From 1a7b303351695f1eb7bca4ae1cf17b760728979b Mon Sep 17 00:00:00 2001 From: Sun Yimin Date: Thu, 1 Aug 2024 11:44:17 +0800 Subject: [PATCH] Generate code for SM2 --- Makefile.examples | 2 + fiat-bedrock2/src/sm2_32.c | 5472 ++ fiat-bedrock2/src/sm2_64.c | 2185 + fiat-bedrock2/src/sm2_scalar_32.c | 5908 ++ fiat-bedrock2/src/sm2_scalar_64.c | 2201 + fiat-c/src/sm2_32.c | 5446 ++ fiat-c/src/sm2_64.c | 2167 + fiat-c/src/sm2_scalar_32.c | 5846 ++ fiat-c/src/sm2_scalar_64.c | 2215 + fiat-go/32/sm2/sm2.go | 5075 ++ fiat-go/32/sm2scalar/sm2scalar | 5459 ++ fiat-go/64/sm2/sm2.go | 1858 + fiat-go/64/sm2scalar/sm2scalar.go | 1890 + fiat-java/src/FiatSm2.java | 5231 ++ fiat-java/src/FiatSm2Scalar.java | 5647 ++ fiat-json/src/sm2_32.json | 81085 ++++++++++++++++++++++++++ fiat-json/src/sm2_64.json | 28639 +++++++++ fiat-json/src/sm2_scalar_32.json | 86944 ++++++++++++++++++++++++++++ fiat-json/src/sm2_scalar_64.json | 29169 ++++++++++ fiat-rust/src/lib.rs | 4 + fiat-rust/src/sm2_32.rs | 5218 ++ fiat-rust/src/sm2_64.rs | 1985 + fiat-rust/src/sm2_scalar_32.rs | 5634 ++ fiat-rust/src/sm2_scalar_64.rs | 2033 + fiat-zig/src/sm2_32.zig | 5208 ++ fiat-zig/src/sm2_64.zig | 1975 + fiat-zig/src/sm2_scalar_32.zig | 5624 ++ fiat-zig/src/sm2_scalar_64.zig | 2023 + 28 files changed, 312143 insertions(+) create mode 100644 fiat-bedrock2/src/sm2_32.c create mode 100644 fiat-bedrock2/src/sm2_64.c create mode 100644 fiat-bedrock2/src/sm2_scalar_32.c create mode 100644 fiat-bedrock2/src/sm2_scalar_64.c create mode 100644 fiat-c/src/sm2_32.c create mode 100644 fiat-c/src/sm2_64.c create mode 100644 fiat-c/src/sm2_scalar_32.c create mode 100644 fiat-c/src/sm2_scalar_64.c create mode 100644 fiat-go/32/sm2/sm2.go create mode 100644 fiat-go/32/sm2scalar/sm2scalar create mode 100644 fiat-go/64/sm2/sm2.go create mode 100644 fiat-go/64/sm2scalar/sm2scalar.go create mode 100644 fiat-java/src/FiatSm2.java create mode 100644 fiat-java/src/FiatSm2Scalar.java create mode 100644 fiat-json/src/sm2_32.json create mode 100644 fiat-json/src/sm2_64.json create mode 100644 fiat-json/src/sm2_scalar_32.json create mode 100644 fiat-json/src/sm2_scalar_64.json create mode 100644 fiat-rust/src/sm2_32.rs create mode 100644 fiat-rust/src/sm2_64.rs create mode 100644 fiat-rust/src/sm2_scalar_32.rs create mode 100644 fiat-rust/src/sm2_scalar_64.rs create mode 100644 fiat-zig/src/sm2_32.zig create mode 100644 fiat-zig/src/sm2_64.zig create mode 100644 fiat-zig/src/sm2_scalar_32.zig create mode 100644 fiat-zig/src/sm2_scalar_64.zig diff --git a/Makefile.examples b/Makefile.examples index 5b0905b7709..8b7532e3697 100644 --- a/Makefile.examples +++ b/Makefile.examples @@ -123,11 +123,13 @@ $(foreach bw,64 32,$(eval $(call add_curve_keys,secp256k1_montgomery_$(bw),WORD_ $(foreach bw,64 32,$(eval $(call add_curve_keys,p384_$(bw),WORD_BY_WORD_MONTGOMERY,'p384',$(bw),'2^384 - 2^128 - 2^96 + 2^32 - 1',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) $(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,sm2_$(bw),WORD_BY_WORD_MONTGOMERY,'sm2',$(bw),'2^256 - 2^224 - 2^96 + 2^64 - 1',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) $(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_montgomery_scalar_$(bw),WORD_BY_WORD_MONTGOMERY,'secp256k1_montgomery_scalar',$(bw),'2^256 - 432420386565659656852420866394968145599',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) +$(foreach bw,64 32,$(eval $(call add_curve_keys,sm2_scalar_$(bw),WORD_BY_WORD_MONTGOMERY,'sm2_scalar',$(bw),'2^256 - 2^224 - 188730267045675049073202170516080344797',$(WORD_BY_WORD_MONTGOMERY_FUNCTIONS),WORD_BY_WORD_MONTGOMERY))) $(foreach bw,64,$(eval $(call add_curve_keys,secp256k1_dettman_$(bw),DETTMAN_MULTIPLICATION,'secp256k1_dettman',$(bw),5 48 2 '2^256 - 4294968273',$(DETTMAN_MULTIPLICATION_FUNCTIONS),DETTMAN_MULTIPLICATION))) $(foreach bw,32,$(eval $(call add_curve_keys,secp256k1_dettman_$(bw),DETTMAN_MULTIPLICATION,'secp256k1_dettman',$(bw),10 22 6 '2^256 - 4294968273',$(DETTMAN_MULTIPLICATION_FUNCTIONS),DETTMAN_MULTIPLICATION))) diff --git a/fiat-bedrock2/src/sm2_32.c b/fiat-bedrock2/src/sm2_32.c new file mode 100644 index 00000000000..09687640168 --- /dev/null +++ b/fiat-bedrock2/src/sm2_32.c @@ -0,0 +1,5472 @@ +/* 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 sm2 32 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2 */ +/* 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") */ +/* */ +/* 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 +#include + +static __attribute__((constructor)) void _br2_preconditions(void) { + static_assert(~(intptr_t)0 == -(intptr_t)1, "two's complement"); + assert(((void)"two's complement", ~(intptr_t)0 == -(intptr_t)1)); + uintptr_t u = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&u)); + intptr_t i = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&i)); +} + +// 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 inline __attribute__((always_inline, unused)) +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 inline __attribute__((always_inline, unused)) +void _br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_mulhuu(uintptr_t a, uintptr_t b) { + #if (UINTPTR_MAX == (UINTMAX_C(1)<<31) - 1 + (UINTMAX_C(1)<<31)) + return ((uint64_t)a * b) >> 32; + #elif (UINTPTR_MAX == (UINTMAX_C(1)<<63) - 1 + (UINTMAX_C(1)<<63)) + return ((unsigned __int128)a * b) >> 64; + #else + #error "32-bit or 64-bit uintptr_t required" + #endif +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_divu(uintptr_t a, uintptr_t b) { + if (!b) return -1; + return a/b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_remu(uintptr_t a, uintptr_t b) { + if (!b) return a; + return a%b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_shamt(uintptr_t a) { + return a&(sizeof(uintptr_t)*8-1); +} + + +/* + * 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_sm2_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, x83, x86, x88, x84, x79, x82, x91, x80, x92, x77, x93, x95, x96, x78, x97, x75, x98, x100, x101, x76, x102, x73, x103, x105, x106, x74, x85, x108, x38, x109, x40, x110, x87, x111, x113, x114, x44, x115, x89, x116, x118, x119, x49, x120, x81, x121, x123, x124, x54, x125, x90, x126, x128, x129, x59, x130, x94, x131, x133, x134, x64, x135, x99, x136, x138, x139, x69, x140, x104, x141, x143, x144, x72, x145, x107, x146, x148, x16, x162, x165, x167, x163, x168, x160, x169, x171, x172, x161, x173, x158, x174, x176, x177, x159, x178, x156, x179, x181, x182, x157, x183, x154, x184, x186, x187, x155, x188, x152, x189, x191, x192, x153, x193, x150, x194, x196, x197, x151, x164, x112, x200, x117, x201, x166, 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, x147, x231, x195, x232, x234, x235, x149, x236, x198, x237, x239, x251, x254, x256, x252, x247, x250, x259, x248, x260, x245, x261, x263, x264, x246, x265, x243, x266, x268, x269, x244, x270, x241, x271, x273, x274, x242, x253, x276, x199, x277, x203, x278, x255, x279, x281, x282, x208, x283, x257, x284, x286, x287, x213, x288, x249, x289, x291, x292, x218, x293, x258, x294, x296, x297, x223, x298, x262, x299, x301, x302, x228, x303, x267, x304, x306, x307, x233, x308, x272, x309, x311, x312, x238, x313, x275, x314, x316, x317, x240, x17, x331, x334, x336, x332, x337, x329, x338, x340, x341, x330, x342, x327, x343, x345, x346, x328, x347, x325, x348, x350, x351, x326, x352, x323, x353, x355, x356, x324, x357, x321, x358, x360, x361, x322, x362, x319, x363, x365, x366, x320, x333, x280, x369, x285, x370, x335, x371, x373, x374, x290, x375, x339, x376, x378, x379, x295, x380, x344, x381, x383, x384, x300, x385, x349, x386, x388, x389, x305, x390, x354, x391, x393, x394, x310, x395, x359, x396, x398, x399, x315, x400, x364, x401, x403, x404, x318, x405, x367, x406, x408, x420, x423, x425, x421, x416, x419, x428, x417, x429, x414, x430, x432, x433, x415, x434, x412, x435, x437, x438, x413, x439, x410, x440, x442, x443, x411, x422, x445, x368, x446, x372, x447, x424, x448, x450, x451, x377, x452, x426, x453, x455, x456, x382, x457, x418, x458, x460, x461, x387, x462, x427, x463, x465, x466, x392, x467, x431, x468, x470, x471, x397, x472, x436, x473, x475, x476, x402, x477, x441, x478, x480, x481, x407, x482, x444, x483, x485, x486, x409, x18, x500, x503, x505, x501, x506, x498, x507, x509, x510, x499, x511, x496, x512, x514, x515, x497, x516, x494, x517, x519, x520, x495, x521, x492, x522, x524, x525, x493, x526, x490, x527, x529, x530, x491, x531, x488, x532, x534, x535, x489, x502, x449, x538, x454, x539, x504, x540, x542, x543, x459, x544, x508, x545, x547, x548, x464, x549, x513, x550, x552, x553, x469, x554, x518, x555, x557, x558, x474, x559, x523, x560, x562, x563, x479, x564, x528, x565, x567, x568, x484, x569, x533, x570, x572, x573, x487, x574, x536, x575, x577, x589, x592, x594, x590, x585, x588, x597, x586, x598, x583, x599, x601, x602, x584, x603, x581, x604, x606, x607, x582, x608, x579, x609, x611, x612, x580, x591, x614, x537, x615, x541, x616, x593, x617, x619, x620, x546, x621, x595, x622, x624, x625, x551, x626, x587, x627, x629, x630, x556, x631, x596, x632, x634, x635, x561, x636, x600, x637, x639, x640, x566, x641, x605, x642, x644, x645, x571, x646, x610, x647, x649, x650, x576, x651, x613, x652, x654, x655, x578, x19, x669, x672, x674, x670, x675, x667, x676, x678, x679, x668, x680, x665, x681, x683, x684, x666, x685, x663, x686, x688, x689, x664, x690, x661, x691, x693, x694, x662, x695, x659, x696, x698, x699, x660, x700, x657, x701, x703, x704, x658, x671, x618, x707, x623, x708, x673, x709, x711, x712, x628, x713, x677, x714, x716, x717, x633, x718, x682, x719, x721, x722, x638, x723, x687, x724, x726, x727, x643, x728, x692, x729, x731, x732, x648, x733, x697, x734, x736, x737, x653, x738, x702, x739, x741, x742, x656, x743, x705, x744, x746, x758, x761, x763, x759, x754, x757, x766, x755, x767, x752, x768, x770, x771, x753, x772, x750, x773, x775, x776, x751, x777, x748, x778, x780, x781, x749, x760, x783, x706, x784, x710, x785, x762, x786, x788, x789, x715, x790, x764, x791, x793, x794, x720, x795, x756, x796, x798, x799, x725, x800, x765, x801, x803, x804, x730, x805, x769, x806, x808, x809, x735, x810, x774, x811, x813, x814, x740, x815, x779, x816, x818, x819, x745, x820, x782, x821, x823, x824, x747, x20, x838, x841, x843, x839, x844, x836, x845, x847, x848, x837, x849, x834, x850, x852, x853, x835, x854, x832, x855, x857, x858, x833, x859, x830, x860, x862, x863, x831, x864, x828, x865, x867, x868, x829, x869, x826, x870, x872, x873, x827, x840, x787, x876, x792, x877, x842, x878, x880, x881, x797, x882, x846, x883, x885, x886, x802, x887, x851, x888, x890, x891, x807, x892, x856, x893, x895, x896, x812, x897, x861, x898, x900, x901, x817, x902, x866, x903, x905, x906, x822, x907, x871, x908, x910, x911, x825, x912, x874, x913, x915, x927, x930, x932, x928, x923, x926, x935, x924, x936, x921, x937, x939, x940, x922, x941, x919, x942, x944, x945, x920, x946, x917, x947, x949, x950, x918, x929, x952, x875, x953, x879, x954, x931, x955, x957, x958, x884, x959, x933, x960, x962, x963, x889, x964, x925, x965, x967, x968, x894, x969, x934, x970, x972, x973, x899, x974, x938, x975, x977, x978, x904, x979, x943, x980, x982, x983, x909, x984, x948, x985, x987, x988, x914, x989, x951, x990, x992, x993, x916, x21, x1007, x1010, x1012, x1008, x1013, x1005, x1014, x1016, x1017, x1006, x1018, x1003, x1019, x1021, x1022, x1004, x1023, x1001, x1024, x1026, x1027, x1002, x1028, x999, x1029, x1031, x1032, x1000, x1033, x997, x1034, x1036, x1037, x998, x1038, x995, x1039, x1041, x1042, x996, x1009, x956, x1045, x961, x1046, x1011, x1047, x1049, x1050, x966, x1051, x1015, x1052, x1054, x1055, x971, x1056, x1020, 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, x994, x1081, x1043, x1082, x1084, x1096, x1099, x1101, x1097, x1092, x1095, x1104, x1093, x1105, x1090, x1106, x1108, x1109, x1091, x1110, x1088, x1111, x1113, x1114, x1089, x1115, x1086, x1116, x1118, x1119, x1087, x1098, x1121, x1044, x1122, x1048, x1123, x1100, x1124, x1126, x1127, x1053, x1128, x1102, x1129, x1131, x1132, x1058, x1133, x1094, x1134, x1136, x1137, x1063, x1138, x1103, x1139, x1141, x1142, x1068, x1143, x1107, x1144, x1146, x1147, x1073, x1148, x1112, x1149, x1151, x1152, x1078, x1153, x1117, x1154, x1156, x1157, x1083, x1158, x1120, x1159, x1161, x1162, x1085, x15, x14, x13, x12, x11, x10, x9, x22, x8, x1176, x1179, x1181, x1177, x1182, x1174, x1183, x1185, x1186, x1175, x1187, x1172, x1188, x1190, x1191, x1173, x1192, x1170, x1193, x1195, x1196, x1171, x1197, x1168, x1198, x1200, x1201, x1169, x1202, x1166, x1203, x1205, x1206, x1167, x1207, x1164, x1208, x1210, x1211, x1165, x1178, x1125, x1214, x1130, x1215, x1180, x1216, x1218, x1219, x1135, x1220, x1184, x1221, x1223, x1224, x1140, x1225, x1189, x1226, x1228, x1229, x1145, x1230, x1194, x1231, x1233, x1234, x1150, x1235, x1199, x1236, x1238, x1239, x1155, x1240, x1204, x1241, x1243, x1244, x1160, x1245, x1209, x1246, x1248, x1249, x1163, x1250, x1212, x1251, x1253, x1265, x1268, x1270, x1266, x1261, x1264, x1273, x1262, x1274, x1259, x1275, x1277, x1278, x1260, x1279, x1257, x1280, x1282, x1283, x1258, x1284, x1255, x1285, x1287, x1288, x1256, x1267, x1290, x1213, x1291, x1217, x1292, x1269, x1293, x1295, x1296, x1222, x1297, x1271, x1298, x1300, x1301, x1227, x1302, x1263, x1303, x1305, x1306, x1232, x1307, x1272, x1308, x1310, x1311, x1237, x1312, x1276, x1313, x1315, x1316, x1242, x1317, x1281, x1318, x1320, x1321, x1247, x1322, x1286, x1323, x1325, x1326, x1252, x1327, x1289, x1328, x1330, x1331, x1254, x1334, x1335, x1336, x1338, x1339, x1341, x1342, x1343, x1345, x1346, x1347, x1348, x1350, x1351, x1352, x1353, x1355, x1356, x1357, x1358, x1360, x1361, x1362, x1363, x1365, x1366, x1332, x1367, x1294, x1369, x1333, x1370, x1299, x1372, x1337, x1373, x1304, x1375, x1340, x1376, x1309, x1378, x1344, x1379, x1314, x1381, x1349, x1382, x1319, x1384, x1354, x1385, x1324, x1387, x1359, x1388, x1368, x1329, x1390, x1364, x1391, x1371, x1374, x1377, x1380, x1383, x1386, x1389, x1392, x1393, x1394, x1395, x1396, x1397, x1398, x1399, x1400; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), 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 = _br2_mulhuu((x23), (x15)); + x26 = (x23)*(x14); + x27 = _br2_mulhuu((x23), (x14)); + x28 = (x23)*(x13); + x29 = _br2_mulhuu((x23), (x13)); + x30 = (x23)*(x12); + x31 = _br2_mulhuu((x23), (x12)); + x32 = (x23)*(x11); + x33 = _br2_mulhuu((x23), (x11)); + x34 = (x23)*(x10); + x35 = _br2_mulhuu((x23), (x10)); + x36 = (x23)*(x9); + x37 = _br2_mulhuu((x23), (x9)); + x38 = (x23)*(x8); + x39 = _br2_mulhuu((x23), (x8)); + 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)(UINTMAX_C(4294967294))); + x74 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967294)))); + x75 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x76 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x77 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x78 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x79 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x80 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x81 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x82 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x83 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x84 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x85 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x86 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x87 = (x86)+(x83); + x88 = (uintptr_t)((x87)<(x86)); + x89 = (x88)+(x84); + x90 = (x82)+(x79); + x91 = (uintptr_t)((x90)<(x82)); + x92 = (x91)+(x80); + x93 = (uintptr_t)((x92)<(x80)); + x94 = (x92)+(x77); + x95 = (uintptr_t)((x94)<(x77)); + x96 = (x93)+(x95); + x97 = (x96)+(x78); + x98 = (uintptr_t)((x97)<(x78)); + x99 = (x97)+(x75); + x100 = (uintptr_t)((x99)<(x75)); + x101 = (x98)+(x100); + x102 = (x101)+(x76); + x103 = (uintptr_t)((x102)<(x76)); + x104 = (x102)+(x73); + x105 = (uintptr_t)((x104)<(x73)); + x106 = (x103)+(x105); + x107 = (x106)+(x74); + x108 = (x38)+(x85); + x109 = (uintptr_t)((x108)<(x38)); + x110 = (x109)+(x40); + x111 = (uintptr_t)((x110)<(x40)); + x112 = (x110)+(x87); + x113 = (uintptr_t)((x112)<(x87)); + x114 = (x111)+(x113); + x115 = (x114)+(x44); + x116 = (uintptr_t)((x115)<(x44)); + x117 = (x115)+(x89); + x118 = (uintptr_t)((x117)<(x89)); + x119 = (x116)+(x118); + x120 = (x119)+(x49); + x121 = (uintptr_t)((x120)<(x49)); + x122 = (x120)+(x81); + x123 = (uintptr_t)((x122)<(x81)); + x124 = (x121)+(x123); + x125 = (x124)+(x54); + x126 = (uintptr_t)((x125)<(x54)); + x127 = (x125)+(x90); + x128 = (uintptr_t)((x127)<(x90)); + x129 = (x126)+(x128); + x130 = (x129)+(x59); + x131 = (uintptr_t)((x130)<(x59)); + x132 = (x130)+(x94); + x133 = (uintptr_t)((x132)<(x94)); + x134 = (x131)+(x133); + x135 = (x134)+(x64); + x136 = (uintptr_t)((x135)<(x64)); + x137 = (x135)+(x99); + x138 = (uintptr_t)((x137)<(x99)); + x139 = (x136)+(x138); + x140 = (x139)+(x69); + x141 = (uintptr_t)((x140)<(x69)); + x142 = (x140)+(x104); + x143 = (uintptr_t)((x142)<(x104)); + x144 = (x141)+(x143); + x145 = (x144)+(x72); + x146 = (uintptr_t)((x145)<(x72)); + x147 = (x145)+(x107); + x148 = (uintptr_t)((x147)<(x107)); + x149 = (x146)+(x148); + x150 = (x16)*(x15); + x151 = _br2_mulhuu((x16), (x15)); + x152 = (x16)*(x14); + x153 = _br2_mulhuu((x16), (x14)); + x154 = (x16)*(x13); + x155 = _br2_mulhuu((x16), (x13)); + x156 = (x16)*(x12); + x157 = _br2_mulhuu((x16), (x12)); + x158 = (x16)*(x11); + x159 = _br2_mulhuu((x16), (x11)); + x160 = (x16)*(x10); + x161 = _br2_mulhuu((x16), (x10)); + x162 = (x16)*(x9); + x163 = _br2_mulhuu((x16), (x9)); + x164 = (x16)*(x8); + x165 = _br2_mulhuu((x16), (x8)); + x166 = (x165)+(x162); + x167 = (uintptr_t)((x166)<(x165)); + x168 = (x167)+(x163); + x169 = (uintptr_t)((x168)<(x163)); + x170 = (x168)+(x160); + x171 = (uintptr_t)((x170)<(x160)); + x172 = (x169)+(x171); + x173 = (x172)+(x161); + x174 = (uintptr_t)((x173)<(x161)); + x175 = (x173)+(x158); + x176 = (uintptr_t)((x175)<(x158)); + x177 = (x174)+(x176); + x178 = (x177)+(x159); + x179 = (uintptr_t)((x178)<(x159)); + x180 = (x178)+(x156); + x181 = (uintptr_t)((x180)<(x156)); + x182 = (x179)+(x181); + x183 = (x182)+(x157); + x184 = (uintptr_t)((x183)<(x157)); + x185 = (x183)+(x154); + x186 = (uintptr_t)((x185)<(x154)); + x187 = (x184)+(x186); + x188 = (x187)+(x155); + x189 = (uintptr_t)((x188)<(x155)); + x190 = (x188)+(x152); + x191 = (uintptr_t)((x190)<(x152)); + x192 = (x189)+(x191); + x193 = (x192)+(x153); + x194 = (uintptr_t)((x193)<(x153)); + x195 = (x193)+(x150); + x196 = (uintptr_t)((x195)<(x150)); + x197 = (x194)+(x196); + x198 = (x197)+(x151); + x199 = (x112)+(x164); + x200 = (uintptr_t)((x199)<(x112)); + x201 = (x200)+(x117); + x202 = (uintptr_t)((x201)<(x117)); + x203 = (x201)+(x166); + x204 = (uintptr_t)((x203)<(x166)); + 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)+(x147); + x232 = (uintptr_t)((x231)<(x147)); + x233 = (x231)+(x195); + x234 = (uintptr_t)((x233)<(x195)); + x235 = (x232)+(x234); + x236 = (x235)+(x149); + x237 = (uintptr_t)((x236)<(x149)); + x238 = (x236)+(x198); + x239 = (uintptr_t)((x238)<(x198)); + x240 = (x237)+(x239); + x241 = (x199)*((uintptr_t)(UINTMAX_C(4294967294))); + x242 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967294)))); + x243 = (x199)*((uintptr_t)(UINTMAX_C(4294967295))); + x244 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967295)))); + x245 = (x199)*((uintptr_t)(UINTMAX_C(4294967295))); + x246 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967295)))); + x247 = (x199)*((uintptr_t)(UINTMAX_C(4294967295))); + x248 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967295)))); + x249 = (x199)*((uintptr_t)(UINTMAX_C(4294967295))); + x250 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967295)))); + x251 = (x199)*((uintptr_t)(UINTMAX_C(4294967295))); + x252 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967295)))); + x253 = (x199)*((uintptr_t)(UINTMAX_C(4294967295))); + x254 = _br2_mulhuu((x199), ((uintptr_t)(UINTMAX_C(4294967295)))); + x255 = (x254)+(x251); + x256 = (uintptr_t)((x255)<(x254)); + x257 = (x256)+(x252); + x258 = (x250)+(x247); + x259 = (uintptr_t)((x258)<(x250)); + x260 = (x259)+(x248); + x261 = (uintptr_t)((x260)<(x248)); + x262 = (x260)+(x245); + x263 = (uintptr_t)((x262)<(x245)); + x264 = (x261)+(x263); + x265 = (x264)+(x246); + x266 = (uintptr_t)((x265)<(x246)); + x267 = (x265)+(x243); + x268 = (uintptr_t)((x267)<(x243)); + x269 = (x266)+(x268); + x270 = (x269)+(x244); + x271 = (uintptr_t)((x270)<(x244)); + x272 = (x270)+(x241); + x273 = (uintptr_t)((x272)<(x241)); + x274 = (x271)+(x273); + x275 = (x274)+(x242); + x276 = (x199)+(x253); + x277 = (uintptr_t)((x276)<(x199)); + x278 = (x277)+(x203); + x279 = (uintptr_t)((x278)<(x203)); + x280 = (x278)+(x255); + x281 = (uintptr_t)((x280)<(x255)); + x282 = (x279)+(x281); + x283 = (x282)+(x208); + x284 = (uintptr_t)((x283)<(x208)); + x285 = (x283)+(x257); + x286 = (uintptr_t)((x285)<(x257)); + x287 = (x284)+(x286); + x288 = (x287)+(x213); + x289 = (uintptr_t)((x288)<(x213)); + x290 = (x288)+(x249); + x291 = (uintptr_t)((x290)<(x249)); + x292 = (x289)+(x291); + x293 = (x292)+(x218); + x294 = (uintptr_t)((x293)<(x218)); + x295 = (x293)+(x258); + x296 = (uintptr_t)((x295)<(x258)); + x297 = (x294)+(x296); + x298 = (x297)+(x223); + x299 = (uintptr_t)((x298)<(x223)); + x300 = (x298)+(x262); + x301 = (uintptr_t)((x300)<(x262)); + x302 = (x299)+(x301); + x303 = (x302)+(x228); + x304 = (uintptr_t)((x303)<(x228)); + x305 = (x303)+(x267); + x306 = (uintptr_t)((x305)<(x267)); + x307 = (x304)+(x306); + x308 = (x307)+(x233); + x309 = (uintptr_t)((x308)<(x233)); + x310 = (x308)+(x272); + x311 = (uintptr_t)((x310)<(x272)); + x312 = (x309)+(x311); + x313 = (x312)+(x238); + x314 = (uintptr_t)((x313)<(x238)); + x315 = (x313)+(x275); + x316 = (uintptr_t)((x315)<(x275)); + x317 = (x314)+(x316); + x318 = (x317)+(x240); + x319 = (x17)*(x15); + x320 = _br2_mulhuu((x17), (x15)); + x321 = (x17)*(x14); + x322 = _br2_mulhuu((x17), (x14)); + x323 = (x17)*(x13); + x324 = _br2_mulhuu((x17), (x13)); + x325 = (x17)*(x12); + x326 = _br2_mulhuu((x17), (x12)); + x327 = (x17)*(x11); + x328 = _br2_mulhuu((x17), (x11)); + x329 = (x17)*(x10); + x330 = _br2_mulhuu((x17), (x10)); + x331 = (x17)*(x9); + x332 = _br2_mulhuu((x17), (x9)); + x333 = (x17)*(x8); + x334 = _br2_mulhuu((x17), (x8)); + x335 = (x334)+(x331); + x336 = (uintptr_t)((x335)<(x334)); + x337 = (x336)+(x332); + x338 = (uintptr_t)((x337)<(x332)); + x339 = (x337)+(x329); + x340 = (uintptr_t)((x339)<(x329)); + x341 = (x338)+(x340); + x342 = (x341)+(x330); + x343 = (uintptr_t)((x342)<(x330)); + x344 = (x342)+(x327); + x345 = (uintptr_t)((x344)<(x327)); + x346 = (x343)+(x345); + x347 = (x346)+(x328); + x348 = (uintptr_t)((x347)<(x328)); + x349 = (x347)+(x325); + x350 = (uintptr_t)((x349)<(x325)); + x351 = (x348)+(x350); + x352 = (x351)+(x326); + x353 = (uintptr_t)((x352)<(x326)); + x354 = (x352)+(x323); + x355 = (uintptr_t)((x354)<(x323)); + x356 = (x353)+(x355); + x357 = (x356)+(x324); + x358 = (uintptr_t)((x357)<(x324)); + x359 = (x357)+(x321); + x360 = (uintptr_t)((x359)<(x321)); + x361 = (x358)+(x360); + x362 = (x361)+(x322); + x363 = (uintptr_t)((x362)<(x322)); + x364 = (x362)+(x319); + x365 = (uintptr_t)((x364)<(x319)); + x366 = (x363)+(x365); + x367 = (x366)+(x320); + x368 = (x280)+(x333); + x369 = (uintptr_t)((x368)<(x280)); + x370 = (x369)+(x285); + x371 = (uintptr_t)((x370)<(x285)); + x372 = (x370)+(x335); + x373 = (uintptr_t)((x372)<(x335)); + x374 = (x371)+(x373); + x375 = (x374)+(x290); + x376 = (uintptr_t)((x375)<(x290)); + x377 = (x375)+(x339); + x378 = (uintptr_t)((x377)<(x339)); + x379 = (x376)+(x378); + x380 = (x379)+(x295); + x381 = (uintptr_t)((x380)<(x295)); + x382 = (x380)+(x344); + x383 = (uintptr_t)((x382)<(x344)); + x384 = (x381)+(x383); + x385 = (x384)+(x300); + x386 = (uintptr_t)((x385)<(x300)); + x387 = (x385)+(x349); + x388 = (uintptr_t)((x387)<(x349)); + x389 = (x386)+(x388); + x390 = (x389)+(x305); + x391 = (uintptr_t)((x390)<(x305)); + x392 = (x390)+(x354); + x393 = (uintptr_t)((x392)<(x354)); + x394 = (x391)+(x393); + x395 = (x394)+(x310); + x396 = (uintptr_t)((x395)<(x310)); + x397 = (x395)+(x359); + x398 = (uintptr_t)((x397)<(x359)); + x399 = (x396)+(x398); + x400 = (x399)+(x315); + x401 = (uintptr_t)((x400)<(x315)); + x402 = (x400)+(x364); + x403 = (uintptr_t)((x402)<(x364)); + x404 = (x401)+(x403); + x405 = (x404)+(x318); + x406 = (uintptr_t)((x405)<(x318)); + x407 = (x405)+(x367); + x408 = (uintptr_t)((x407)<(x367)); + x409 = (x406)+(x408); + x410 = (x368)*((uintptr_t)(UINTMAX_C(4294967294))); + x411 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967294)))); + x412 = (x368)*((uintptr_t)(UINTMAX_C(4294967295))); + x413 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967295)))); + x414 = (x368)*((uintptr_t)(UINTMAX_C(4294967295))); + x415 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967295)))); + x416 = (x368)*((uintptr_t)(UINTMAX_C(4294967295))); + x417 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967295)))); + x418 = (x368)*((uintptr_t)(UINTMAX_C(4294967295))); + x419 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967295)))); + x420 = (x368)*((uintptr_t)(UINTMAX_C(4294967295))); + x421 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967295)))); + x422 = (x368)*((uintptr_t)(UINTMAX_C(4294967295))); + x423 = _br2_mulhuu((x368), ((uintptr_t)(UINTMAX_C(4294967295)))); + x424 = (x423)+(x420); + x425 = (uintptr_t)((x424)<(x423)); + x426 = (x425)+(x421); + x427 = (x419)+(x416); + x428 = (uintptr_t)((x427)<(x419)); + x429 = (x428)+(x417); + x430 = (uintptr_t)((x429)<(x417)); + x431 = (x429)+(x414); + x432 = (uintptr_t)((x431)<(x414)); + x433 = (x430)+(x432); + x434 = (x433)+(x415); + x435 = (uintptr_t)((x434)<(x415)); + x436 = (x434)+(x412); + x437 = (uintptr_t)((x436)<(x412)); + x438 = (x435)+(x437); + x439 = (x438)+(x413); + x440 = (uintptr_t)((x439)<(x413)); + x441 = (x439)+(x410); + x442 = (uintptr_t)((x441)<(x410)); + x443 = (x440)+(x442); + x444 = (x443)+(x411); + x445 = (x368)+(x422); + x446 = (uintptr_t)((x445)<(x368)); + x447 = (x446)+(x372); + x448 = (uintptr_t)((x447)<(x372)); + x449 = (x447)+(x424); + x450 = (uintptr_t)((x449)<(x424)); + x451 = (x448)+(x450); + x452 = (x451)+(x377); + x453 = (uintptr_t)((x452)<(x377)); + x454 = (x452)+(x426); + x455 = (uintptr_t)((x454)<(x426)); + x456 = (x453)+(x455); + x457 = (x456)+(x382); + x458 = (uintptr_t)((x457)<(x382)); + x459 = (x457)+(x418); + x460 = (uintptr_t)((x459)<(x418)); + x461 = (x458)+(x460); + x462 = (x461)+(x387); + x463 = (uintptr_t)((x462)<(x387)); + x464 = (x462)+(x427); + x465 = (uintptr_t)((x464)<(x427)); + x466 = (x463)+(x465); + x467 = (x466)+(x392); + x468 = (uintptr_t)((x467)<(x392)); + x469 = (x467)+(x431); + x470 = (uintptr_t)((x469)<(x431)); + x471 = (x468)+(x470); + x472 = (x471)+(x397); + x473 = (uintptr_t)((x472)<(x397)); + x474 = (x472)+(x436); + x475 = (uintptr_t)((x474)<(x436)); + x476 = (x473)+(x475); + x477 = (x476)+(x402); + x478 = (uintptr_t)((x477)<(x402)); + x479 = (x477)+(x441); + x480 = (uintptr_t)((x479)<(x441)); + x481 = (x478)+(x480); + x482 = (x481)+(x407); + x483 = (uintptr_t)((x482)<(x407)); + x484 = (x482)+(x444); + x485 = (uintptr_t)((x484)<(x444)); + x486 = (x483)+(x485); + x487 = (x486)+(x409); + x488 = (x18)*(x15); + x489 = _br2_mulhuu((x18), (x15)); + x490 = (x18)*(x14); + x491 = _br2_mulhuu((x18), (x14)); + x492 = (x18)*(x13); + x493 = _br2_mulhuu((x18), (x13)); + x494 = (x18)*(x12); + x495 = _br2_mulhuu((x18), (x12)); + x496 = (x18)*(x11); + x497 = _br2_mulhuu((x18), (x11)); + x498 = (x18)*(x10); + x499 = _br2_mulhuu((x18), (x10)); + x500 = (x18)*(x9); + x501 = _br2_mulhuu((x18), (x9)); + x502 = (x18)*(x8); + x503 = _br2_mulhuu((x18), (x8)); + x504 = (x503)+(x500); + x505 = (uintptr_t)((x504)<(x503)); + x506 = (x505)+(x501); + x507 = (uintptr_t)((x506)<(x501)); + x508 = (x506)+(x498); + x509 = (uintptr_t)((x508)<(x498)); + x510 = (x507)+(x509); + x511 = (x510)+(x499); + x512 = (uintptr_t)((x511)<(x499)); + x513 = (x511)+(x496); + x514 = (uintptr_t)((x513)<(x496)); + x515 = (x512)+(x514); + x516 = (x515)+(x497); + x517 = (uintptr_t)((x516)<(x497)); + x518 = (x516)+(x494); + x519 = (uintptr_t)((x518)<(x494)); + x520 = (x517)+(x519); + x521 = (x520)+(x495); + x522 = (uintptr_t)((x521)<(x495)); + x523 = (x521)+(x492); + x524 = (uintptr_t)((x523)<(x492)); + x525 = (x522)+(x524); + x526 = (x525)+(x493); + x527 = (uintptr_t)((x526)<(x493)); + x528 = (x526)+(x490); + x529 = (uintptr_t)((x528)<(x490)); + x530 = (x527)+(x529); + x531 = (x530)+(x491); + x532 = (uintptr_t)((x531)<(x491)); + x533 = (x531)+(x488); + x534 = (uintptr_t)((x533)<(x488)); + x535 = (x532)+(x534); + x536 = (x535)+(x489); + x537 = (x449)+(x502); + x538 = (uintptr_t)((x537)<(x449)); + x539 = (x538)+(x454); + x540 = (uintptr_t)((x539)<(x454)); + x541 = (x539)+(x504); + x542 = (uintptr_t)((x541)<(x504)); + x543 = (x540)+(x542); + x544 = (x543)+(x459); + x545 = (uintptr_t)((x544)<(x459)); + x546 = (x544)+(x508); + x547 = (uintptr_t)((x546)<(x508)); + x548 = (x545)+(x547); + x549 = (x548)+(x464); + x550 = (uintptr_t)((x549)<(x464)); + x551 = (x549)+(x513); + x552 = (uintptr_t)((x551)<(x513)); + x553 = (x550)+(x552); + x554 = (x553)+(x469); + x555 = (uintptr_t)((x554)<(x469)); + x556 = (x554)+(x518); + x557 = (uintptr_t)((x556)<(x518)); + x558 = (x555)+(x557); + x559 = (x558)+(x474); + x560 = (uintptr_t)((x559)<(x474)); + x561 = (x559)+(x523); + x562 = (uintptr_t)((x561)<(x523)); + x563 = (x560)+(x562); + x564 = (x563)+(x479); + x565 = (uintptr_t)((x564)<(x479)); + x566 = (x564)+(x528); + x567 = (uintptr_t)((x566)<(x528)); + x568 = (x565)+(x567); + x569 = (x568)+(x484); + x570 = (uintptr_t)((x569)<(x484)); + x571 = (x569)+(x533); + x572 = (uintptr_t)((x571)<(x533)); + x573 = (x570)+(x572); + x574 = (x573)+(x487); + x575 = (uintptr_t)((x574)<(x487)); + x576 = (x574)+(x536); + x577 = (uintptr_t)((x576)<(x536)); + x578 = (x575)+(x577); + x579 = (x537)*((uintptr_t)(UINTMAX_C(4294967294))); + x580 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967294)))); + x581 = (x537)*((uintptr_t)(UINTMAX_C(4294967295))); + x582 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967295)))); + x583 = (x537)*((uintptr_t)(UINTMAX_C(4294967295))); + x584 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967295)))); + x585 = (x537)*((uintptr_t)(UINTMAX_C(4294967295))); + x586 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967295)))); + x587 = (x537)*((uintptr_t)(UINTMAX_C(4294967295))); + x588 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967295)))); + x589 = (x537)*((uintptr_t)(UINTMAX_C(4294967295))); + x590 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967295)))); + x591 = (x537)*((uintptr_t)(UINTMAX_C(4294967295))); + x592 = _br2_mulhuu((x537), ((uintptr_t)(UINTMAX_C(4294967295)))); + x593 = (x592)+(x589); + x594 = (uintptr_t)((x593)<(x592)); + x595 = (x594)+(x590); + x596 = (x588)+(x585); + x597 = (uintptr_t)((x596)<(x588)); + x598 = (x597)+(x586); + x599 = (uintptr_t)((x598)<(x586)); + x600 = (x598)+(x583); + x601 = (uintptr_t)((x600)<(x583)); + x602 = (x599)+(x601); + x603 = (x602)+(x584); + x604 = (uintptr_t)((x603)<(x584)); + x605 = (x603)+(x581); + x606 = (uintptr_t)((x605)<(x581)); + x607 = (x604)+(x606); + x608 = (x607)+(x582); + x609 = (uintptr_t)((x608)<(x582)); + x610 = (x608)+(x579); + x611 = (uintptr_t)((x610)<(x579)); + x612 = (x609)+(x611); + x613 = (x612)+(x580); + x614 = (x537)+(x591); + x615 = (uintptr_t)((x614)<(x537)); + x616 = (x615)+(x541); + x617 = (uintptr_t)((x616)<(x541)); + x618 = (x616)+(x593); + x619 = (uintptr_t)((x618)<(x593)); + x620 = (x617)+(x619); + x621 = (x620)+(x546); + x622 = (uintptr_t)((x621)<(x546)); + x623 = (x621)+(x595); + x624 = (uintptr_t)((x623)<(x595)); + x625 = (x622)+(x624); + x626 = (x625)+(x551); + x627 = (uintptr_t)((x626)<(x551)); + x628 = (x626)+(x587); + x629 = (uintptr_t)((x628)<(x587)); + x630 = (x627)+(x629); + x631 = (x630)+(x556); + x632 = (uintptr_t)((x631)<(x556)); + x633 = (x631)+(x596); + x634 = (uintptr_t)((x633)<(x596)); + x635 = (x632)+(x634); + x636 = (x635)+(x561); + x637 = (uintptr_t)((x636)<(x561)); + x638 = (x636)+(x600); + x639 = (uintptr_t)((x638)<(x600)); + x640 = (x637)+(x639); + x641 = (x640)+(x566); + x642 = (uintptr_t)((x641)<(x566)); + x643 = (x641)+(x605); + x644 = (uintptr_t)((x643)<(x605)); + x645 = (x642)+(x644); + x646 = (x645)+(x571); + x647 = (uintptr_t)((x646)<(x571)); + x648 = (x646)+(x610); + x649 = (uintptr_t)((x648)<(x610)); + x650 = (x647)+(x649); + x651 = (x650)+(x576); + x652 = (uintptr_t)((x651)<(x576)); + x653 = (x651)+(x613); + x654 = (uintptr_t)((x653)<(x613)); + x655 = (x652)+(x654); + x656 = (x655)+(x578); + x657 = (x19)*(x15); + x658 = _br2_mulhuu((x19), (x15)); + x659 = (x19)*(x14); + x660 = _br2_mulhuu((x19), (x14)); + x661 = (x19)*(x13); + x662 = _br2_mulhuu((x19), (x13)); + x663 = (x19)*(x12); + x664 = _br2_mulhuu((x19), (x12)); + x665 = (x19)*(x11); + x666 = _br2_mulhuu((x19), (x11)); + x667 = (x19)*(x10); + x668 = _br2_mulhuu((x19), (x10)); + x669 = (x19)*(x9); + x670 = _br2_mulhuu((x19), (x9)); + x671 = (x19)*(x8); + x672 = _br2_mulhuu((x19), (x8)); + x673 = (x672)+(x669); + x674 = (uintptr_t)((x673)<(x672)); + x675 = (x674)+(x670); + x676 = (uintptr_t)((x675)<(x670)); + x677 = (x675)+(x667); + x678 = (uintptr_t)((x677)<(x667)); + x679 = (x676)+(x678); + x680 = (x679)+(x668); + x681 = (uintptr_t)((x680)<(x668)); + x682 = (x680)+(x665); + x683 = (uintptr_t)((x682)<(x665)); + x684 = (x681)+(x683); + x685 = (x684)+(x666); + x686 = (uintptr_t)((x685)<(x666)); + x687 = (x685)+(x663); + x688 = (uintptr_t)((x687)<(x663)); + x689 = (x686)+(x688); + x690 = (x689)+(x664); + x691 = (uintptr_t)((x690)<(x664)); + x692 = (x690)+(x661); + x693 = (uintptr_t)((x692)<(x661)); + x694 = (x691)+(x693); + x695 = (x694)+(x662); + x696 = (uintptr_t)((x695)<(x662)); + x697 = (x695)+(x659); + x698 = (uintptr_t)((x697)<(x659)); + x699 = (x696)+(x698); + x700 = (x699)+(x660); + x701 = (uintptr_t)((x700)<(x660)); + x702 = (x700)+(x657); + x703 = (uintptr_t)((x702)<(x657)); + x704 = (x701)+(x703); + x705 = (x704)+(x658); + x706 = (x618)+(x671); + x707 = (uintptr_t)((x706)<(x618)); + x708 = (x707)+(x623); + x709 = (uintptr_t)((x708)<(x623)); + x710 = (x708)+(x673); + x711 = (uintptr_t)((x710)<(x673)); + x712 = (x709)+(x711); + x713 = (x712)+(x628); + x714 = (uintptr_t)((x713)<(x628)); + x715 = (x713)+(x677); + x716 = (uintptr_t)((x715)<(x677)); + x717 = (x714)+(x716); + x718 = (x717)+(x633); + x719 = (uintptr_t)((x718)<(x633)); + x720 = (x718)+(x682); + x721 = (uintptr_t)((x720)<(x682)); + x722 = (x719)+(x721); + x723 = (x722)+(x638); + x724 = (uintptr_t)((x723)<(x638)); + x725 = (x723)+(x687); + x726 = (uintptr_t)((x725)<(x687)); + x727 = (x724)+(x726); + x728 = (x727)+(x643); + x729 = (uintptr_t)((x728)<(x643)); + x730 = (x728)+(x692); + x731 = (uintptr_t)((x730)<(x692)); + x732 = (x729)+(x731); + x733 = (x732)+(x648); + x734 = (uintptr_t)((x733)<(x648)); + x735 = (x733)+(x697); + x736 = (uintptr_t)((x735)<(x697)); + x737 = (x734)+(x736); + x738 = (x737)+(x653); + x739 = (uintptr_t)((x738)<(x653)); + x740 = (x738)+(x702); + x741 = (uintptr_t)((x740)<(x702)); + x742 = (x739)+(x741); + x743 = (x742)+(x656); + x744 = (uintptr_t)((x743)<(x656)); + x745 = (x743)+(x705); + x746 = (uintptr_t)((x745)<(x705)); + x747 = (x744)+(x746); + x748 = (x706)*((uintptr_t)(UINTMAX_C(4294967294))); + x749 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967294)))); + x750 = (x706)*((uintptr_t)(UINTMAX_C(4294967295))); + x751 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967295)))); + x752 = (x706)*((uintptr_t)(UINTMAX_C(4294967295))); + x753 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967295)))); + x754 = (x706)*((uintptr_t)(UINTMAX_C(4294967295))); + x755 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967295)))); + x756 = (x706)*((uintptr_t)(UINTMAX_C(4294967295))); + x757 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967295)))); + x758 = (x706)*((uintptr_t)(UINTMAX_C(4294967295))); + x759 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967295)))); + x760 = (x706)*((uintptr_t)(UINTMAX_C(4294967295))); + x761 = _br2_mulhuu((x706), ((uintptr_t)(UINTMAX_C(4294967295)))); + x762 = (x761)+(x758); + x763 = (uintptr_t)((x762)<(x761)); + x764 = (x763)+(x759); + x765 = (x757)+(x754); + x766 = (uintptr_t)((x765)<(x757)); + x767 = (x766)+(x755); + x768 = (uintptr_t)((x767)<(x755)); + x769 = (x767)+(x752); + x770 = (uintptr_t)((x769)<(x752)); + x771 = (x768)+(x770); + x772 = (x771)+(x753); + x773 = (uintptr_t)((x772)<(x753)); + x774 = (x772)+(x750); + x775 = (uintptr_t)((x774)<(x750)); + x776 = (x773)+(x775); + x777 = (x776)+(x751); + x778 = (uintptr_t)((x777)<(x751)); + x779 = (x777)+(x748); + x780 = (uintptr_t)((x779)<(x748)); + x781 = (x778)+(x780); + x782 = (x781)+(x749); + x783 = (x706)+(x760); + x784 = (uintptr_t)((x783)<(x706)); + x785 = (x784)+(x710); + x786 = (uintptr_t)((x785)<(x710)); + x787 = (x785)+(x762); + x788 = (uintptr_t)((x787)<(x762)); + x789 = (x786)+(x788); + x790 = (x789)+(x715); + x791 = (uintptr_t)((x790)<(x715)); + x792 = (x790)+(x764); + x793 = (uintptr_t)((x792)<(x764)); + x794 = (x791)+(x793); + x795 = (x794)+(x720); + x796 = (uintptr_t)((x795)<(x720)); + x797 = (x795)+(x756); + x798 = (uintptr_t)((x797)<(x756)); + x799 = (x796)+(x798); + x800 = (x799)+(x725); + x801 = (uintptr_t)((x800)<(x725)); + x802 = (x800)+(x765); + x803 = (uintptr_t)((x802)<(x765)); + x804 = (x801)+(x803); + x805 = (x804)+(x730); + x806 = (uintptr_t)((x805)<(x730)); + x807 = (x805)+(x769); + x808 = (uintptr_t)((x807)<(x769)); + x809 = (x806)+(x808); + x810 = (x809)+(x735); + x811 = (uintptr_t)((x810)<(x735)); + x812 = (x810)+(x774); + x813 = (uintptr_t)((x812)<(x774)); + x814 = (x811)+(x813); + x815 = (x814)+(x740); + x816 = (uintptr_t)((x815)<(x740)); + x817 = (x815)+(x779); + x818 = (uintptr_t)((x817)<(x779)); + x819 = (x816)+(x818); + x820 = (x819)+(x745); + x821 = (uintptr_t)((x820)<(x745)); + x822 = (x820)+(x782); + x823 = (uintptr_t)((x822)<(x782)); + x824 = (x821)+(x823); + x825 = (x824)+(x747); + x826 = (x20)*(x15); + x827 = _br2_mulhuu((x20), (x15)); + x828 = (x20)*(x14); + x829 = _br2_mulhuu((x20), (x14)); + x830 = (x20)*(x13); + x831 = _br2_mulhuu((x20), (x13)); + x832 = (x20)*(x12); + x833 = _br2_mulhuu((x20), (x12)); + x834 = (x20)*(x11); + x835 = _br2_mulhuu((x20), (x11)); + x836 = (x20)*(x10); + x837 = _br2_mulhuu((x20), (x10)); + x838 = (x20)*(x9); + x839 = _br2_mulhuu((x20), (x9)); + x840 = (x20)*(x8); + x841 = _br2_mulhuu((x20), (x8)); + x842 = (x841)+(x838); + x843 = (uintptr_t)((x842)<(x841)); + x844 = (x843)+(x839); + x845 = (uintptr_t)((x844)<(x839)); + x846 = (x844)+(x836); + x847 = (uintptr_t)((x846)<(x836)); + x848 = (x845)+(x847); + x849 = (x848)+(x837); + x850 = (uintptr_t)((x849)<(x837)); + x851 = (x849)+(x834); + x852 = (uintptr_t)((x851)<(x834)); + x853 = (x850)+(x852); + x854 = (x853)+(x835); + x855 = (uintptr_t)((x854)<(x835)); + x856 = (x854)+(x832); + x857 = (uintptr_t)((x856)<(x832)); + x858 = (x855)+(x857); + x859 = (x858)+(x833); + x860 = (uintptr_t)((x859)<(x833)); + x861 = (x859)+(x830); + x862 = (uintptr_t)((x861)<(x830)); + x863 = (x860)+(x862); + x864 = (x863)+(x831); + x865 = (uintptr_t)((x864)<(x831)); + x866 = (x864)+(x828); + x867 = (uintptr_t)((x866)<(x828)); + x868 = (x865)+(x867); + x869 = (x868)+(x829); + x870 = (uintptr_t)((x869)<(x829)); + x871 = (x869)+(x826); + x872 = (uintptr_t)((x871)<(x826)); + x873 = (x870)+(x872); + x874 = (x873)+(x827); + x875 = (x787)+(x840); + x876 = (uintptr_t)((x875)<(x787)); + x877 = (x876)+(x792); + x878 = (uintptr_t)((x877)<(x792)); + x879 = (x877)+(x842); + x880 = (uintptr_t)((x879)<(x842)); + x881 = (x878)+(x880); + x882 = (x881)+(x797); + x883 = (uintptr_t)((x882)<(x797)); + x884 = (x882)+(x846); + x885 = (uintptr_t)((x884)<(x846)); + x886 = (x883)+(x885); + x887 = (x886)+(x802); + x888 = (uintptr_t)((x887)<(x802)); + x889 = (x887)+(x851); + x890 = (uintptr_t)((x889)<(x851)); + x891 = (x888)+(x890); + x892 = (x891)+(x807); + x893 = (uintptr_t)((x892)<(x807)); + x894 = (x892)+(x856); + x895 = (uintptr_t)((x894)<(x856)); + 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)+(x825); + x913 = (uintptr_t)((x912)<(x825)); + x914 = (x912)+(x874); + x915 = (uintptr_t)((x914)<(x874)); + x916 = (x913)+(x915); + x917 = (x875)*((uintptr_t)(UINTMAX_C(4294967294))); + x918 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967294)))); + x919 = (x875)*((uintptr_t)(UINTMAX_C(4294967295))); + x920 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967295)))); + x921 = (x875)*((uintptr_t)(UINTMAX_C(4294967295))); + x922 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967295)))); + x923 = (x875)*((uintptr_t)(UINTMAX_C(4294967295))); + x924 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967295)))); + x925 = (x875)*((uintptr_t)(UINTMAX_C(4294967295))); + x926 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967295)))); + x927 = (x875)*((uintptr_t)(UINTMAX_C(4294967295))); + x928 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967295)))); + x929 = (x875)*((uintptr_t)(UINTMAX_C(4294967295))); + x930 = _br2_mulhuu((x875), ((uintptr_t)(UINTMAX_C(4294967295)))); + x931 = (x930)+(x927); + x932 = (uintptr_t)((x931)<(x930)); + x933 = (x932)+(x928); + x934 = (x926)+(x923); + x935 = (uintptr_t)((x934)<(x926)); + x936 = (x935)+(x924); + x937 = (uintptr_t)((x936)<(x924)); + x938 = (x936)+(x921); + x939 = (uintptr_t)((x938)<(x921)); + x940 = (x937)+(x939); + x941 = (x940)+(x922); + x942 = (uintptr_t)((x941)<(x922)); + x943 = (x941)+(x919); + x944 = (uintptr_t)((x943)<(x919)); + x945 = (x942)+(x944); + x946 = (x945)+(x920); + x947 = (uintptr_t)((x946)<(x920)); + x948 = (x946)+(x917); + x949 = (uintptr_t)((x948)<(x917)); + x950 = (x947)+(x949); + x951 = (x950)+(x918); + x952 = (x875)+(x929); + x953 = (uintptr_t)((x952)<(x875)); + x954 = (x953)+(x879); + x955 = (uintptr_t)((x954)<(x879)); + x956 = (x954)+(x931); + x957 = (uintptr_t)((x956)<(x931)); + x958 = (x955)+(x957); + x959 = (x958)+(x884); + x960 = (uintptr_t)((x959)<(x884)); + x961 = (x959)+(x933); + x962 = (uintptr_t)((x961)<(x933)); + x963 = (x960)+(x962); + x964 = (x963)+(x889); + x965 = (uintptr_t)((x964)<(x889)); + x966 = (x964)+(x925); + x967 = (uintptr_t)((x966)<(x925)); + x968 = (x965)+(x967); + x969 = (x968)+(x894); + x970 = (uintptr_t)((x969)<(x894)); + x971 = (x969)+(x934); + x972 = (uintptr_t)((x971)<(x934)); + x973 = (x970)+(x972); + x974 = (x973)+(x899); + x975 = (uintptr_t)((x974)<(x899)); + x976 = (x974)+(x938); + x977 = (uintptr_t)((x976)<(x938)); + x978 = (x975)+(x977); + x979 = (x978)+(x904); + x980 = (uintptr_t)((x979)<(x904)); + x981 = (x979)+(x943); + x982 = (uintptr_t)((x981)<(x943)); + x983 = (x980)+(x982); + x984 = (x983)+(x909); + x985 = (uintptr_t)((x984)<(x909)); + x986 = (x984)+(x948); + x987 = (uintptr_t)((x986)<(x948)); + x988 = (x985)+(x987); + x989 = (x988)+(x914); + x990 = (uintptr_t)((x989)<(x914)); + x991 = (x989)+(x951); + x992 = (uintptr_t)((x991)<(x951)); + x993 = (x990)+(x992); + x994 = (x993)+(x916); + x995 = (x21)*(x15); + x996 = _br2_mulhuu((x21), (x15)); + x997 = (x21)*(x14); + x998 = _br2_mulhuu((x21), (x14)); + x999 = (x21)*(x13); + x1000 = _br2_mulhuu((x21), (x13)); + x1001 = (x21)*(x12); + x1002 = _br2_mulhuu((x21), (x12)); + x1003 = (x21)*(x11); + x1004 = _br2_mulhuu((x21), (x11)); + x1005 = (x21)*(x10); + x1006 = _br2_mulhuu((x21), (x10)); + x1007 = (x21)*(x9); + x1008 = _br2_mulhuu((x21), (x9)); + x1009 = (x21)*(x8); + x1010 = _br2_mulhuu((x21), (x8)); + x1011 = (x1010)+(x1007); + x1012 = (uintptr_t)((x1011)<(x1010)); + x1013 = (x1012)+(x1008); + x1014 = (uintptr_t)((x1013)<(x1008)); + x1015 = (x1013)+(x1005); + x1016 = (uintptr_t)((x1015)<(x1005)); + x1017 = (x1014)+(x1016); + x1018 = (x1017)+(x1006); + x1019 = (uintptr_t)((x1018)<(x1006)); + x1020 = (x1018)+(x1003); + x1021 = (uintptr_t)((x1020)<(x1003)); + x1022 = (x1019)+(x1021); + x1023 = (x1022)+(x1004); + x1024 = (uintptr_t)((x1023)<(x1004)); + x1025 = (x1023)+(x1001); + x1026 = (uintptr_t)((x1025)<(x1001)); + x1027 = (x1024)+(x1026); + x1028 = (x1027)+(x1002); + x1029 = (uintptr_t)((x1028)<(x1002)); + x1030 = (x1028)+(x999); + x1031 = (uintptr_t)((x1030)<(x999)); + x1032 = (x1029)+(x1031); + x1033 = (x1032)+(x1000); + x1034 = (uintptr_t)((x1033)<(x1000)); + x1035 = (x1033)+(x997); + x1036 = (uintptr_t)((x1035)<(x997)); + x1037 = (x1034)+(x1036); + x1038 = (x1037)+(x998); + x1039 = (uintptr_t)((x1038)<(x998)); + x1040 = (x1038)+(x995); + x1041 = (uintptr_t)((x1040)<(x995)); + x1042 = (x1039)+(x1041); + x1043 = (x1042)+(x996); + x1044 = (x956)+(x1009); + x1045 = (uintptr_t)((x1044)<(x956)); + x1046 = (x1045)+(x961); + x1047 = (uintptr_t)((x1046)<(x961)); + x1048 = (x1046)+(x1011); + x1049 = (uintptr_t)((x1048)<(x1011)); + x1050 = (x1047)+(x1049); + x1051 = (x1050)+(x966); + x1052 = (uintptr_t)((x1051)<(x966)); + x1053 = (x1051)+(x1015); + x1054 = (uintptr_t)((x1053)<(x1015)); + x1055 = (x1052)+(x1054); + x1056 = (x1055)+(x971); + x1057 = (uintptr_t)((x1056)<(x971)); + x1058 = (x1056)+(x1020); + x1059 = (uintptr_t)((x1058)<(x1020)); + 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)+(x994); + x1082 = (uintptr_t)((x1081)<(x994)); + x1083 = (x1081)+(x1043); + x1084 = (uintptr_t)((x1083)<(x1043)); + x1085 = (x1082)+(x1084); + x1086 = (x1044)*((uintptr_t)(UINTMAX_C(4294967294))); + x1087 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1088 = (x1044)*((uintptr_t)(UINTMAX_C(4294967295))); + x1089 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1090 = (x1044)*((uintptr_t)(UINTMAX_C(4294967295))); + x1091 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1092 = (x1044)*((uintptr_t)(UINTMAX_C(4294967295))); + x1093 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1094 = (x1044)*((uintptr_t)(UINTMAX_C(4294967295))); + x1095 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1096 = (x1044)*((uintptr_t)(UINTMAX_C(4294967295))); + x1097 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1098 = (x1044)*((uintptr_t)(UINTMAX_C(4294967295))); + x1099 = _br2_mulhuu((x1044), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1100 = (x1099)+(x1096); + x1101 = (uintptr_t)((x1100)<(x1099)); + x1102 = (x1101)+(x1097); + x1103 = (x1095)+(x1092); + x1104 = (uintptr_t)((x1103)<(x1095)); + x1105 = (x1104)+(x1093); + x1106 = (uintptr_t)((x1105)<(x1093)); + x1107 = (x1105)+(x1090); + x1108 = (uintptr_t)((x1107)<(x1090)); + x1109 = (x1106)+(x1108); + x1110 = (x1109)+(x1091); + x1111 = (uintptr_t)((x1110)<(x1091)); + x1112 = (x1110)+(x1088); + x1113 = (uintptr_t)((x1112)<(x1088)); + x1114 = (x1111)+(x1113); + x1115 = (x1114)+(x1089); + x1116 = (uintptr_t)((x1115)<(x1089)); + x1117 = (x1115)+(x1086); + x1118 = (uintptr_t)((x1117)<(x1086)); + x1119 = (x1116)+(x1118); + x1120 = (x1119)+(x1087); + x1121 = (x1044)+(x1098); + x1122 = (uintptr_t)((x1121)<(x1044)); + x1123 = (x1122)+(x1048); + x1124 = (uintptr_t)((x1123)<(x1048)); + x1125 = (x1123)+(x1100); + x1126 = (uintptr_t)((x1125)<(x1100)); + x1127 = (x1124)+(x1126); + x1128 = (x1127)+(x1053); + x1129 = (uintptr_t)((x1128)<(x1053)); + x1130 = (x1128)+(x1102); + x1131 = (uintptr_t)((x1130)<(x1102)); + x1132 = (x1129)+(x1131); + x1133 = (x1132)+(x1058); + x1134 = (uintptr_t)((x1133)<(x1058)); + x1135 = (x1133)+(x1094); + x1136 = (uintptr_t)((x1135)<(x1094)); + x1137 = (x1134)+(x1136); + x1138 = (x1137)+(x1063); + x1139 = (uintptr_t)((x1138)<(x1063)); + x1140 = (x1138)+(x1103); + x1141 = (uintptr_t)((x1140)<(x1103)); + x1142 = (x1139)+(x1141); + x1143 = (x1142)+(x1068); + x1144 = (uintptr_t)((x1143)<(x1068)); + x1145 = (x1143)+(x1107); + x1146 = (uintptr_t)((x1145)<(x1107)); + x1147 = (x1144)+(x1146); + x1148 = (x1147)+(x1073); + x1149 = (uintptr_t)((x1148)<(x1073)); + x1150 = (x1148)+(x1112); + x1151 = (uintptr_t)((x1150)<(x1112)); + x1152 = (x1149)+(x1151); + x1153 = (x1152)+(x1078); + x1154 = (uintptr_t)((x1153)<(x1078)); + x1155 = (x1153)+(x1117); + x1156 = (uintptr_t)((x1155)<(x1117)); + x1157 = (x1154)+(x1156); + x1158 = (x1157)+(x1083); + x1159 = (uintptr_t)((x1158)<(x1083)); + x1160 = (x1158)+(x1120); + x1161 = (uintptr_t)((x1160)<(x1120)); + x1162 = (x1159)+(x1161); + x1163 = (x1162)+(x1085); + x1164 = (x22)*(x15); + x1165 = _br2_mulhuu((x22), (x15)); + x1166 = (x22)*(x14); + x1167 = _br2_mulhuu((x22), (x14)); + x1168 = (x22)*(x13); + x1169 = _br2_mulhuu((x22), (x13)); + x1170 = (x22)*(x12); + x1171 = _br2_mulhuu((x22), (x12)); + x1172 = (x22)*(x11); + x1173 = _br2_mulhuu((x22), (x11)); + x1174 = (x22)*(x10); + x1175 = _br2_mulhuu((x22), (x10)); + x1176 = (x22)*(x9); + x1177 = _br2_mulhuu((x22), (x9)); + x1178 = (x22)*(x8); + x1179 = _br2_mulhuu((x22), (x8)); + x1180 = (x1179)+(x1176); + x1181 = (uintptr_t)((x1180)<(x1179)); + x1182 = (x1181)+(x1177); + x1183 = (uintptr_t)((x1182)<(x1177)); + x1184 = (x1182)+(x1174); + x1185 = (uintptr_t)((x1184)<(x1174)); + x1186 = (x1183)+(x1185); + x1187 = (x1186)+(x1175); + x1188 = (uintptr_t)((x1187)<(x1175)); + x1189 = (x1187)+(x1172); + x1190 = (uintptr_t)((x1189)<(x1172)); + x1191 = (x1188)+(x1190); + x1192 = (x1191)+(x1173); + x1193 = (uintptr_t)((x1192)<(x1173)); + x1194 = (x1192)+(x1170); + x1195 = (uintptr_t)((x1194)<(x1170)); + x1196 = (x1193)+(x1195); + x1197 = (x1196)+(x1171); + x1198 = (uintptr_t)((x1197)<(x1171)); + x1199 = (x1197)+(x1168); + x1200 = (uintptr_t)((x1199)<(x1168)); + x1201 = (x1198)+(x1200); + x1202 = (x1201)+(x1169); + x1203 = (uintptr_t)((x1202)<(x1169)); + x1204 = (x1202)+(x1166); + x1205 = (uintptr_t)((x1204)<(x1166)); + x1206 = (x1203)+(x1205); + x1207 = (x1206)+(x1167); + x1208 = (uintptr_t)((x1207)<(x1167)); + x1209 = (x1207)+(x1164); + x1210 = (uintptr_t)((x1209)<(x1164)); + x1211 = (x1208)+(x1210); + x1212 = (x1211)+(x1165); + x1213 = (x1125)+(x1178); + x1214 = (uintptr_t)((x1213)<(x1125)); + x1215 = (x1214)+(x1130); + x1216 = (uintptr_t)((x1215)<(x1130)); + x1217 = (x1215)+(x1180); + x1218 = (uintptr_t)((x1217)<(x1180)); + x1219 = (x1216)+(x1218); + x1220 = (x1219)+(x1135); + x1221 = (uintptr_t)((x1220)<(x1135)); + x1222 = (x1220)+(x1184); + x1223 = (uintptr_t)((x1222)<(x1184)); + x1224 = (x1221)+(x1223); + x1225 = (x1224)+(x1140); + x1226 = (uintptr_t)((x1225)<(x1140)); + x1227 = (x1225)+(x1189); + x1228 = (uintptr_t)((x1227)<(x1189)); + x1229 = (x1226)+(x1228); + x1230 = (x1229)+(x1145); + x1231 = (uintptr_t)((x1230)<(x1145)); + x1232 = (x1230)+(x1194); + x1233 = (uintptr_t)((x1232)<(x1194)); + x1234 = (x1231)+(x1233); + x1235 = (x1234)+(x1150); + x1236 = (uintptr_t)((x1235)<(x1150)); + x1237 = (x1235)+(x1199); + x1238 = (uintptr_t)((x1237)<(x1199)); + x1239 = (x1236)+(x1238); + x1240 = (x1239)+(x1155); + x1241 = (uintptr_t)((x1240)<(x1155)); + x1242 = (x1240)+(x1204); + x1243 = (uintptr_t)((x1242)<(x1204)); + x1244 = (x1241)+(x1243); + x1245 = (x1244)+(x1160); + x1246 = (uintptr_t)((x1245)<(x1160)); + x1247 = (x1245)+(x1209); + x1248 = (uintptr_t)((x1247)<(x1209)); + x1249 = (x1246)+(x1248); + x1250 = (x1249)+(x1163); + x1251 = (uintptr_t)((x1250)<(x1163)); + x1252 = (x1250)+(x1212); + x1253 = (uintptr_t)((x1252)<(x1212)); + x1254 = (x1251)+(x1253); + x1255 = (x1213)*((uintptr_t)(UINTMAX_C(4294967294))); + x1256 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1257 = (x1213)*((uintptr_t)(UINTMAX_C(4294967295))); + x1258 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1259 = (x1213)*((uintptr_t)(UINTMAX_C(4294967295))); + x1260 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1261 = (x1213)*((uintptr_t)(UINTMAX_C(4294967295))); + x1262 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1263 = (x1213)*((uintptr_t)(UINTMAX_C(4294967295))); + x1264 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1265 = (x1213)*((uintptr_t)(UINTMAX_C(4294967295))); + x1266 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1267 = (x1213)*((uintptr_t)(UINTMAX_C(4294967295))); + x1268 = _br2_mulhuu((x1213), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1269 = (x1268)+(x1265); + x1270 = (uintptr_t)((x1269)<(x1268)); + x1271 = (x1270)+(x1266); + x1272 = (x1264)+(x1261); + x1273 = (uintptr_t)((x1272)<(x1264)); + x1274 = (x1273)+(x1262); + x1275 = (uintptr_t)((x1274)<(x1262)); + x1276 = (x1274)+(x1259); + x1277 = (uintptr_t)((x1276)<(x1259)); + x1278 = (x1275)+(x1277); + x1279 = (x1278)+(x1260); + x1280 = (uintptr_t)((x1279)<(x1260)); + x1281 = (x1279)+(x1257); + x1282 = (uintptr_t)((x1281)<(x1257)); + x1283 = (x1280)+(x1282); + x1284 = (x1283)+(x1258); + x1285 = (uintptr_t)((x1284)<(x1258)); + x1286 = (x1284)+(x1255); + x1287 = (uintptr_t)((x1286)<(x1255)); + x1288 = (x1285)+(x1287); + x1289 = (x1288)+(x1256); + x1290 = (x1213)+(x1267); + x1291 = (uintptr_t)((x1290)<(x1213)); + x1292 = (x1291)+(x1217); + x1293 = (uintptr_t)((x1292)<(x1217)); + x1294 = (x1292)+(x1269); + x1295 = (uintptr_t)((x1294)<(x1269)); + x1296 = (x1293)+(x1295); + x1297 = (x1296)+(x1222); + x1298 = (uintptr_t)((x1297)<(x1222)); + x1299 = (x1297)+(x1271); + x1300 = (uintptr_t)((x1299)<(x1271)); + x1301 = (x1298)+(x1300); + x1302 = (x1301)+(x1227); + x1303 = (uintptr_t)((x1302)<(x1227)); + x1304 = (x1302)+(x1263); + x1305 = (uintptr_t)((x1304)<(x1263)); + x1306 = (x1303)+(x1305); + x1307 = (x1306)+(x1232); + x1308 = (uintptr_t)((x1307)<(x1232)); + x1309 = (x1307)+(x1272); + x1310 = (uintptr_t)((x1309)<(x1272)); + x1311 = (x1308)+(x1310); + x1312 = (x1311)+(x1237); + x1313 = (uintptr_t)((x1312)<(x1237)); + x1314 = (x1312)+(x1276); + x1315 = (uintptr_t)((x1314)<(x1276)); + x1316 = (x1313)+(x1315); + x1317 = (x1316)+(x1242); + x1318 = (uintptr_t)((x1317)<(x1242)); + x1319 = (x1317)+(x1281); + x1320 = (uintptr_t)((x1319)<(x1281)); + x1321 = (x1318)+(x1320); + x1322 = (x1321)+(x1247); + x1323 = (uintptr_t)((x1322)<(x1247)); + x1324 = (x1322)+(x1286); + x1325 = (uintptr_t)((x1324)<(x1286)); + x1326 = (x1323)+(x1325); + x1327 = (x1326)+(x1252); + x1328 = (uintptr_t)((x1327)<(x1252)); + x1329 = (x1327)+(x1289); + x1330 = (uintptr_t)((x1329)<(x1289)); + x1331 = (x1328)+(x1330); + x1332 = (x1331)+(x1254); + x1333 = (x1294)-((uintptr_t)(UINTMAX_C(4294967295))); + x1334 = (uintptr_t)((x1294)<(x1333)); + x1335 = (x1299)-((uintptr_t)(UINTMAX_C(4294967295))); + x1336 = (uintptr_t)((x1299)<(x1335)); + x1337 = (x1335)-(x1334); + x1338 = (uintptr_t)((x1335)<(x1337)); + x1339 = (x1336)+(x1338); + x1340 = (x1304)-(x1339); + x1341 = (uintptr_t)((x1304)<(x1340)); + x1342 = (x1309)-((uintptr_t)(UINTMAX_C(4294967295))); + x1343 = (uintptr_t)((x1309)<(x1342)); + x1344 = (x1342)-(x1341); + x1345 = (uintptr_t)((x1342)<(x1344)); + x1346 = (x1343)+(x1345); + x1347 = (x1314)-((uintptr_t)(UINTMAX_C(4294967295))); + x1348 = (uintptr_t)((x1314)<(x1347)); + x1349 = (x1347)-(x1346); + x1350 = (uintptr_t)((x1347)<(x1349)); + x1351 = (x1348)+(x1350); + x1352 = (x1319)-((uintptr_t)(UINTMAX_C(4294967295))); + x1353 = (uintptr_t)((x1319)<(x1352)); + x1354 = (x1352)-(x1351); + x1355 = (uintptr_t)((x1352)<(x1354)); + x1356 = (x1353)+(x1355); + x1357 = (x1324)-((uintptr_t)(UINTMAX_C(4294967295))); + x1358 = (uintptr_t)((x1324)<(x1357)); + x1359 = (x1357)-(x1356); + x1360 = (uintptr_t)((x1357)<(x1359)); + x1361 = (x1358)+(x1360); + x1362 = (x1329)-((uintptr_t)(UINTMAX_C(4294967294))); + x1363 = (uintptr_t)((x1329)<(x1362)); + x1364 = (x1362)-(x1361); + x1365 = (uintptr_t)((x1362)<(x1364)); + x1366 = (x1363)+(x1365); + x1367 = (x1332)-(x1366); + x1368 = (uintptr_t)((x1332)<(x1367)); + x1369 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1370 = (x1369)^((uintptr_t)(UINTMAX_C(4294967295))); + x1371 = ((x1294)&(x1369))|((x1333)&(x1370)); + x1372 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1373 = (x1372)^((uintptr_t)(UINTMAX_C(4294967295))); + x1374 = ((x1299)&(x1372))|((x1337)&(x1373)); + x1375 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1376 = (x1375)^((uintptr_t)(UINTMAX_C(4294967295))); + x1377 = ((x1304)&(x1375))|((x1340)&(x1376)); + x1378 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1379 = (x1378)^((uintptr_t)(UINTMAX_C(4294967295))); + x1380 = ((x1309)&(x1378))|((x1344)&(x1379)); + x1381 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1382 = (x1381)^((uintptr_t)(UINTMAX_C(4294967295))); + x1383 = ((x1314)&(x1381))|((x1349)&(x1382)); + x1384 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1385 = (x1384)^((uintptr_t)(UINTMAX_C(4294967295))); + x1386 = ((x1319)&(x1384))|((x1354)&(x1385)); + x1387 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1388 = (x1387)^((uintptr_t)(UINTMAX_C(4294967295))); + x1389 = ((x1324)&(x1387))|((x1359)&(x1388)); + x1390 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1368)==((uintptr_t)(UINTMAX_C(0))))); + x1391 = (x1390)^((uintptr_t)(UINTMAX_C(4294967295))); + x1392 = ((x1329)&(x1390))|((x1364)&(x1391)); + x1393 = x1371; + x1394 = x1374; + x1395 = x1377; + x1396 = x1380; + x1397 = x1383; + x1398 = x1386; + x1399 = x1389; + x1400 = x1392; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x1393, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1394, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1395, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x1396, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x1397, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x1398, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x1399, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x1400, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_mul(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_sm2_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_sm2_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, x75, x78, x80, x76, x71, x74, x83, x72, x84, x69, x85, x87, x88, x70, x89, x67, x90, x92, x93, x68, x94, x65, x95, x97, x98, x66, x77, x100, x30, x101, x32, x102, x79, x103, x105, x106, x36, x107, x81, x108, x110, x111, x41, x112, x73, x113, x115, x116, x46, x117, x82, x118, x120, x121, x51, x122, x86, x123, x125, x126, x56, x127, x91, x128, x130, x131, x61, x132, x96, x133, x135, x136, x64, x137, x99, x138, x140, x8, x154, x157, x159, x155, x160, x152, x161, x163, x164, x153, x165, x150, x166, x168, x169, x151, x170, x148, x171, x173, x174, x149, x175, x146, x176, x178, x179, x147, x180, x144, x181, x183, x184, x145, x185, x142, x186, x188, x189, x143, x156, x104, x192, x109, x193, x158, x194, x196, x197, x114, x198, x162, x199, x201, x202, x119, x203, x167, x204, x206, x207, x124, x208, x172, x209, x211, x212, x129, x213, x177, x214, x216, x217, x134, x218, x182, x219, x221, x222, x139, x223, x187, x224, x226, x227, x141, x228, x190, x229, x231, x243, x246, x248, x244, x239, x242, x251, x240, x252, x237, x253, x255, x256, x238, x257, x235, x258, x260, x261, x236, x262, x233, x263, x265, x266, x234, x245, x268, x191, x269, x195, x270, x247, x271, x273, x274, x200, x275, x249, x276, x278, x279, x205, x280, x241, x281, x283, x284, x210, x285, x250, x286, x288, x289, x215, x290, x254, x291, x293, x294, x220, x295, x259, x296, x298, x299, x225, x300, x264, x301, x303, x304, x230, x305, x267, x306, x308, x309, x232, x9, x323, x326, x328, x324, x329, x321, x330, x332, x333, x322, x334, x319, x335, x337, x338, x320, x339, x317, x340, x342, x343, x318, x344, x315, x345, x347, x348, x316, x349, x313, x350, x352, x353, x314, x354, x311, x355, x357, x358, x312, x325, x272, x361, x277, x362, x327, x363, x365, x366, x282, x367, x331, x368, x370, x371, x287, x372, x336, x373, x375, x376, x292, x377, x341, x378, x380, x381, x297, x382, x346, x383, x385, x386, x302, x387, x351, x388, x390, x391, x307, x392, x356, x393, x395, x396, x310, x397, x359, x398, x400, x412, x415, x417, x413, x408, x411, x420, x409, x421, x406, x422, x424, x425, x407, x426, x404, x427, x429, x430, x405, x431, x402, x432, x434, x435, x403, x414, x437, x360, x438, x364, x439, x416, x440, x442, x443, x369, x444, x418, x445, x447, x448, x374, x449, x410, x450, x452, x453, x379, x454, x419, x455, x457, x458, x384, x459, x423, x460, x462, x463, x389, x464, x428, x465, x467, x468, x394, x469, x433, x470, x472, x473, x399, x474, x436, x475, x477, x478, x401, x10, x492, x495, x497, x493, x498, x490, x499, x501, x502, x491, x503, x488, x504, x506, x507, x489, x508, x486, x509, x511, x512, x487, x513, x484, x514, x516, x517, x485, x518, x482, x519, x521, x522, x483, x523, x480, x524, x526, x527, x481, x494, x441, x530, x446, x531, x496, x532, x534, x535, x451, x536, x500, x537, x539, x540, x456, x541, x505, x542, x544, x545, x461, x546, x510, x547, x549, x550, x466, x551, x515, x552, x554, x555, x471, x556, x520, x557, x559, x560, x476, x561, x525, x562, x564, x565, x479, x566, x528, x567, x569, x581, x584, x586, x582, x577, x580, x589, x578, x590, x575, x591, x593, x594, x576, x595, x573, x596, x598, x599, x574, x600, x571, x601, x603, x604, x572, x583, x606, x529, x607, x533, x608, x585, x609, x611, x612, x538, x613, x587, x614, x616, x617, x543, x618, x579, x619, x621, x622, x548, x623, x588, x624, x626, x627, x553, x628, x592, x629, x631, x632, x558, x633, x597, x634, x636, x637, x563, x638, x602, x639, x641, x642, x568, x643, x605, x644, x646, x647, x570, x11, x661, x664, x666, x662, x667, x659, x668, x670, x671, x660, x672, x657, x673, x675, x676, x658, x677, x655, x678, x680, x681, x656, x682, x653, x683, x685, x686, x654, x687, x651, x688, x690, x691, x652, x692, x649, x693, x695, x696, x650, x663, x610, x699, x615, x700, x665, x701, x703, x704, x620, x705, x669, x706, x708, x709, x625, x710, x674, x711, x713, x714, x630, x715, x679, x716, x718, x719, x635, x720, x684, x721, x723, x724, x640, x725, x689, x726, x728, x729, x645, x730, x694, x731, x733, x734, x648, x735, x697, x736, x738, x750, x753, x755, x751, x746, x749, x758, x747, x759, x744, x760, x762, x763, x745, x764, x742, x765, x767, x768, x743, x769, x740, x770, x772, x773, x741, x752, x775, x698, x776, x702, x777, x754, x778, x780, x781, x707, x782, x756, x783, x785, x786, x712, x787, x748, x788, x790, x791, x717, x792, x757, x793, x795, x796, x722, x797, x761, x798, x800, x801, x727, x802, x766, x803, x805, x806, x732, x807, x771, x808, x810, x811, x737, x812, x774, x813, x815, x816, x739, x12, x830, x833, x835, x831, x836, x828, x837, x839, x840, x829, x841, x826, x842, x844, x845, x827, x846, x824, x847, x849, x850, x825, x851, x822, x852, x854, x855, x823, x856, x820, x857, x859, x860, x821, x861, x818, x862, x864, x865, x819, x832, x779, x868, x784, x869, x834, x870, x872, x873, x789, x874, x838, x875, x877, x878, x794, x879, x843, x880, x882, x883, x799, x884, x848, x885, x887, x888, x804, x889, x853, x890, x892, x893, x809, x894, x858, x895, x897, x898, x814, x899, x863, x900, x902, x903, x817, x904, x866, x905, x907, x919, x922, x924, x920, x915, x918, x927, x916, x928, x913, x929, x931, x932, x914, x933, x911, x934, x936, x937, x912, x938, x909, x939, x941, x942, x910, x921, x944, x867, x945, x871, x946, x923, x947, x949, x950, x876, x951, x925, x952, x954, x955, x881, x956, x917, x957, x959, x960, x886, x961, x926, x962, x964, x965, x891, x966, x930, x967, x969, x970, x896, x971, x935, x972, x974, x975, x901, x976, x940, x977, x979, x980, x906, x981, x943, x982, x984, x985, x908, x13, x999, x1002, x1004, x1000, x1005, x997, x1006, x1008, x1009, x998, x1010, x995, x1011, x1013, x1014, x996, x1015, x993, x1016, x1018, x1019, x994, x1020, x991, x1021, x1023, x1024, x992, x1025, x989, x1026, x1028, x1029, x990, x1030, x987, x1031, x1033, x1034, x988, x1001, x948, x1037, x953, x1038, x1003, x1039, x1041, x1042, x958, x1043, x1007, x1044, x1046, x1047, x963, x1048, x1012, x1049, x1051, x1052, x968, x1053, x1017, x1054, x1056, x1057, x973, x1058, x1022, x1059, x1061, x1062, x978, x1063, x1027, x1064, x1066, x1067, x983, x1068, x1032, x1069, x1071, x1072, x986, x1073, x1035, x1074, x1076, x1088, x1091, x1093, x1089, x1084, x1087, x1096, x1085, x1097, x1082, x1098, x1100, x1101, x1083, x1102, x1080, x1103, x1105, x1106, x1081, x1107, x1078, x1108, x1110, x1111, x1079, x1090, x1113, x1036, x1114, x1040, x1115, x1092, x1116, x1118, x1119, x1045, x1120, x1094, x1121, x1123, x1124, x1050, x1125, x1086, x1126, x1128, x1129, x1055, x1130, x1095, x1131, x1133, x1134, x1060, x1135, x1099, x1136, x1138, x1139, x1065, x1140, x1104, x1141, x1143, x1144, x1070, x1145, x1109, x1146, x1148, x1149, x1075, x1150, x1112, x1151, x1153, x1154, x1077, x7, x6, x5, x4, x3, x2, x1, x14, x0, x1168, x1171, x1173, x1169, x1174, x1166, x1175, x1177, x1178, x1167, x1179, x1164, x1180, x1182, x1183, x1165, x1184, x1162, x1185, x1187, x1188, x1163, x1189, x1160, x1190, x1192, x1193, x1161, x1194, x1158, x1195, x1197, x1198, x1159, x1199, x1156, x1200, x1202, x1203, x1157, x1170, x1117, x1206, x1122, x1207, x1172, x1208, x1210, x1211, x1127, x1212, x1176, x1213, x1215, x1216, x1132, x1217, x1181, x1218, x1220, x1221, x1137, x1222, x1186, x1223, x1225, x1226, x1142, x1227, x1191, x1228, x1230, x1231, x1147, x1232, x1196, x1233, x1235, x1236, x1152, x1237, x1201, x1238, x1240, x1241, x1155, x1242, x1204, x1243, x1245, x1257, x1260, x1262, x1258, x1253, x1256, x1265, x1254, x1266, x1251, x1267, x1269, x1270, x1252, x1271, x1249, x1272, x1274, x1275, x1250, x1276, x1247, x1277, x1279, x1280, x1248, x1259, x1282, x1205, x1283, x1209, x1284, x1261, x1285, x1287, x1288, x1214, x1289, x1263, x1290, x1292, x1293, x1219, x1294, x1255, x1295, x1297, x1298, x1224, x1299, x1264, x1300, x1302, x1303, x1229, x1304, x1268, x1305, x1307, x1308, x1234, x1309, x1273, x1310, x1312, x1313, x1239, x1314, x1278, x1315, x1317, x1318, x1244, x1319, x1281, x1320, x1322, x1323, x1246, x1326, x1327, x1328, x1330, x1331, x1333, x1334, x1335, x1337, x1338, x1339, x1340, x1342, x1343, x1344, x1345, x1347, x1348, x1349, x1350, x1352, x1353, x1354, x1355, x1357, x1358, x1324, x1359, x1286, x1361, x1325, x1362, x1291, x1364, x1329, x1365, x1296, x1367, x1332, x1368, x1301, x1370, x1336, x1371, x1306, x1373, x1341, x1374, x1311, x1376, x1346, x1377, x1316, x1379, x1351, x1380, x1360, x1321, x1382, x1356, x1383, x1363, x1366, x1369, x1372, x1375, x1378, x1381, x1384, x1385, x1386, x1387, x1388, x1389, x1390, x1391, x1392; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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 = _br2_mulhuu((x15), (x7)); + x18 = (x15)*(x6); + x19 = _br2_mulhuu((x15), (x6)); + x20 = (x15)*(x5); + x21 = _br2_mulhuu((x15), (x5)); + x22 = (x15)*(x4); + x23 = _br2_mulhuu((x15), (x4)); + x24 = (x15)*(x3); + x25 = _br2_mulhuu((x15), (x3)); + x26 = (x15)*(x2); + x27 = _br2_mulhuu((x15), (x2)); + x28 = (x15)*(x1); + x29 = _br2_mulhuu((x15), (x1)); + x30 = (x15)*(x0); + x31 = _br2_mulhuu((x15), (x0)); + 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)(UINTMAX_C(4294967294))); + x66 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967294)))); + x67 = (x30)*((uintptr_t)(UINTMAX_C(4294967295))); + x68 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967295)))); + x69 = (x30)*((uintptr_t)(UINTMAX_C(4294967295))); + x70 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967295)))); + x71 = (x30)*((uintptr_t)(UINTMAX_C(4294967295))); + x72 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967295)))); + x73 = (x30)*((uintptr_t)(UINTMAX_C(4294967295))); + x74 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967295)))); + x75 = (x30)*((uintptr_t)(UINTMAX_C(4294967295))); + x76 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967295)))); + x77 = (x30)*((uintptr_t)(UINTMAX_C(4294967295))); + x78 = _br2_mulhuu((x30), ((uintptr_t)(UINTMAX_C(4294967295)))); + x79 = (x78)+(x75); + x80 = (uintptr_t)((x79)<(x78)); + x81 = (x80)+(x76); + x82 = (x74)+(x71); + x83 = (uintptr_t)((x82)<(x74)); + x84 = (x83)+(x72); + x85 = (uintptr_t)((x84)<(x72)); + x86 = (x84)+(x69); + x87 = (uintptr_t)((x86)<(x69)); + x88 = (x85)+(x87); + x89 = (x88)+(x70); + x90 = (uintptr_t)((x89)<(x70)); + x91 = (x89)+(x67); + x92 = (uintptr_t)((x91)<(x67)); + x93 = (x90)+(x92); + x94 = (x93)+(x68); + x95 = (uintptr_t)((x94)<(x68)); + x96 = (x94)+(x65); + x97 = (uintptr_t)((x96)<(x65)); + x98 = (x95)+(x97); + x99 = (x98)+(x66); + x100 = (x30)+(x77); + x101 = (uintptr_t)((x100)<(x30)); + x102 = (x101)+(x32); + x103 = (uintptr_t)((x102)<(x32)); + x104 = (x102)+(x79); + x105 = (uintptr_t)((x104)<(x79)); + x106 = (x103)+(x105); + x107 = (x106)+(x36); + x108 = (uintptr_t)((x107)<(x36)); + x109 = (x107)+(x81); + x110 = (uintptr_t)((x109)<(x81)); + x111 = (x108)+(x110); + x112 = (x111)+(x41); + x113 = (uintptr_t)((x112)<(x41)); + x114 = (x112)+(x73); + x115 = (uintptr_t)((x114)<(x73)); + x116 = (x113)+(x115); + x117 = (x116)+(x46); + x118 = (uintptr_t)((x117)<(x46)); + x119 = (x117)+(x82); + x120 = (uintptr_t)((x119)<(x82)); + x121 = (x118)+(x120); + x122 = (x121)+(x51); + x123 = (uintptr_t)((x122)<(x51)); + x124 = (x122)+(x86); + x125 = (uintptr_t)((x124)<(x86)); + x126 = (x123)+(x125); + x127 = (x126)+(x56); + x128 = (uintptr_t)((x127)<(x56)); + x129 = (x127)+(x91); + x130 = (uintptr_t)((x129)<(x91)); + x131 = (x128)+(x130); + x132 = (x131)+(x61); + x133 = (uintptr_t)((x132)<(x61)); + x134 = (x132)+(x96); + x135 = (uintptr_t)((x134)<(x96)); + x136 = (x133)+(x135); + x137 = (x136)+(x64); + x138 = (uintptr_t)((x137)<(x64)); + x139 = (x137)+(x99); + x140 = (uintptr_t)((x139)<(x99)); + x141 = (x138)+(x140); + x142 = (x8)*(x7); + x143 = _br2_mulhuu((x8), (x7)); + x144 = (x8)*(x6); + x145 = _br2_mulhuu((x8), (x6)); + x146 = (x8)*(x5); + x147 = _br2_mulhuu((x8), (x5)); + x148 = (x8)*(x4); + x149 = _br2_mulhuu((x8), (x4)); + x150 = (x8)*(x3); + x151 = _br2_mulhuu((x8), (x3)); + x152 = (x8)*(x2); + x153 = _br2_mulhuu((x8), (x2)); + x154 = (x8)*(x1); + x155 = _br2_mulhuu((x8), (x1)); + x156 = (x8)*(x0); + x157 = _br2_mulhuu((x8), (x0)); + x158 = (x157)+(x154); + x159 = (uintptr_t)((x158)<(x157)); + x160 = (x159)+(x155); + x161 = (uintptr_t)((x160)<(x155)); + x162 = (x160)+(x152); + x163 = (uintptr_t)((x162)<(x152)); + x164 = (x161)+(x163); + x165 = (x164)+(x153); + x166 = (uintptr_t)((x165)<(x153)); + x167 = (x165)+(x150); + x168 = (uintptr_t)((x167)<(x150)); + x169 = (x166)+(x168); + x170 = (x169)+(x151); + x171 = (uintptr_t)((x170)<(x151)); + x172 = (x170)+(x148); + x173 = (uintptr_t)((x172)<(x148)); + x174 = (x171)+(x173); + x175 = (x174)+(x149); + x176 = (uintptr_t)((x175)<(x149)); + x177 = (x175)+(x146); + x178 = (uintptr_t)((x177)<(x146)); + x179 = (x176)+(x178); + x180 = (x179)+(x147); + x181 = (uintptr_t)((x180)<(x147)); + x182 = (x180)+(x144); + x183 = (uintptr_t)((x182)<(x144)); + x184 = (x181)+(x183); + x185 = (x184)+(x145); + x186 = (uintptr_t)((x185)<(x145)); + x187 = (x185)+(x142); + x188 = (uintptr_t)((x187)<(x142)); + x189 = (x186)+(x188); + x190 = (x189)+(x143); + x191 = (x104)+(x156); + x192 = (uintptr_t)((x191)<(x104)); + x193 = (x192)+(x109); + x194 = (uintptr_t)((x193)<(x109)); + x195 = (x193)+(x158); + x196 = (uintptr_t)((x195)<(x158)); + x197 = (x194)+(x196); + x198 = (x197)+(x114); + x199 = (uintptr_t)((x198)<(x114)); + x200 = (x198)+(x162); + x201 = (uintptr_t)((x200)<(x162)); + x202 = (x199)+(x201); + x203 = (x202)+(x119); + x204 = (uintptr_t)((x203)<(x119)); + x205 = (x203)+(x167); + x206 = (uintptr_t)((x205)<(x167)); + x207 = (x204)+(x206); + x208 = (x207)+(x124); + x209 = (uintptr_t)((x208)<(x124)); + x210 = (x208)+(x172); + x211 = (uintptr_t)((x210)<(x172)); + 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)+(x141); + x229 = (uintptr_t)((x228)<(x141)); + x230 = (x228)+(x190); + x231 = (uintptr_t)((x230)<(x190)); + x232 = (x229)+(x231); + x233 = (x191)*((uintptr_t)(UINTMAX_C(4294967294))); + x234 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967294)))); + x235 = (x191)*((uintptr_t)(UINTMAX_C(4294967295))); + x236 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967295)))); + x237 = (x191)*((uintptr_t)(UINTMAX_C(4294967295))); + x238 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967295)))); + x239 = (x191)*((uintptr_t)(UINTMAX_C(4294967295))); + x240 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967295)))); + x241 = (x191)*((uintptr_t)(UINTMAX_C(4294967295))); + x242 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967295)))); + x243 = (x191)*((uintptr_t)(UINTMAX_C(4294967295))); + x244 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967295)))); + x245 = (x191)*((uintptr_t)(UINTMAX_C(4294967295))); + x246 = _br2_mulhuu((x191), ((uintptr_t)(UINTMAX_C(4294967295)))); + x247 = (x246)+(x243); + x248 = (uintptr_t)((x247)<(x246)); + x249 = (x248)+(x244); + x250 = (x242)+(x239); + x251 = (uintptr_t)((x250)<(x242)); + x252 = (x251)+(x240); + x253 = (uintptr_t)((x252)<(x240)); + x254 = (x252)+(x237); + x255 = (uintptr_t)((x254)<(x237)); + x256 = (x253)+(x255); + x257 = (x256)+(x238); + x258 = (uintptr_t)((x257)<(x238)); + x259 = (x257)+(x235); + x260 = (uintptr_t)((x259)<(x235)); + x261 = (x258)+(x260); + x262 = (x261)+(x236); + x263 = (uintptr_t)((x262)<(x236)); + x264 = (x262)+(x233); + x265 = (uintptr_t)((x264)<(x233)); + x266 = (x263)+(x265); + x267 = (x266)+(x234); + x268 = (x191)+(x245); + x269 = (uintptr_t)((x268)<(x191)); + x270 = (x269)+(x195); + x271 = (uintptr_t)((x270)<(x195)); + x272 = (x270)+(x247); + x273 = (uintptr_t)((x272)<(x247)); + x274 = (x271)+(x273); + x275 = (x274)+(x200); + x276 = (uintptr_t)((x275)<(x200)); + x277 = (x275)+(x249); + x278 = (uintptr_t)((x277)<(x249)); + x279 = (x276)+(x278); + x280 = (x279)+(x205); + x281 = (uintptr_t)((x280)<(x205)); + x282 = (x280)+(x241); + x283 = (uintptr_t)((x282)<(x241)); + x284 = (x281)+(x283); + x285 = (x284)+(x210); + x286 = (uintptr_t)((x285)<(x210)); + x287 = (x285)+(x250); + x288 = (uintptr_t)((x287)<(x250)); + x289 = (x286)+(x288); + x290 = (x289)+(x215); + x291 = (uintptr_t)((x290)<(x215)); + x292 = (x290)+(x254); + x293 = (uintptr_t)((x292)<(x254)); + x294 = (x291)+(x293); + x295 = (x294)+(x220); + x296 = (uintptr_t)((x295)<(x220)); + x297 = (x295)+(x259); + x298 = (uintptr_t)((x297)<(x259)); + x299 = (x296)+(x298); + x300 = (x299)+(x225); + x301 = (uintptr_t)((x300)<(x225)); + x302 = (x300)+(x264); + x303 = (uintptr_t)((x302)<(x264)); + x304 = (x301)+(x303); + x305 = (x304)+(x230); + x306 = (uintptr_t)((x305)<(x230)); + x307 = (x305)+(x267); + x308 = (uintptr_t)((x307)<(x267)); + x309 = (x306)+(x308); + x310 = (x309)+(x232); + x311 = (x9)*(x7); + x312 = _br2_mulhuu((x9), (x7)); + x313 = (x9)*(x6); + x314 = _br2_mulhuu((x9), (x6)); + x315 = (x9)*(x5); + x316 = _br2_mulhuu((x9), (x5)); + x317 = (x9)*(x4); + x318 = _br2_mulhuu((x9), (x4)); + x319 = (x9)*(x3); + x320 = _br2_mulhuu((x9), (x3)); + x321 = (x9)*(x2); + x322 = _br2_mulhuu((x9), (x2)); + x323 = (x9)*(x1); + x324 = _br2_mulhuu((x9), (x1)); + x325 = (x9)*(x0); + x326 = _br2_mulhuu((x9), (x0)); + x327 = (x326)+(x323); + x328 = (uintptr_t)((x327)<(x326)); + x329 = (x328)+(x324); + x330 = (uintptr_t)((x329)<(x324)); + x331 = (x329)+(x321); + x332 = (uintptr_t)((x331)<(x321)); + x333 = (x330)+(x332); + x334 = (x333)+(x322); + x335 = (uintptr_t)((x334)<(x322)); + x336 = (x334)+(x319); + x337 = (uintptr_t)((x336)<(x319)); + x338 = (x335)+(x337); + x339 = (x338)+(x320); + x340 = (uintptr_t)((x339)<(x320)); + x341 = (x339)+(x317); + x342 = (uintptr_t)((x341)<(x317)); + x343 = (x340)+(x342); + x344 = (x343)+(x318); + x345 = (uintptr_t)((x344)<(x318)); + x346 = (x344)+(x315); + x347 = (uintptr_t)((x346)<(x315)); + x348 = (x345)+(x347); + x349 = (x348)+(x316); + x350 = (uintptr_t)((x349)<(x316)); + x351 = (x349)+(x313); + x352 = (uintptr_t)((x351)<(x313)); + x353 = (x350)+(x352); + x354 = (x353)+(x314); + x355 = (uintptr_t)((x354)<(x314)); + x356 = (x354)+(x311); + x357 = (uintptr_t)((x356)<(x311)); + x358 = (x355)+(x357); + x359 = (x358)+(x312); + x360 = (x272)+(x325); + x361 = (uintptr_t)((x360)<(x272)); + x362 = (x361)+(x277); + x363 = (uintptr_t)((x362)<(x277)); + x364 = (x362)+(x327); + x365 = (uintptr_t)((x364)<(x327)); + x366 = (x363)+(x365); + x367 = (x366)+(x282); + x368 = (uintptr_t)((x367)<(x282)); + x369 = (x367)+(x331); + x370 = (uintptr_t)((x369)<(x331)); + x371 = (x368)+(x370); + x372 = (x371)+(x287); + x373 = (uintptr_t)((x372)<(x287)); + x374 = (x372)+(x336); + x375 = (uintptr_t)((x374)<(x336)); + x376 = (x373)+(x375); + x377 = (x376)+(x292); + x378 = (uintptr_t)((x377)<(x292)); + x379 = (x377)+(x341); + x380 = (uintptr_t)((x379)<(x341)); + x381 = (x378)+(x380); + x382 = (x381)+(x297); + x383 = (uintptr_t)((x382)<(x297)); + x384 = (x382)+(x346); + x385 = (uintptr_t)((x384)<(x346)); + x386 = (x383)+(x385); + x387 = (x386)+(x302); + x388 = (uintptr_t)((x387)<(x302)); + x389 = (x387)+(x351); + x390 = (uintptr_t)((x389)<(x351)); + x391 = (x388)+(x390); + x392 = (x391)+(x307); + x393 = (uintptr_t)((x392)<(x307)); + x394 = (x392)+(x356); + x395 = (uintptr_t)((x394)<(x356)); + x396 = (x393)+(x395); + x397 = (x396)+(x310); + x398 = (uintptr_t)((x397)<(x310)); + x399 = (x397)+(x359); + x400 = (uintptr_t)((x399)<(x359)); + x401 = (x398)+(x400); + x402 = (x360)*((uintptr_t)(UINTMAX_C(4294967294))); + x403 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967294)))); + x404 = (x360)*((uintptr_t)(UINTMAX_C(4294967295))); + x405 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x406 = (x360)*((uintptr_t)(UINTMAX_C(4294967295))); + x407 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x408 = (x360)*((uintptr_t)(UINTMAX_C(4294967295))); + x409 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x410 = (x360)*((uintptr_t)(UINTMAX_C(4294967295))); + x411 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x412 = (x360)*((uintptr_t)(UINTMAX_C(4294967295))); + x413 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x414 = (x360)*((uintptr_t)(UINTMAX_C(4294967295))); + x415 = _br2_mulhuu((x360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x416 = (x415)+(x412); + x417 = (uintptr_t)((x416)<(x415)); + x418 = (x417)+(x413); + x419 = (x411)+(x408); + x420 = (uintptr_t)((x419)<(x411)); + x421 = (x420)+(x409); + x422 = (uintptr_t)((x421)<(x409)); + x423 = (x421)+(x406); + x424 = (uintptr_t)((x423)<(x406)); + x425 = (x422)+(x424); + x426 = (x425)+(x407); + x427 = (uintptr_t)((x426)<(x407)); + x428 = (x426)+(x404); + x429 = (uintptr_t)((x428)<(x404)); + x430 = (x427)+(x429); + x431 = (x430)+(x405); + x432 = (uintptr_t)((x431)<(x405)); + x433 = (x431)+(x402); + x434 = (uintptr_t)((x433)<(x402)); + x435 = (x432)+(x434); + x436 = (x435)+(x403); + x437 = (x360)+(x414); + x438 = (uintptr_t)((x437)<(x360)); + x439 = (x438)+(x364); + x440 = (uintptr_t)((x439)<(x364)); + x441 = (x439)+(x416); + x442 = (uintptr_t)((x441)<(x416)); + x443 = (x440)+(x442); + x444 = (x443)+(x369); + x445 = (uintptr_t)((x444)<(x369)); + x446 = (x444)+(x418); + x447 = (uintptr_t)((x446)<(x418)); + x448 = (x445)+(x447); + x449 = (x448)+(x374); + x450 = (uintptr_t)((x449)<(x374)); + x451 = (x449)+(x410); + x452 = (uintptr_t)((x451)<(x410)); + x453 = (x450)+(x452); + x454 = (x453)+(x379); + x455 = (uintptr_t)((x454)<(x379)); + x456 = (x454)+(x419); + x457 = (uintptr_t)((x456)<(x419)); + x458 = (x455)+(x457); + x459 = (x458)+(x384); + x460 = (uintptr_t)((x459)<(x384)); + x461 = (x459)+(x423); + x462 = (uintptr_t)((x461)<(x423)); + x463 = (x460)+(x462); + x464 = (x463)+(x389); + x465 = (uintptr_t)((x464)<(x389)); + x466 = (x464)+(x428); + x467 = (uintptr_t)((x466)<(x428)); + x468 = (x465)+(x467); + x469 = (x468)+(x394); + x470 = (uintptr_t)((x469)<(x394)); + x471 = (x469)+(x433); + x472 = (uintptr_t)((x471)<(x433)); + x473 = (x470)+(x472); + x474 = (x473)+(x399); + x475 = (uintptr_t)((x474)<(x399)); + x476 = (x474)+(x436); + x477 = (uintptr_t)((x476)<(x436)); + x478 = (x475)+(x477); + x479 = (x478)+(x401); + x480 = (x10)*(x7); + x481 = _br2_mulhuu((x10), (x7)); + x482 = (x10)*(x6); + x483 = _br2_mulhuu((x10), (x6)); + x484 = (x10)*(x5); + x485 = _br2_mulhuu((x10), (x5)); + x486 = (x10)*(x4); + x487 = _br2_mulhuu((x10), (x4)); + x488 = (x10)*(x3); + x489 = _br2_mulhuu((x10), (x3)); + x490 = (x10)*(x2); + x491 = _br2_mulhuu((x10), (x2)); + x492 = (x10)*(x1); + x493 = _br2_mulhuu((x10), (x1)); + x494 = (x10)*(x0); + x495 = _br2_mulhuu((x10), (x0)); + x496 = (x495)+(x492); + x497 = (uintptr_t)((x496)<(x495)); + x498 = (x497)+(x493); + x499 = (uintptr_t)((x498)<(x493)); + x500 = (x498)+(x490); + x501 = (uintptr_t)((x500)<(x490)); + x502 = (x499)+(x501); + x503 = (x502)+(x491); + x504 = (uintptr_t)((x503)<(x491)); + x505 = (x503)+(x488); + x506 = (uintptr_t)((x505)<(x488)); + x507 = (x504)+(x506); + x508 = (x507)+(x489); + x509 = (uintptr_t)((x508)<(x489)); + x510 = (x508)+(x486); + x511 = (uintptr_t)((x510)<(x486)); + x512 = (x509)+(x511); + x513 = (x512)+(x487); + x514 = (uintptr_t)((x513)<(x487)); + x515 = (x513)+(x484); + x516 = (uintptr_t)((x515)<(x484)); + x517 = (x514)+(x516); + x518 = (x517)+(x485); + x519 = (uintptr_t)((x518)<(x485)); + x520 = (x518)+(x482); + x521 = (uintptr_t)((x520)<(x482)); + x522 = (x519)+(x521); + x523 = (x522)+(x483); + x524 = (uintptr_t)((x523)<(x483)); + x525 = (x523)+(x480); + x526 = (uintptr_t)((x525)<(x480)); + x527 = (x524)+(x526); + x528 = (x527)+(x481); + x529 = (x441)+(x494); + x530 = (uintptr_t)((x529)<(x441)); + x531 = (x530)+(x446); + x532 = (uintptr_t)((x531)<(x446)); + x533 = (x531)+(x496); + x534 = (uintptr_t)((x533)<(x496)); + x535 = (x532)+(x534); + x536 = (x535)+(x451); + x537 = (uintptr_t)((x536)<(x451)); + x538 = (x536)+(x500); + x539 = (uintptr_t)((x538)<(x500)); + x540 = (x537)+(x539); + x541 = (x540)+(x456); + x542 = (uintptr_t)((x541)<(x456)); + x543 = (x541)+(x505); + x544 = (uintptr_t)((x543)<(x505)); + x545 = (x542)+(x544); + x546 = (x545)+(x461); + x547 = (uintptr_t)((x546)<(x461)); + x548 = (x546)+(x510); + x549 = (uintptr_t)((x548)<(x510)); + x550 = (x547)+(x549); + x551 = (x550)+(x466); + x552 = (uintptr_t)((x551)<(x466)); + x553 = (x551)+(x515); + x554 = (uintptr_t)((x553)<(x515)); + x555 = (x552)+(x554); + x556 = (x555)+(x471); + x557 = (uintptr_t)((x556)<(x471)); + x558 = (x556)+(x520); + x559 = (uintptr_t)((x558)<(x520)); + x560 = (x557)+(x559); + x561 = (x560)+(x476); + x562 = (uintptr_t)((x561)<(x476)); + x563 = (x561)+(x525); + x564 = (uintptr_t)((x563)<(x525)); + x565 = (x562)+(x564); + x566 = (x565)+(x479); + x567 = (uintptr_t)((x566)<(x479)); + x568 = (x566)+(x528); + x569 = (uintptr_t)((x568)<(x528)); + x570 = (x567)+(x569); + x571 = (x529)*((uintptr_t)(UINTMAX_C(4294967294))); + x572 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967294)))); + x573 = (x529)*((uintptr_t)(UINTMAX_C(4294967295))); + x574 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967295)))); + x575 = (x529)*((uintptr_t)(UINTMAX_C(4294967295))); + x576 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967295)))); + x577 = (x529)*((uintptr_t)(UINTMAX_C(4294967295))); + x578 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967295)))); + x579 = (x529)*((uintptr_t)(UINTMAX_C(4294967295))); + x580 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967295)))); + x581 = (x529)*((uintptr_t)(UINTMAX_C(4294967295))); + x582 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967295)))); + x583 = (x529)*((uintptr_t)(UINTMAX_C(4294967295))); + x584 = _br2_mulhuu((x529), ((uintptr_t)(UINTMAX_C(4294967295)))); + x585 = (x584)+(x581); + x586 = (uintptr_t)((x585)<(x584)); + x587 = (x586)+(x582); + x588 = (x580)+(x577); + x589 = (uintptr_t)((x588)<(x580)); + x590 = (x589)+(x578); + x591 = (uintptr_t)((x590)<(x578)); + x592 = (x590)+(x575); + x593 = (uintptr_t)((x592)<(x575)); + x594 = (x591)+(x593); + x595 = (x594)+(x576); + x596 = (uintptr_t)((x595)<(x576)); + x597 = (x595)+(x573); + x598 = (uintptr_t)((x597)<(x573)); + x599 = (x596)+(x598); + x600 = (x599)+(x574); + x601 = (uintptr_t)((x600)<(x574)); + x602 = (x600)+(x571); + x603 = (uintptr_t)((x602)<(x571)); + x604 = (x601)+(x603); + x605 = (x604)+(x572); + x606 = (x529)+(x583); + x607 = (uintptr_t)((x606)<(x529)); + x608 = (x607)+(x533); + x609 = (uintptr_t)((x608)<(x533)); + x610 = (x608)+(x585); + x611 = (uintptr_t)((x610)<(x585)); + x612 = (x609)+(x611); + x613 = (x612)+(x538); + x614 = (uintptr_t)((x613)<(x538)); + x615 = (x613)+(x587); + x616 = (uintptr_t)((x615)<(x587)); + x617 = (x614)+(x616); + x618 = (x617)+(x543); + x619 = (uintptr_t)((x618)<(x543)); + x620 = (x618)+(x579); + x621 = (uintptr_t)((x620)<(x579)); + x622 = (x619)+(x621); + x623 = (x622)+(x548); + x624 = (uintptr_t)((x623)<(x548)); + x625 = (x623)+(x588); + x626 = (uintptr_t)((x625)<(x588)); + x627 = (x624)+(x626); + x628 = (x627)+(x553); + x629 = (uintptr_t)((x628)<(x553)); + x630 = (x628)+(x592); + x631 = (uintptr_t)((x630)<(x592)); + x632 = (x629)+(x631); + x633 = (x632)+(x558); + x634 = (uintptr_t)((x633)<(x558)); + x635 = (x633)+(x597); + x636 = (uintptr_t)((x635)<(x597)); + x637 = (x634)+(x636); + x638 = (x637)+(x563); + x639 = (uintptr_t)((x638)<(x563)); + x640 = (x638)+(x602); + x641 = (uintptr_t)((x640)<(x602)); + x642 = (x639)+(x641); + x643 = (x642)+(x568); + x644 = (uintptr_t)((x643)<(x568)); + x645 = (x643)+(x605); + x646 = (uintptr_t)((x645)<(x605)); + x647 = (x644)+(x646); + x648 = (x647)+(x570); + x649 = (x11)*(x7); + x650 = _br2_mulhuu((x11), (x7)); + x651 = (x11)*(x6); + x652 = _br2_mulhuu((x11), (x6)); + x653 = (x11)*(x5); + x654 = _br2_mulhuu((x11), (x5)); + x655 = (x11)*(x4); + x656 = _br2_mulhuu((x11), (x4)); + x657 = (x11)*(x3); + x658 = _br2_mulhuu((x11), (x3)); + x659 = (x11)*(x2); + x660 = _br2_mulhuu((x11), (x2)); + x661 = (x11)*(x1); + x662 = _br2_mulhuu((x11), (x1)); + x663 = (x11)*(x0); + x664 = _br2_mulhuu((x11), (x0)); + x665 = (x664)+(x661); + x666 = (uintptr_t)((x665)<(x664)); + x667 = (x666)+(x662); + x668 = (uintptr_t)((x667)<(x662)); + x669 = (x667)+(x659); + x670 = (uintptr_t)((x669)<(x659)); + x671 = (x668)+(x670); + x672 = (x671)+(x660); + x673 = (uintptr_t)((x672)<(x660)); + x674 = (x672)+(x657); + x675 = (uintptr_t)((x674)<(x657)); + x676 = (x673)+(x675); + x677 = (x676)+(x658); + x678 = (uintptr_t)((x677)<(x658)); + x679 = (x677)+(x655); + x680 = (uintptr_t)((x679)<(x655)); + x681 = (x678)+(x680); + x682 = (x681)+(x656); + x683 = (uintptr_t)((x682)<(x656)); + x684 = (x682)+(x653); + x685 = (uintptr_t)((x684)<(x653)); + x686 = (x683)+(x685); + x687 = (x686)+(x654); + x688 = (uintptr_t)((x687)<(x654)); + x689 = (x687)+(x651); + x690 = (uintptr_t)((x689)<(x651)); + x691 = (x688)+(x690); + x692 = (x691)+(x652); + x693 = (uintptr_t)((x692)<(x652)); + x694 = (x692)+(x649); + x695 = (uintptr_t)((x694)<(x649)); + x696 = (x693)+(x695); + x697 = (x696)+(x650); + x698 = (x610)+(x663); + x699 = (uintptr_t)((x698)<(x610)); + x700 = (x699)+(x615); + x701 = (uintptr_t)((x700)<(x615)); + x702 = (x700)+(x665); + x703 = (uintptr_t)((x702)<(x665)); + x704 = (x701)+(x703); + x705 = (x704)+(x620); + x706 = (uintptr_t)((x705)<(x620)); + x707 = (x705)+(x669); + x708 = (uintptr_t)((x707)<(x669)); + x709 = (x706)+(x708); + x710 = (x709)+(x625); + x711 = (uintptr_t)((x710)<(x625)); + x712 = (x710)+(x674); + x713 = (uintptr_t)((x712)<(x674)); + x714 = (x711)+(x713); + x715 = (x714)+(x630); + x716 = (uintptr_t)((x715)<(x630)); + x717 = (x715)+(x679); + x718 = (uintptr_t)((x717)<(x679)); + x719 = (x716)+(x718); + x720 = (x719)+(x635); + x721 = (uintptr_t)((x720)<(x635)); + x722 = (x720)+(x684); + x723 = (uintptr_t)((x722)<(x684)); + 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)+(x648); + x736 = (uintptr_t)((x735)<(x648)); + x737 = (x735)+(x697); + x738 = (uintptr_t)((x737)<(x697)); + x739 = (x736)+(x738); + x740 = (x698)*((uintptr_t)(UINTMAX_C(4294967294))); + x741 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967294)))); + x742 = (x698)*((uintptr_t)(UINTMAX_C(4294967295))); + x743 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967295)))); + x744 = (x698)*((uintptr_t)(UINTMAX_C(4294967295))); + x745 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967295)))); + x746 = (x698)*((uintptr_t)(UINTMAX_C(4294967295))); + x747 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967295)))); + x748 = (x698)*((uintptr_t)(UINTMAX_C(4294967295))); + x749 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967295)))); + x750 = (x698)*((uintptr_t)(UINTMAX_C(4294967295))); + x751 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967295)))); + x752 = (x698)*((uintptr_t)(UINTMAX_C(4294967295))); + x753 = _br2_mulhuu((x698), ((uintptr_t)(UINTMAX_C(4294967295)))); + x754 = (x753)+(x750); + x755 = (uintptr_t)((x754)<(x753)); + x756 = (x755)+(x751); + x757 = (x749)+(x746); + x758 = (uintptr_t)((x757)<(x749)); + x759 = (x758)+(x747); + x760 = (uintptr_t)((x759)<(x747)); + x761 = (x759)+(x744); + x762 = (uintptr_t)((x761)<(x744)); + x763 = (x760)+(x762); + x764 = (x763)+(x745); + x765 = (uintptr_t)((x764)<(x745)); + x766 = (x764)+(x742); + x767 = (uintptr_t)((x766)<(x742)); + x768 = (x765)+(x767); + x769 = (x768)+(x743); + x770 = (uintptr_t)((x769)<(x743)); + x771 = (x769)+(x740); + x772 = (uintptr_t)((x771)<(x740)); + x773 = (x770)+(x772); + x774 = (x773)+(x741); + x775 = (x698)+(x752); + x776 = (uintptr_t)((x775)<(x698)); + x777 = (x776)+(x702); + x778 = (uintptr_t)((x777)<(x702)); + x779 = (x777)+(x754); + x780 = (uintptr_t)((x779)<(x754)); + x781 = (x778)+(x780); + x782 = (x781)+(x707); + x783 = (uintptr_t)((x782)<(x707)); + x784 = (x782)+(x756); + x785 = (uintptr_t)((x784)<(x756)); + x786 = (x783)+(x785); + x787 = (x786)+(x712); + x788 = (uintptr_t)((x787)<(x712)); + x789 = (x787)+(x748); + x790 = (uintptr_t)((x789)<(x748)); + x791 = (x788)+(x790); + x792 = (x791)+(x717); + x793 = (uintptr_t)((x792)<(x717)); + x794 = (x792)+(x757); + x795 = (uintptr_t)((x794)<(x757)); + x796 = (x793)+(x795); + x797 = (x796)+(x722); + x798 = (uintptr_t)((x797)<(x722)); + x799 = (x797)+(x761); + x800 = (uintptr_t)((x799)<(x761)); + x801 = (x798)+(x800); + x802 = (x801)+(x727); + x803 = (uintptr_t)((x802)<(x727)); + x804 = (x802)+(x766); + x805 = (uintptr_t)((x804)<(x766)); + x806 = (x803)+(x805); + x807 = (x806)+(x732); + x808 = (uintptr_t)((x807)<(x732)); + x809 = (x807)+(x771); + x810 = (uintptr_t)((x809)<(x771)); + x811 = (x808)+(x810); + x812 = (x811)+(x737); + x813 = (uintptr_t)((x812)<(x737)); + x814 = (x812)+(x774); + x815 = (uintptr_t)((x814)<(x774)); + x816 = (x813)+(x815); + x817 = (x816)+(x739); + x818 = (x12)*(x7); + x819 = _br2_mulhuu((x12), (x7)); + x820 = (x12)*(x6); + x821 = _br2_mulhuu((x12), (x6)); + x822 = (x12)*(x5); + x823 = _br2_mulhuu((x12), (x5)); + x824 = (x12)*(x4); + x825 = _br2_mulhuu((x12), (x4)); + x826 = (x12)*(x3); + x827 = _br2_mulhuu((x12), (x3)); + x828 = (x12)*(x2); + x829 = _br2_mulhuu((x12), (x2)); + x830 = (x12)*(x1); + x831 = _br2_mulhuu((x12), (x1)); + x832 = (x12)*(x0); + x833 = _br2_mulhuu((x12), (x0)); + x834 = (x833)+(x830); + x835 = (uintptr_t)((x834)<(x833)); + x836 = (x835)+(x831); + x837 = (uintptr_t)((x836)<(x831)); + x838 = (x836)+(x828); + x839 = (uintptr_t)((x838)<(x828)); + x840 = (x837)+(x839); + x841 = (x840)+(x829); + x842 = (uintptr_t)((x841)<(x829)); + x843 = (x841)+(x826); + x844 = (uintptr_t)((x843)<(x826)); + x845 = (x842)+(x844); + x846 = (x845)+(x827); + x847 = (uintptr_t)((x846)<(x827)); + x848 = (x846)+(x824); + x849 = (uintptr_t)((x848)<(x824)); + x850 = (x847)+(x849); + x851 = (x850)+(x825); + x852 = (uintptr_t)((x851)<(x825)); + x853 = (x851)+(x822); + x854 = (uintptr_t)((x853)<(x822)); + x855 = (x852)+(x854); + x856 = (x855)+(x823); + x857 = (uintptr_t)((x856)<(x823)); + x858 = (x856)+(x820); + x859 = (uintptr_t)((x858)<(x820)); + x860 = (x857)+(x859); + x861 = (x860)+(x821); + x862 = (uintptr_t)((x861)<(x821)); + x863 = (x861)+(x818); + x864 = (uintptr_t)((x863)<(x818)); + x865 = (x862)+(x864); + x866 = (x865)+(x819); + x867 = (x779)+(x832); + x868 = (uintptr_t)((x867)<(x779)); + x869 = (x868)+(x784); + x870 = (uintptr_t)((x869)<(x784)); + x871 = (x869)+(x834); + x872 = (uintptr_t)((x871)<(x834)); + x873 = (x870)+(x872); + x874 = (x873)+(x789); + x875 = (uintptr_t)((x874)<(x789)); + x876 = (x874)+(x838); + x877 = (uintptr_t)((x876)<(x838)); + x878 = (x875)+(x877); + x879 = (x878)+(x794); + x880 = (uintptr_t)((x879)<(x794)); + x881 = (x879)+(x843); + x882 = (uintptr_t)((x881)<(x843)); + x883 = (x880)+(x882); + x884 = (x883)+(x799); + x885 = (uintptr_t)((x884)<(x799)); + x886 = (x884)+(x848); + x887 = (uintptr_t)((x886)<(x848)); + 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)+(x817); + x905 = (uintptr_t)((x904)<(x817)); + x906 = (x904)+(x866); + x907 = (uintptr_t)((x906)<(x866)); + x908 = (x905)+(x907); + x909 = (x867)*((uintptr_t)(UINTMAX_C(4294967294))); + x910 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967294)))); + x911 = (x867)*((uintptr_t)(UINTMAX_C(4294967295))); + x912 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967295)))); + x913 = (x867)*((uintptr_t)(UINTMAX_C(4294967295))); + x914 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967295)))); + x915 = (x867)*((uintptr_t)(UINTMAX_C(4294967295))); + x916 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967295)))); + x917 = (x867)*((uintptr_t)(UINTMAX_C(4294967295))); + x918 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967295)))); + x919 = (x867)*((uintptr_t)(UINTMAX_C(4294967295))); + x920 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967295)))); + x921 = (x867)*((uintptr_t)(UINTMAX_C(4294967295))); + x922 = _br2_mulhuu((x867), ((uintptr_t)(UINTMAX_C(4294967295)))); + x923 = (x922)+(x919); + x924 = (uintptr_t)((x923)<(x922)); + x925 = (x924)+(x920); + x926 = (x918)+(x915); + x927 = (uintptr_t)((x926)<(x918)); + x928 = (x927)+(x916); + x929 = (uintptr_t)((x928)<(x916)); + x930 = (x928)+(x913); + x931 = (uintptr_t)((x930)<(x913)); + x932 = (x929)+(x931); + x933 = (x932)+(x914); + x934 = (uintptr_t)((x933)<(x914)); + x935 = (x933)+(x911); + x936 = (uintptr_t)((x935)<(x911)); + x937 = (x934)+(x936); + x938 = (x937)+(x912); + x939 = (uintptr_t)((x938)<(x912)); + x940 = (x938)+(x909); + x941 = (uintptr_t)((x940)<(x909)); + x942 = (x939)+(x941); + x943 = (x942)+(x910); + x944 = (x867)+(x921); + x945 = (uintptr_t)((x944)<(x867)); + x946 = (x945)+(x871); + x947 = (uintptr_t)((x946)<(x871)); + x948 = (x946)+(x923); + x949 = (uintptr_t)((x948)<(x923)); + x950 = (x947)+(x949); + x951 = (x950)+(x876); + x952 = (uintptr_t)((x951)<(x876)); + x953 = (x951)+(x925); + x954 = (uintptr_t)((x953)<(x925)); + x955 = (x952)+(x954); + x956 = (x955)+(x881); + x957 = (uintptr_t)((x956)<(x881)); + x958 = (x956)+(x917); + x959 = (uintptr_t)((x958)<(x917)); + x960 = (x957)+(x959); + x961 = (x960)+(x886); + x962 = (uintptr_t)((x961)<(x886)); + x963 = (x961)+(x926); + x964 = (uintptr_t)((x963)<(x926)); + x965 = (x962)+(x964); + x966 = (x965)+(x891); + x967 = (uintptr_t)((x966)<(x891)); + x968 = (x966)+(x930); + x969 = (uintptr_t)((x968)<(x930)); + x970 = (x967)+(x969); + x971 = (x970)+(x896); + x972 = (uintptr_t)((x971)<(x896)); + x973 = (x971)+(x935); + x974 = (uintptr_t)((x973)<(x935)); + x975 = (x972)+(x974); + x976 = (x975)+(x901); + x977 = (uintptr_t)((x976)<(x901)); + x978 = (x976)+(x940); + x979 = (uintptr_t)((x978)<(x940)); + x980 = (x977)+(x979); + x981 = (x980)+(x906); + x982 = (uintptr_t)((x981)<(x906)); + x983 = (x981)+(x943); + x984 = (uintptr_t)((x983)<(x943)); + x985 = (x982)+(x984); + x986 = (x985)+(x908); + x987 = (x13)*(x7); + x988 = _br2_mulhuu((x13), (x7)); + x989 = (x13)*(x6); + x990 = _br2_mulhuu((x13), (x6)); + x991 = (x13)*(x5); + x992 = _br2_mulhuu((x13), (x5)); + x993 = (x13)*(x4); + x994 = _br2_mulhuu((x13), (x4)); + x995 = (x13)*(x3); + x996 = _br2_mulhuu((x13), (x3)); + x997 = (x13)*(x2); + x998 = _br2_mulhuu((x13), (x2)); + x999 = (x13)*(x1); + x1000 = _br2_mulhuu((x13), (x1)); + x1001 = (x13)*(x0); + x1002 = _br2_mulhuu((x13), (x0)); + x1003 = (x1002)+(x999); + x1004 = (uintptr_t)((x1003)<(x1002)); + x1005 = (x1004)+(x1000); + x1006 = (uintptr_t)((x1005)<(x1000)); + x1007 = (x1005)+(x997); + x1008 = (uintptr_t)((x1007)<(x997)); + x1009 = (x1006)+(x1008); + x1010 = (x1009)+(x998); + x1011 = (uintptr_t)((x1010)<(x998)); + x1012 = (x1010)+(x995); + x1013 = (uintptr_t)((x1012)<(x995)); + x1014 = (x1011)+(x1013); + x1015 = (x1014)+(x996); + x1016 = (uintptr_t)((x1015)<(x996)); + x1017 = (x1015)+(x993); + x1018 = (uintptr_t)((x1017)<(x993)); + x1019 = (x1016)+(x1018); + x1020 = (x1019)+(x994); + x1021 = (uintptr_t)((x1020)<(x994)); + x1022 = (x1020)+(x991); + x1023 = (uintptr_t)((x1022)<(x991)); + x1024 = (x1021)+(x1023); + x1025 = (x1024)+(x992); + x1026 = (uintptr_t)((x1025)<(x992)); + x1027 = (x1025)+(x989); + x1028 = (uintptr_t)((x1027)<(x989)); + x1029 = (x1026)+(x1028); + x1030 = (x1029)+(x990); + x1031 = (uintptr_t)((x1030)<(x990)); + x1032 = (x1030)+(x987); + x1033 = (uintptr_t)((x1032)<(x987)); + x1034 = (x1031)+(x1033); + x1035 = (x1034)+(x988); + x1036 = (x948)+(x1001); + x1037 = (uintptr_t)((x1036)<(x948)); + x1038 = (x1037)+(x953); + x1039 = (uintptr_t)((x1038)<(x953)); + x1040 = (x1038)+(x1003); + x1041 = (uintptr_t)((x1040)<(x1003)); + x1042 = (x1039)+(x1041); + x1043 = (x1042)+(x958); + x1044 = (uintptr_t)((x1043)<(x958)); + x1045 = (x1043)+(x1007); + x1046 = (uintptr_t)((x1045)<(x1007)); + x1047 = (x1044)+(x1046); + x1048 = (x1047)+(x963); + x1049 = (uintptr_t)((x1048)<(x963)); + x1050 = (x1048)+(x1012); + x1051 = (uintptr_t)((x1050)<(x1012)); + x1052 = (x1049)+(x1051); + x1053 = (x1052)+(x968); + x1054 = (uintptr_t)((x1053)<(x968)); + x1055 = (x1053)+(x1017); + x1056 = (uintptr_t)((x1055)<(x1017)); + x1057 = (x1054)+(x1056); + x1058 = (x1057)+(x973); + x1059 = (uintptr_t)((x1058)<(x973)); + x1060 = (x1058)+(x1022); + x1061 = (uintptr_t)((x1060)<(x1022)); + x1062 = (x1059)+(x1061); + x1063 = (x1062)+(x978); + x1064 = (uintptr_t)((x1063)<(x978)); + x1065 = (x1063)+(x1027); + x1066 = (uintptr_t)((x1065)<(x1027)); + x1067 = (x1064)+(x1066); + x1068 = (x1067)+(x983); + x1069 = (uintptr_t)((x1068)<(x983)); + x1070 = (x1068)+(x1032); + x1071 = (uintptr_t)((x1070)<(x1032)); + x1072 = (x1069)+(x1071); + x1073 = (x1072)+(x986); + x1074 = (uintptr_t)((x1073)<(x986)); + x1075 = (x1073)+(x1035); + x1076 = (uintptr_t)((x1075)<(x1035)); + x1077 = (x1074)+(x1076); + x1078 = (x1036)*((uintptr_t)(UINTMAX_C(4294967294))); + x1079 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1080 = (x1036)*((uintptr_t)(UINTMAX_C(4294967295))); + x1081 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1082 = (x1036)*((uintptr_t)(UINTMAX_C(4294967295))); + x1083 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1084 = (x1036)*((uintptr_t)(UINTMAX_C(4294967295))); + x1085 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1086 = (x1036)*((uintptr_t)(UINTMAX_C(4294967295))); + x1087 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1088 = (x1036)*((uintptr_t)(UINTMAX_C(4294967295))); + x1089 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1090 = (x1036)*((uintptr_t)(UINTMAX_C(4294967295))); + x1091 = _br2_mulhuu((x1036), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1092 = (x1091)+(x1088); + x1093 = (uintptr_t)((x1092)<(x1091)); + x1094 = (x1093)+(x1089); + x1095 = (x1087)+(x1084); + x1096 = (uintptr_t)((x1095)<(x1087)); + x1097 = (x1096)+(x1085); + x1098 = (uintptr_t)((x1097)<(x1085)); + x1099 = (x1097)+(x1082); + x1100 = (uintptr_t)((x1099)<(x1082)); + x1101 = (x1098)+(x1100); + x1102 = (x1101)+(x1083); + x1103 = (uintptr_t)((x1102)<(x1083)); + x1104 = (x1102)+(x1080); + x1105 = (uintptr_t)((x1104)<(x1080)); + x1106 = (x1103)+(x1105); + x1107 = (x1106)+(x1081); + x1108 = (uintptr_t)((x1107)<(x1081)); + x1109 = (x1107)+(x1078); + x1110 = (uintptr_t)((x1109)<(x1078)); + x1111 = (x1108)+(x1110); + x1112 = (x1111)+(x1079); + x1113 = (x1036)+(x1090); + x1114 = (uintptr_t)((x1113)<(x1036)); + x1115 = (x1114)+(x1040); + x1116 = (uintptr_t)((x1115)<(x1040)); + x1117 = (x1115)+(x1092); + x1118 = (uintptr_t)((x1117)<(x1092)); + x1119 = (x1116)+(x1118); + x1120 = (x1119)+(x1045); + x1121 = (uintptr_t)((x1120)<(x1045)); + x1122 = (x1120)+(x1094); + x1123 = (uintptr_t)((x1122)<(x1094)); + x1124 = (x1121)+(x1123); + x1125 = (x1124)+(x1050); + x1126 = (uintptr_t)((x1125)<(x1050)); + x1127 = (x1125)+(x1086); + x1128 = (uintptr_t)((x1127)<(x1086)); + x1129 = (x1126)+(x1128); + x1130 = (x1129)+(x1055); + x1131 = (uintptr_t)((x1130)<(x1055)); + x1132 = (x1130)+(x1095); + x1133 = (uintptr_t)((x1132)<(x1095)); + x1134 = (x1131)+(x1133); + x1135 = (x1134)+(x1060); + x1136 = (uintptr_t)((x1135)<(x1060)); + x1137 = (x1135)+(x1099); + x1138 = (uintptr_t)((x1137)<(x1099)); + x1139 = (x1136)+(x1138); + x1140 = (x1139)+(x1065); + x1141 = (uintptr_t)((x1140)<(x1065)); + x1142 = (x1140)+(x1104); + x1143 = (uintptr_t)((x1142)<(x1104)); + x1144 = (x1141)+(x1143); + x1145 = (x1144)+(x1070); + x1146 = (uintptr_t)((x1145)<(x1070)); + x1147 = (x1145)+(x1109); + x1148 = (uintptr_t)((x1147)<(x1109)); + x1149 = (x1146)+(x1148); + x1150 = (x1149)+(x1075); + x1151 = (uintptr_t)((x1150)<(x1075)); + x1152 = (x1150)+(x1112); + x1153 = (uintptr_t)((x1152)<(x1112)); + x1154 = (x1151)+(x1153); + x1155 = (x1154)+(x1077); + x1156 = (x14)*(x7); + x1157 = _br2_mulhuu((x14), (x7)); + x1158 = (x14)*(x6); + x1159 = _br2_mulhuu((x14), (x6)); + x1160 = (x14)*(x5); + x1161 = _br2_mulhuu((x14), (x5)); + x1162 = (x14)*(x4); + x1163 = _br2_mulhuu((x14), (x4)); + x1164 = (x14)*(x3); + x1165 = _br2_mulhuu((x14), (x3)); + x1166 = (x14)*(x2); + x1167 = _br2_mulhuu((x14), (x2)); + x1168 = (x14)*(x1); + x1169 = _br2_mulhuu((x14), (x1)); + x1170 = (x14)*(x0); + x1171 = _br2_mulhuu((x14), (x0)); + x1172 = (x1171)+(x1168); + x1173 = (uintptr_t)((x1172)<(x1171)); + x1174 = (x1173)+(x1169); + x1175 = (uintptr_t)((x1174)<(x1169)); + x1176 = (x1174)+(x1166); + x1177 = (uintptr_t)((x1176)<(x1166)); + x1178 = (x1175)+(x1177); + x1179 = (x1178)+(x1167); + x1180 = (uintptr_t)((x1179)<(x1167)); + x1181 = (x1179)+(x1164); + x1182 = (uintptr_t)((x1181)<(x1164)); + x1183 = (x1180)+(x1182); + x1184 = (x1183)+(x1165); + x1185 = (uintptr_t)((x1184)<(x1165)); + x1186 = (x1184)+(x1162); + x1187 = (uintptr_t)((x1186)<(x1162)); + x1188 = (x1185)+(x1187); + x1189 = (x1188)+(x1163); + x1190 = (uintptr_t)((x1189)<(x1163)); + x1191 = (x1189)+(x1160); + x1192 = (uintptr_t)((x1191)<(x1160)); + x1193 = (x1190)+(x1192); + x1194 = (x1193)+(x1161); + x1195 = (uintptr_t)((x1194)<(x1161)); + x1196 = (x1194)+(x1158); + x1197 = (uintptr_t)((x1196)<(x1158)); + x1198 = (x1195)+(x1197); + x1199 = (x1198)+(x1159); + x1200 = (uintptr_t)((x1199)<(x1159)); + x1201 = (x1199)+(x1156); + x1202 = (uintptr_t)((x1201)<(x1156)); + x1203 = (x1200)+(x1202); + x1204 = (x1203)+(x1157); + x1205 = (x1117)+(x1170); + x1206 = (uintptr_t)((x1205)<(x1117)); + x1207 = (x1206)+(x1122); + x1208 = (uintptr_t)((x1207)<(x1122)); + x1209 = (x1207)+(x1172); + x1210 = (uintptr_t)((x1209)<(x1172)); + x1211 = (x1208)+(x1210); + x1212 = (x1211)+(x1127); + x1213 = (uintptr_t)((x1212)<(x1127)); + x1214 = (x1212)+(x1176); + x1215 = (uintptr_t)((x1214)<(x1176)); + x1216 = (x1213)+(x1215); + x1217 = (x1216)+(x1132); + x1218 = (uintptr_t)((x1217)<(x1132)); + x1219 = (x1217)+(x1181); + x1220 = (uintptr_t)((x1219)<(x1181)); + x1221 = (x1218)+(x1220); + x1222 = (x1221)+(x1137); + x1223 = (uintptr_t)((x1222)<(x1137)); + x1224 = (x1222)+(x1186); + x1225 = (uintptr_t)((x1224)<(x1186)); + x1226 = (x1223)+(x1225); + x1227 = (x1226)+(x1142); + x1228 = (uintptr_t)((x1227)<(x1142)); + x1229 = (x1227)+(x1191); + x1230 = (uintptr_t)((x1229)<(x1191)); + x1231 = (x1228)+(x1230); + x1232 = (x1231)+(x1147); + x1233 = (uintptr_t)((x1232)<(x1147)); + x1234 = (x1232)+(x1196); + x1235 = (uintptr_t)((x1234)<(x1196)); + x1236 = (x1233)+(x1235); + x1237 = (x1236)+(x1152); + x1238 = (uintptr_t)((x1237)<(x1152)); + x1239 = (x1237)+(x1201); + x1240 = (uintptr_t)((x1239)<(x1201)); + x1241 = (x1238)+(x1240); + x1242 = (x1241)+(x1155); + x1243 = (uintptr_t)((x1242)<(x1155)); + x1244 = (x1242)+(x1204); + x1245 = (uintptr_t)((x1244)<(x1204)); + x1246 = (x1243)+(x1245); + x1247 = (x1205)*((uintptr_t)(UINTMAX_C(4294967294))); + x1248 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1249 = (x1205)*((uintptr_t)(UINTMAX_C(4294967295))); + x1250 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1251 = (x1205)*((uintptr_t)(UINTMAX_C(4294967295))); + x1252 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1253 = (x1205)*((uintptr_t)(UINTMAX_C(4294967295))); + x1254 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1255 = (x1205)*((uintptr_t)(UINTMAX_C(4294967295))); + x1256 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1257 = (x1205)*((uintptr_t)(UINTMAX_C(4294967295))); + x1258 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1259 = (x1205)*((uintptr_t)(UINTMAX_C(4294967295))); + x1260 = _br2_mulhuu((x1205), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1261 = (x1260)+(x1257); + x1262 = (uintptr_t)((x1261)<(x1260)); + x1263 = (x1262)+(x1258); + x1264 = (x1256)+(x1253); + x1265 = (uintptr_t)((x1264)<(x1256)); + x1266 = (x1265)+(x1254); + x1267 = (uintptr_t)((x1266)<(x1254)); + x1268 = (x1266)+(x1251); + x1269 = (uintptr_t)((x1268)<(x1251)); + x1270 = (x1267)+(x1269); + x1271 = (x1270)+(x1252); + x1272 = (uintptr_t)((x1271)<(x1252)); + x1273 = (x1271)+(x1249); + x1274 = (uintptr_t)((x1273)<(x1249)); + x1275 = (x1272)+(x1274); + x1276 = (x1275)+(x1250); + x1277 = (uintptr_t)((x1276)<(x1250)); + x1278 = (x1276)+(x1247); + x1279 = (uintptr_t)((x1278)<(x1247)); + x1280 = (x1277)+(x1279); + x1281 = (x1280)+(x1248); + x1282 = (x1205)+(x1259); + x1283 = (uintptr_t)((x1282)<(x1205)); + x1284 = (x1283)+(x1209); + x1285 = (uintptr_t)((x1284)<(x1209)); + x1286 = (x1284)+(x1261); + x1287 = (uintptr_t)((x1286)<(x1261)); + x1288 = (x1285)+(x1287); + x1289 = (x1288)+(x1214); + x1290 = (uintptr_t)((x1289)<(x1214)); + x1291 = (x1289)+(x1263); + x1292 = (uintptr_t)((x1291)<(x1263)); + x1293 = (x1290)+(x1292); + x1294 = (x1293)+(x1219); + x1295 = (uintptr_t)((x1294)<(x1219)); + x1296 = (x1294)+(x1255); + x1297 = (uintptr_t)((x1296)<(x1255)); + x1298 = (x1295)+(x1297); + x1299 = (x1298)+(x1224); + x1300 = (uintptr_t)((x1299)<(x1224)); + x1301 = (x1299)+(x1264); + x1302 = (uintptr_t)((x1301)<(x1264)); + x1303 = (x1300)+(x1302); + x1304 = (x1303)+(x1229); + x1305 = (uintptr_t)((x1304)<(x1229)); + x1306 = (x1304)+(x1268); + x1307 = (uintptr_t)((x1306)<(x1268)); + x1308 = (x1305)+(x1307); + x1309 = (x1308)+(x1234); + x1310 = (uintptr_t)((x1309)<(x1234)); + x1311 = (x1309)+(x1273); + x1312 = (uintptr_t)((x1311)<(x1273)); + x1313 = (x1310)+(x1312); + x1314 = (x1313)+(x1239); + x1315 = (uintptr_t)((x1314)<(x1239)); + x1316 = (x1314)+(x1278); + x1317 = (uintptr_t)((x1316)<(x1278)); + x1318 = (x1315)+(x1317); + x1319 = (x1318)+(x1244); + x1320 = (uintptr_t)((x1319)<(x1244)); + x1321 = (x1319)+(x1281); + x1322 = (uintptr_t)((x1321)<(x1281)); + x1323 = (x1320)+(x1322); + x1324 = (x1323)+(x1246); + x1325 = (x1286)-((uintptr_t)(UINTMAX_C(4294967295))); + x1326 = (uintptr_t)((x1286)<(x1325)); + x1327 = (x1291)-((uintptr_t)(UINTMAX_C(4294967295))); + x1328 = (uintptr_t)((x1291)<(x1327)); + x1329 = (x1327)-(x1326); + x1330 = (uintptr_t)((x1327)<(x1329)); + x1331 = (x1328)+(x1330); + x1332 = (x1296)-(x1331); + x1333 = (uintptr_t)((x1296)<(x1332)); + x1334 = (x1301)-((uintptr_t)(UINTMAX_C(4294967295))); + x1335 = (uintptr_t)((x1301)<(x1334)); + x1336 = (x1334)-(x1333); + x1337 = (uintptr_t)((x1334)<(x1336)); + x1338 = (x1335)+(x1337); + x1339 = (x1306)-((uintptr_t)(UINTMAX_C(4294967295))); + x1340 = (uintptr_t)((x1306)<(x1339)); + x1341 = (x1339)-(x1338); + x1342 = (uintptr_t)((x1339)<(x1341)); + x1343 = (x1340)+(x1342); + x1344 = (x1311)-((uintptr_t)(UINTMAX_C(4294967295))); + x1345 = (uintptr_t)((x1311)<(x1344)); + x1346 = (x1344)-(x1343); + x1347 = (uintptr_t)((x1344)<(x1346)); + x1348 = (x1345)+(x1347); + x1349 = (x1316)-((uintptr_t)(UINTMAX_C(4294967295))); + x1350 = (uintptr_t)((x1316)<(x1349)); + x1351 = (x1349)-(x1348); + x1352 = (uintptr_t)((x1349)<(x1351)); + x1353 = (x1350)+(x1352); + x1354 = (x1321)-((uintptr_t)(UINTMAX_C(4294967294))); + x1355 = (uintptr_t)((x1321)<(x1354)); + x1356 = (x1354)-(x1353); + x1357 = (uintptr_t)((x1354)<(x1356)); + x1358 = (x1355)+(x1357); + x1359 = (x1324)-(x1358); + x1360 = (uintptr_t)((x1324)<(x1359)); + x1361 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1362 = (x1361)^((uintptr_t)(UINTMAX_C(4294967295))); + x1363 = ((x1286)&(x1361))|((x1325)&(x1362)); + x1364 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1365 = (x1364)^((uintptr_t)(UINTMAX_C(4294967295))); + x1366 = ((x1291)&(x1364))|((x1329)&(x1365)); + x1367 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1368 = (x1367)^((uintptr_t)(UINTMAX_C(4294967295))); + x1369 = ((x1296)&(x1367))|((x1332)&(x1368)); + x1370 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1371 = (x1370)^((uintptr_t)(UINTMAX_C(4294967295))); + x1372 = ((x1301)&(x1370))|((x1336)&(x1371)); + x1373 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1374 = (x1373)^((uintptr_t)(UINTMAX_C(4294967295))); + x1375 = ((x1306)&(x1373))|((x1341)&(x1374)); + x1376 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1377 = (x1376)^((uintptr_t)(UINTMAX_C(4294967295))); + x1378 = ((x1311)&(x1376))|((x1346)&(x1377)); + x1379 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1380 = (x1379)^((uintptr_t)(UINTMAX_C(4294967295))); + x1381 = ((x1316)&(x1379))|((x1351)&(x1380)); + x1382 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1360)==((uintptr_t)(UINTMAX_C(0))))); + x1383 = (x1382)^((uintptr_t)(UINTMAX_C(4294967295))); + x1384 = ((x1321)&(x1382))|((x1356)&(x1383)); + x1385 = x1363; + x1386 = x1366; + x1387 = x1369; + x1388 = x1372; + x1389 = x1375; + x1390 = x1378; + x1391 = x1381; + x1392 = x1384; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x1385, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1386, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1387, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x1388, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x1389, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x1390, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x1391, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x1392, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_square(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_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, x36, x38, x40, x42, x31, x44, x16, x47, x32, x48, x18, x50, x34, x51, x20, x53, x35, x54, x22, x56, x37, x57, x24, x59, x39, x60, x26, x62, x41, 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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(4294967295))); + x33 = (x18)-((uintptr_t)(UINTMAX_C(4294967295))); + x34 = (x33)-((uintptr_t)((x16)<(x32))); + x35 = (x20)-(((uintptr_t)((x18)<(x33)))+((uintptr_t)((x33)<(x34)))); + x36 = (x22)-((uintptr_t)(UINTMAX_C(4294967295))); + x37 = (x36)-((uintptr_t)((x20)<(x35))); + x38 = (x24)-((uintptr_t)(UINTMAX_C(4294967295))); + x39 = (x38)-(((uintptr_t)((x22)<(x36)))+((uintptr_t)((x36)<(x37)))); + x40 = (x26)-((uintptr_t)(UINTMAX_C(4294967295))); + x41 = (x40)-(((uintptr_t)((x24)<(x38)))+((uintptr_t)((x38)<(x39)))); + x42 = (x28)-((uintptr_t)(UINTMAX_C(4294967295))); + x43 = (x42)-(((uintptr_t)((x26)<(x40)))+((uintptr_t)((x40)<(x41)))); + x44 = (x30)-((uintptr_t)(UINTMAX_C(4294967294))); + x45 = (x44)-(((uintptr_t)((x28)<(x42)))+((uintptr_t)((x42)<(x43)))); + x46 = (uintptr_t)((x31)<((x31)-(((uintptr_t)((x30)<(x44)))+((uintptr_t)((x44)<(x45)))))); + x47 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x48 = (x47)^((uintptr_t)(UINTMAX_C(4294967295))); + x49 = ((x16)&(x47))|((x32)&(x48)); + x50 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x51 = (x50)^((uintptr_t)(UINTMAX_C(4294967295))); + x52 = ((x18)&(x50))|((x34)&(x51)); + x53 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x54 = (x53)^((uintptr_t)(UINTMAX_C(4294967295))); + x55 = ((x20)&(x53))|((x35)&(x54)); + x56 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x57 = (x56)^((uintptr_t)(UINTMAX_C(4294967295))); + x58 = ((x22)&(x56))|((x37)&(x57)); + x59 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x60 = (x59)^((uintptr_t)(UINTMAX_C(4294967295))); + x61 = ((x24)&(x59))|((x39)&(x60)); + x62 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x63 = (x62)^((uintptr_t)(UINTMAX_C(4294967295))); + x64 = ((x26)&(x62))|((x41)&(x63)); + x65 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x66 = (x65)^((uintptr_t)(UINTMAX_C(4294967295))); + x67 = ((x28)&(x65))|((x43)&(x66)); + x68 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x46)==((uintptr_t)(UINTMAX_C(0))))); + x69 = (x68)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x71, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x72, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x73, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x74, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x75, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x76, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x77, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x78, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_add(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_sm2_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_sm2_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, x20, x36, x22, x38, x24, x40, x26, x42, x28, x30, x31, x32, x34, x35, x37, x39, x41, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)((x7)<(x29)))+((uintptr_t)((x29)<(x30))))==((uintptr_t)(UINTMAX_C(0))))); + x32 = (x16)+(x31); + x33 = ((uintptr_t)((x32)<(x16)))+(x18); + x34 = (x33)+(x31); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<(x31))))+(x20); + x36 = ((uintptr_t)((x35)<(x20)))+(x22); + x37 = (x36)+(x31); + x38 = (((uintptr_t)((x36)<(x22)))+((uintptr_t)((x37)<(x31))))+(x24); + x39 = (x38)+(x31); + x40 = (((uintptr_t)((x38)<(x24)))+((uintptr_t)((x39)<(x31))))+(x26); + x41 = (x40)+(x31); + x42 = (((uintptr_t)((x40)<(x26)))+((uintptr_t)((x41)<(x31))))+(x28); + x43 = (x42)+(x31); + x44 = ((((uintptr_t)((x42)<(x28)))+((uintptr_t)((x43)<(x31))))+(x30))+((x31)&((uintptr_t)(UINTMAX_C(4294967294)))); + x45 = x32; + x46 = x34; + x47 = x35; + x48 = x37; + x49 = x39; + x50 = x41; + x51 = x43; + x52 = x44; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x47, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x48, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x49, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x50, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x51, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x52, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_sub(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_sm2_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_sm2_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, x12, x28, x14, x30, x16, x32, x18, x34, x20, x22, x23, x24, x26, x27, x29, x31, x33, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)(UINTMAX_C(0)))-(x0); + x9 = ((uintptr_t)(UINTMAX_C(0)))-(x1); + x10 = (x9)-((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x8))); + x11 = ((uintptr_t)(UINTMAX_C(0)))-(x2); + x12 = (x11)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = ((uintptr_t)(UINTMAX_C(0)))-(x3); + x14 = (x13)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)(UINTMAX_C(0)))-(x4); + x16 = (x15)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)(UINTMAX_C(0)))-(x5); + x18 = (x17)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = ((uintptr_t)(UINTMAX_C(0)))-(x6); + x20 = (x19)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = ((uintptr_t)(UINTMAX_C(0)))-(x7); + x22 = (x21)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)(UINTMAX_C(0))))); + x24 = (x8)+(x23); + x25 = ((uintptr_t)((x24)<(x8)))+(x10); + x26 = (x25)+(x23); + x27 = (((uintptr_t)((x25)<(x10)))+((uintptr_t)((x26)<(x23))))+(x12); + x28 = ((uintptr_t)((x27)<(x12)))+(x14); + x29 = (x28)+(x23); + x30 = (((uintptr_t)((x28)<(x14)))+((uintptr_t)((x29)<(x23))))+(x16); + x31 = (x30)+(x23); + x32 = (((uintptr_t)((x30)<(x16)))+((uintptr_t)((x31)<(x23))))+(x18); + x33 = (x32)+(x23); + x34 = (((uintptr_t)((x32)<(x18)))+((uintptr_t)((x33)<(x23))))+(x20); + x35 = (x34)+(x23); + x36 = ((((uintptr_t)((x34)<(x20)))+((uintptr_t)((x35)<(x23))))+(x22))+((x23)&((uintptr_t)(UINTMAX_C(4294967294)))); + x37 = x24; + x38 = x26; + x39 = x27; + x40 = x29; + x41 = x31; + x42 = x33; + x43 = x35; + x44 = x36; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x39, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x44, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_opp(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x19, x17, x23, x15, x13, x25, x14, x11, x27, x12, x9, x8, x20, x21, x18, x16, x22, x24, x26, x28, x1, x30, x31, x32, x33, x34, x35, x36, x37, x29, x10, x57, x55, x61, x53, x51, x63, x52, x49, x65, x50, x47, x38, x68, x39, x58, x70, x40, x59, x56, x72, x41, x54, x74, x42, x60, x76, x43, x62, x78, x44, x64, x80, x45, x66, x82, x46, x67, x48, x2, x69, x71, x73, x75, x77, x79, x81, x83, x104, x102, x108, x100, x98, x110, x99, x96, x112, x97, x94, x85, x115, x86, x105, x117, x87, x106, x103, x119, x88, x101, x121, x89, x107, x123, x90, x109, x125, x91, x111, x127, x92, x113, x129, x93, x84, x114, x95, x3, x116, x118, x120, x122, x124, x126, x128, x130, x151, x149, x155, x147, x145, x157, x146, x143, x159, x144, x141, x132, x162, x133, x152, x164, x134, x153, x150, x166, x135, x148, x168, x136, x154, x170, x137, x156, x172, x138, x158, x174, x139, x160, x176, x140, x131, x161, x142, x4, x163, x165, x167, x169, x171, x173, x175, x177, x198, x196, x202, x194, x192, x204, x193, x190, x206, x191, x188, x179, x209, x180, x199, x211, x181, x200, x197, x213, x182, x195, x215, x183, x201, x217, x184, x203, x219, x185, x205, x221, x186, x207, x223, x187, x178, x208, x189, x5, x210, x212, x214, x216, x218, x220, x222, x224, x245, x243, x249, x241, x239, x251, x240, x237, x253, x238, x235, x226, x256, x227, x246, x258, x228, x247, x244, x260, x229, x242, x262, x230, x248, x264, x231, x250, x266, x232, x252, x268, x233, x254, x270, x234, x225, x255, x236, x6, x257, x259, x261, x263, x265, x267, x269, x271, x292, x290, x296, x288, x286, x298, x287, x284, x300, x285, x282, x273, x303, x274, x293, x305, x275, x294, x291, x307, x276, x289, x309, x277, x295, x311, x278, x297, x313, x279, x299, x315, x280, x301, x317, x281, x272, x302, x283, x7, x304, x306, x308, x310, x312, x314, x316, x318, x339, x337, x343, x335, x333, x345, x334, x331, x347, x332, x329, x320, x350, x321, x340, x352, x322, x341, x338, x354, x323, x336, x356, x324, x342, x358, x325, x344, x360, x326, x346, x362, x327, x348, x364, x328, x319, x349, x330, x368, x371, x373, x375, x377, x366, x379, x351, x382, x367, x383, x353, x385, x369, x386, x355, x388, x370, x389, x357, x391, x372, x392, x359, x394, x374, x395, x361, x397, x376, x398, x363, x400, x378, x401, x381, x365, x403, x380, x404, x384, x387, x390, x393, x396, x399, x402, x405, x406, x407, x408, x409, x410, x411, x412, x413; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x0; + x9 = (x8)*((uintptr_t)(UINTMAX_C(4294967294))); + x10 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967294)))); + x11 = (x8)*((uintptr_t)(UINTMAX_C(4294967295))); + x12 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x13 = (x8)*((uintptr_t)(UINTMAX_C(4294967295))); + x14 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x15 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x16 = (x8)*((uintptr_t)(UINTMAX_C(4294967295))); + x17 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x18 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x19 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x20 = (x19)+((x8)*((uintptr_t)(UINTMAX_C(4294967295)))); + x21 = (uintptr_t)((x20)<(x19)); + x22 = (x17)+((x8)*((uintptr_t)(UINTMAX_C(4294967295)))); + x23 = ((uintptr_t)((x22)<(x17)))+(x15); + x24 = (x23)+(x13); + x25 = (((uintptr_t)((x23)<(x15)))+((uintptr_t)((x24)<(x13))))+(x14); + x26 = (x25)+(x11); + x27 = (((uintptr_t)((x25)<(x14)))+((uintptr_t)((x26)<(x11))))+(x12); + x28 = (x27)+(x9); + x29 = ((uintptr_t)((x27)<(x12)))+((uintptr_t)((x28)<(x9))); + x30 = ((uintptr_t)(((x8)+((x8)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x8)))+(x20); + x31 = ((uintptr_t)((x30)<(x20)))+((x21)+(x18)); + x32 = ((uintptr_t)((x31)<((x21)+(x18))))+(x16); + x33 = ((uintptr_t)((x32)<(x16)))+(x22); + x34 = ((uintptr_t)((x33)<(x22)))+(x24); + x35 = ((uintptr_t)((x34)<(x24)))+(x26); + x36 = ((uintptr_t)((x35)<(x26)))+(x28); + x37 = (uintptr_t)((x36)<(x28)); + x38 = (x30)+(x1); + x39 = ((uintptr_t)((x38)<(x30)))+(x31); + x40 = ((uintptr_t)((x39)<(x31)))+(x32); + 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)+((x29)+(x10))); + x46 = (uintptr_t)((x45)<((x37)+((x29)+(x10)))); + x47 = (x38)*((uintptr_t)(UINTMAX_C(4294967294))); + x48 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967294)))); + x49 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x50 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x51 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x52 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x53 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x54 = (x38)*((uintptr_t)(UINTMAX_C(4294967295))); + x55 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x56 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x57 = _br2_mulhuu((x38), ((uintptr_t)(UINTMAX_C(4294967295)))); + x58 = (x57)+((x38)*((uintptr_t)(UINTMAX_C(4294967295)))); + x59 = (uintptr_t)((x58)<(x57)); + x60 = (x55)+((x38)*((uintptr_t)(UINTMAX_C(4294967295)))); + x61 = ((uintptr_t)((x60)<(x55)))+(x53); + x62 = (x61)+(x51); + x63 = (((uintptr_t)((x61)<(x53)))+((uintptr_t)((x62)<(x51))))+(x52); + x64 = (x63)+(x49); + x65 = (((uintptr_t)((x63)<(x52)))+((uintptr_t)((x64)<(x49))))+(x50); + x66 = (x65)+(x47); + x67 = ((uintptr_t)((x65)<(x50)))+((uintptr_t)((x66)<(x47))); + x68 = ((uintptr_t)(((x38)+((x38)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x38)))+(x39); + x69 = (x68)+(x58); + x70 = (((uintptr_t)((x68)<(x39)))+((uintptr_t)((x69)<(x58))))+(x40); + x71 = (x70)+((x59)+(x56)); + x72 = (((uintptr_t)((x70)<(x40)))+((uintptr_t)((x71)<((x59)+(x56)))))+(x41); + x73 = (x72)+(x54); + x74 = (((uintptr_t)((x72)<(x41)))+((uintptr_t)((x73)<(x54))))+(x42); + x75 = (x74)+(x60); + x76 = (((uintptr_t)((x74)<(x42)))+((uintptr_t)((x75)<(x60))))+(x43); + x77 = (x76)+(x62); + x78 = (((uintptr_t)((x76)<(x43)))+((uintptr_t)((x77)<(x62))))+(x44); + x79 = (x78)+(x64); + x80 = (((uintptr_t)((x78)<(x44)))+((uintptr_t)((x79)<(x64))))+(x45); + x81 = (x80)+(x66); + x82 = (((uintptr_t)((x80)<(x45)))+((uintptr_t)((x81)<(x66))))+(x46); + x83 = (x82)+((x67)+(x48)); + x84 = ((uintptr_t)((x82)<(x46)))+((uintptr_t)((x83)<((x67)+(x48)))); + x85 = (x69)+(x2); + x86 = ((uintptr_t)((x85)<(x69)))+(x71); + x87 = ((uintptr_t)((x86)<(x71)))+(x73); + x88 = ((uintptr_t)((x87)<(x73)))+(x75); + x89 = ((uintptr_t)((x88)<(x75)))+(x77); + x90 = ((uintptr_t)((x89)<(x77)))+(x79); + x91 = ((uintptr_t)((x90)<(x79)))+(x81); + x92 = ((uintptr_t)((x91)<(x81)))+(x83); + x93 = (uintptr_t)((x92)<(x83)); + x94 = (x85)*((uintptr_t)(UINTMAX_C(4294967294))); + x95 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967294)))); + x96 = (x85)*((uintptr_t)(UINTMAX_C(4294967295))); + x97 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967295)))); + x98 = (x85)*((uintptr_t)(UINTMAX_C(4294967295))); + x99 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967295)))); + x100 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967295)))); + x101 = (x85)*((uintptr_t)(UINTMAX_C(4294967295))); + x102 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967295)))); + x103 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967295)))); + x104 = _br2_mulhuu((x85), ((uintptr_t)(UINTMAX_C(4294967295)))); + x105 = (x104)+((x85)*((uintptr_t)(UINTMAX_C(4294967295)))); + x106 = (uintptr_t)((x105)<(x104)); + x107 = (x102)+((x85)*((uintptr_t)(UINTMAX_C(4294967295)))); + x108 = ((uintptr_t)((x107)<(x102)))+(x100); + x109 = (x108)+(x98); + x110 = (((uintptr_t)((x108)<(x100)))+((uintptr_t)((x109)<(x98))))+(x99); + x111 = (x110)+(x96); + x112 = (((uintptr_t)((x110)<(x99)))+((uintptr_t)((x111)<(x96))))+(x97); + x113 = (x112)+(x94); + x114 = ((uintptr_t)((x112)<(x97)))+((uintptr_t)((x113)<(x94))); + x115 = ((uintptr_t)(((x85)+((x85)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x85)))+(x86); + x116 = (x115)+(x105); + x117 = (((uintptr_t)((x115)<(x86)))+((uintptr_t)((x116)<(x105))))+(x87); + x118 = (x117)+((x106)+(x103)); + x119 = (((uintptr_t)((x117)<(x87)))+((uintptr_t)((x118)<((x106)+(x103)))))+(x88); + x120 = (x119)+(x101); + x121 = (((uintptr_t)((x119)<(x88)))+((uintptr_t)((x120)<(x101))))+(x89); + x122 = (x121)+(x107); + x123 = (((uintptr_t)((x121)<(x89)))+((uintptr_t)((x122)<(x107))))+(x90); + x124 = (x123)+(x109); + x125 = (((uintptr_t)((x123)<(x90)))+((uintptr_t)((x124)<(x109))))+(x91); + x126 = (x125)+(x111); + x127 = (((uintptr_t)((x125)<(x91)))+((uintptr_t)((x126)<(x111))))+(x92); + x128 = (x127)+(x113); + x129 = (((uintptr_t)((x127)<(x92)))+((uintptr_t)((x128)<(x113))))+((x93)+(x84)); + x130 = (x129)+((x114)+(x95)); + x131 = ((uintptr_t)((x129)<((x93)+(x84))))+((uintptr_t)((x130)<((x114)+(x95)))); + x132 = (x116)+(x3); + x133 = ((uintptr_t)((x132)<(x116)))+(x118); + x134 = ((uintptr_t)((x133)<(x118)))+(x120); + x135 = ((uintptr_t)((x134)<(x120)))+(x122); + x136 = ((uintptr_t)((x135)<(x122)))+(x124); + x137 = ((uintptr_t)((x136)<(x124)))+(x126); + x138 = ((uintptr_t)((x137)<(x126)))+(x128); + x139 = ((uintptr_t)((x138)<(x128)))+(x130); + x140 = (uintptr_t)((x139)<(x130)); + x141 = (x132)*((uintptr_t)(UINTMAX_C(4294967294))); + x142 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967294)))); + x143 = (x132)*((uintptr_t)(UINTMAX_C(4294967295))); + x144 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967295)))); + x145 = (x132)*((uintptr_t)(UINTMAX_C(4294967295))); + x146 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967295)))); + x147 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967295)))); + x148 = (x132)*((uintptr_t)(UINTMAX_C(4294967295))); + x149 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967295)))); + x150 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967295)))); + x151 = _br2_mulhuu((x132), ((uintptr_t)(UINTMAX_C(4294967295)))); + x152 = (x151)+((x132)*((uintptr_t)(UINTMAX_C(4294967295)))); + x153 = (uintptr_t)((x152)<(x151)); + x154 = (x149)+((x132)*((uintptr_t)(UINTMAX_C(4294967295)))); + x155 = ((uintptr_t)((x154)<(x149)))+(x147); + x156 = (x155)+(x145); + x157 = (((uintptr_t)((x155)<(x147)))+((uintptr_t)((x156)<(x145))))+(x146); + x158 = (x157)+(x143); + x159 = (((uintptr_t)((x157)<(x146)))+((uintptr_t)((x158)<(x143))))+(x144); + x160 = (x159)+(x141); + x161 = ((uintptr_t)((x159)<(x144)))+((uintptr_t)((x160)<(x141))); + x162 = ((uintptr_t)(((x132)+((x132)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x132)))+(x133); + x163 = (x162)+(x152); + x164 = (((uintptr_t)((x162)<(x133)))+((uintptr_t)((x163)<(x152))))+(x134); + x165 = (x164)+((x153)+(x150)); + x166 = (((uintptr_t)((x164)<(x134)))+((uintptr_t)((x165)<((x153)+(x150)))))+(x135); + x167 = (x166)+(x148); + x168 = (((uintptr_t)((x166)<(x135)))+((uintptr_t)((x167)<(x148))))+(x136); + x169 = (x168)+(x154); + x170 = (((uintptr_t)((x168)<(x136)))+((uintptr_t)((x169)<(x154))))+(x137); + x171 = (x170)+(x156); + x172 = (((uintptr_t)((x170)<(x137)))+((uintptr_t)((x171)<(x156))))+(x138); + x173 = (x172)+(x158); + x174 = (((uintptr_t)((x172)<(x138)))+((uintptr_t)((x173)<(x158))))+(x139); + x175 = (x174)+(x160); + x176 = (((uintptr_t)((x174)<(x139)))+((uintptr_t)((x175)<(x160))))+((x140)+(x131)); + x177 = (x176)+((x161)+(x142)); + x178 = ((uintptr_t)((x176)<((x140)+(x131))))+((uintptr_t)((x177)<((x161)+(x142)))); + x179 = (x163)+(x4); + x180 = ((uintptr_t)((x179)<(x163)))+(x165); + x181 = ((uintptr_t)((x180)<(x165)))+(x167); + x182 = ((uintptr_t)((x181)<(x167)))+(x169); + x183 = ((uintptr_t)((x182)<(x169)))+(x171); + x184 = ((uintptr_t)((x183)<(x171)))+(x173); + x185 = ((uintptr_t)((x184)<(x173)))+(x175); + x186 = ((uintptr_t)((x185)<(x175)))+(x177); + x187 = (uintptr_t)((x186)<(x177)); + x188 = (x179)*((uintptr_t)(UINTMAX_C(4294967294))); + x189 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967294)))); + x190 = (x179)*((uintptr_t)(UINTMAX_C(4294967295))); + x191 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967295)))); + x192 = (x179)*((uintptr_t)(UINTMAX_C(4294967295))); + x193 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967295)))); + x194 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967295)))); + x195 = (x179)*((uintptr_t)(UINTMAX_C(4294967295))); + x196 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967295)))); + x197 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967295)))); + x198 = _br2_mulhuu((x179), ((uintptr_t)(UINTMAX_C(4294967295)))); + x199 = (x198)+((x179)*((uintptr_t)(UINTMAX_C(4294967295)))); + x200 = (uintptr_t)((x199)<(x198)); + x201 = (x196)+((x179)*((uintptr_t)(UINTMAX_C(4294967295)))); + x202 = ((uintptr_t)((x201)<(x196)))+(x194); + x203 = (x202)+(x192); + x204 = (((uintptr_t)((x202)<(x194)))+((uintptr_t)((x203)<(x192))))+(x193); + x205 = (x204)+(x190); + x206 = (((uintptr_t)((x204)<(x193)))+((uintptr_t)((x205)<(x190))))+(x191); + x207 = (x206)+(x188); + x208 = ((uintptr_t)((x206)<(x191)))+((uintptr_t)((x207)<(x188))); + x209 = ((uintptr_t)(((x179)+((x179)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x179)))+(x180); + x210 = (x209)+(x199); + x211 = (((uintptr_t)((x209)<(x180)))+((uintptr_t)((x210)<(x199))))+(x181); + x212 = (x211)+((x200)+(x197)); + x213 = (((uintptr_t)((x211)<(x181)))+((uintptr_t)((x212)<((x200)+(x197)))))+(x182); + x214 = (x213)+(x195); + x215 = (((uintptr_t)((x213)<(x182)))+((uintptr_t)((x214)<(x195))))+(x183); + x216 = (x215)+(x201); + x217 = (((uintptr_t)((x215)<(x183)))+((uintptr_t)((x216)<(x201))))+(x184); + x218 = (x217)+(x203); + x219 = (((uintptr_t)((x217)<(x184)))+((uintptr_t)((x218)<(x203))))+(x185); + x220 = (x219)+(x205); + x221 = (((uintptr_t)((x219)<(x185)))+((uintptr_t)((x220)<(x205))))+(x186); + x222 = (x221)+(x207); + x223 = (((uintptr_t)((x221)<(x186)))+((uintptr_t)((x222)<(x207))))+((x187)+(x178)); + x224 = (x223)+((x208)+(x189)); + x225 = ((uintptr_t)((x223)<((x187)+(x178))))+((uintptr_t)((x224)<((x208)+(x189)))); + x226 = (x210)+(x5); + x227 = ((uintptr_t)((x226)<(x210)))+(x212); + x228 = ((uintptr_t)((x227)<(x212)))+(x214); + x229 = ((uintptr_t)((x228)<(x214)))+(x216); + x230 = ((uintptr_t)((x229)<(x216)))+(x218); + x231 = ((uintptr_t)((x230)<(x218)))+(x220); + x232 = ((uintptr_t)((x231)<(x220)))+(x222); + x233 = ((uintptr_t)((x232)<(x222)))+(x224); + x234 = (uintptr_t)((x233)<(x224)); + x235 = (x226)*((uintptr_t)(UINTMAX_C(4294967294))); + x236 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967294)))); + x237 = (x226)*((uintptr_t)(UINTMAX_C(4294967295))); + x238 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967295)))); + x239 = (x226)*((uintptr_t)(UINTMAX_C(4294967295))); + x240 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967295)))); + x241 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967295)))); + x242 = (x226)*((uintptr_t)(UINTMAX_C(4294967295))); + x243 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967295)))); + x244 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967295)))); + x245 = _br2_mulhuu((x226), ((uintptr_t)(UINTMAX_C(4294967295)))); + x246 = (x245)+((x226)*((uintptr_t)(UINTMAX_C(4294967295)))); + x247 = (uintptr_t)((x246)<(x245)); + x248 = (x243)+((x226)*((uintptr_t)(UINTMAX_C(4294967295)))); + x249 = ((uintptr_t)((x248)<(x243)))+(x241); + x250 = (x249)+(x239); + x251 = (((uintptr_t)((x249)<(x241)))+((uintptr_t)((x250)<(x239))))+(x240); + x252 = (x251)+(x237); + x253 = (((uintptr_t)((x251)<(x240)))+((uintptr_t)((x252)<(x237))))+(x238); + x254 = (x253)+(x235); + x255 = ((uintptr_t)((x253)<(x238)))+((uintptr_t)((x254)<(x235))); + x256 = ((uintptr_t)(((x226)+((x226)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x226)))+(x227); + x257 = (x256)+(x246); + x258 = (((uintptr_t)((x256)<(x227)))+((uintptr_t)((x257)<(x246))))+(x228); + x259 = (x258)+((x247)+(x244)); + x260 = (((uintptr_t)((x258)<(x228)))+((uintptr_t)((x259)<((x247)+(x244)))))+(x229); + x261 = (x260)+(x242); + x262 = (((uintptr_t)((x260)<(x229)))+((uintptr_t)((x261)<(x242))))+(x230); + x263 = (x262)+(x248); + x264 = (((uintptr_t)((x262)<(x230)))+((uintptr_t)((x263)<(x248))))+(x231); + x265 = (x264)+(x250); + x266 = (((uintptr_t)((x264)<(x231)))+((uintptr_t)((x265)<(x250))))+(x232); + x267 = (x266)+(x252); + x268 = (((uintptr_t)((x266)<(x232)))+((uintptr_t)((x267)<(x252))))+(x233); + x269 = (x268)+(x254); + x270 = (((uintptr_t)((x268)<(x233)))+((uintptr_t)((x269)<(x254))))+((x234)+(x225)); + x271 = (x270)+((x255)+(x236)); + x272 = ((uintptr_t)((x270)<((x234)+(x225))))+((uintptr_t)((x271)<((x255)+(x236)))); + x273 = (x257)+(x6); + x274 = ((uintptr_t)((x273)<(x257)))+(x259); + x275 = ((uintptr_t)((x274)<(x259)))+(x261); + x276 = ((uintptr_t)((x275)<(x261)))+(x263); + x277 = ((uintptr_t)((x276)<(x263)))+(x265); + x278 = ((uintptr_t)((x277)<(x265)))+(x267); + x279 = ((uintptr_t)((x278)<(x267)))+(x269); + x280 = ((uintptr_t)((x279)<(x269)))+(x271); + x281 = (uintptr_t)((x280)<(x271)); + x282 = (x273)*((uintptr_t)(UINTMAX_C(4294967294))); + x283 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967294)))); + x284 = (x273)*((uintptr_t)(UINTMAX_C(4294967295))); + x285 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967295)))); + x286 = (x273)*((uintptr_t)(UINTMAX_C(4294967295))); + x287 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967295)))); + x288 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967295)))); + x289 = (x273)*((uintptr_t)(UINTMAX_C(4294967295))); + x290 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967295)))); + x291 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967295)))); + x292 = _br2_mulhuu((x273), ((uintptr_t)(UINTMAX_C(4294967295)))); + x293 = (x292)+((x273)*((uintptr_t)(UINTMAX_C(4294967295)))); + x294 = (uintptr_t)((x293)<(x292)); + x295 = (x290)+((x273)*((uintptr_t)(UINTMAX_C(4294967295)))); + x296 = ((uintptr_t)((x295)<(x290)))+(x288); + x297 = (x296)+(x286); + x298 = (((uintptr_t)((x296)<(x288)))+((uintptr_t)((x297)<(x286))))+(x287); + x299 = (x298)+(x284); + x300 = (((uintptr_t)((x298)<(x287)))+((uintptr_t)((x299)<(x284))))+(x285); + x301 = (x300)+(x282); + x302 = ((uintptr_t)((x300)<(x285)))+((uintptr_t)((x301)<(x282))); + x303 = ((uintptr_t)(((x273)+((x273)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x273)))+(x274); + x304 = (x303)+(x293); + x305 = (((uintptr_t)((x303)<(x274)))+((uintptr_t)((x304)<(x293))))+(x275); + x306 = (x305)+((x294)+(x291)); + x307 = (((uintptr_t)((x305)<(x275)))+((uintptr_t)((x306)<((x294)+(x291)))))+(x276); + x308 = (x307)+(x289); + x309 = (((uintptr_t)((x307)<(x276)))+((uintptr_t)((x308)<(x289))))+(x277); + x310 = (x309)+(x295); + x311 = (((uintptr_t)((x309)<(x277)))+((uintptr_t)((x310)<(x295))))+(x278); + x312 = (x311)+(x297); + x313 = (((uintptr_t)((x311)<(x278)))+((uintptr_t)((x312)<(x297))))+(x279); + x314 = (x313)+(x299); + x315 = (((uintptr_t)((x313)<(x279)))+((uintptr_t)((x314)<(x299))))+(x280); + x316 = (x315)+(x301); + x317 = (((uintptr_t)((x315)<(x280)))+((uintptr_t)((x316)<(x301))))+((x281)+(x272)); + x318 = (x317)+((x302)+(x283)); + x319 = ((uintptr_t)((x317)<((x281)+(x272))))+((uintptr_t)((x318)<((x302)+(x283)))); + x320 = (x304)+(x7); + x321 = ((uintptr_t)((x320)<(x304)))+(x306); + x322 = ((uintptr_t)((x321)<(x306)))+(x308); + x323 = ((uintptr_t)((x322)<(x308)))+(x310); + x324 = ((uintptr_t)((x323)<(x310)))+(x312); + x325 = ((uintptr_t)((x324)<(x312)))+(x314); + x326 = ((uintptr_t)((x325)<(x314)))+(x316); + x327 = ((uintptr_t)((x326)<(x316)))+(x318); + x328 = (uintptr_t)((x327)<(x318)); + x329 = (x320)*((uintptr_t)(UINTMAX_C(4294967294))); + x330 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967294)))); + x331 = (x320)*((uintptr_t)(UINTMAX_C(4294967295))); + x332 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967295)))); + x333 = (x320)*((uintptr_t)(UINTMAX_C(4294967295))); + x334 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967295)))); + x335 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967295)))); + x336 = (x320)*((uintptr_t)(UINTMAX_C(4294967295))); + x337 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967295)))); + x338 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967295)))); + x339 = _br2_mulhuu((x320), ((uintptr_t)(UINTMAX_C(4294967295)))); + x340 = (x339)+((x320)*((uintptr_t)(UINTMAX_C(4294967295)))); + x341 = (uintptr_t)((x340)<(x339)); + x342 = (x337)+((x320)*((uintptr_t)(UINTMAX_C(4294967295)))); + x343 = ((uintptr_t)((x342)<(x337)))+(x335); + x344 = (x343)+(x333); + x345 = (((uintptr_t)((x343)<(x335)))+((uintptr_t)((x344)<(x333))))+(x334); + x346 = (x345)+(x331); + x347 = (((uintptr_t)((x345)<(x334)))+((uintptr_t)((x346)<(x331))))+(x332); + x348 = (x347)+(x329); + x349 = ((uintptr_t)((x347)<(x332)))+((uintptr_t)((x348)<(x329))); + x350 = ((uintptr_t)(((x320)+((x320)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x320)))+(x321); + x351 = (x350)+(x340); + x352 = (((uintptr_t)((x350)<(x321)))+((uintptr_t)((x351)<(x340))))+(x322); + x353 = (x352)+((x341)+(x338)); + x354 = (((uintptr_t)((x352)<(x322)))+((uintptr_t)((x353)<((x341)+(x338)))))+(x323); + x355 = (x354)+(x336); + x356 = (((uintptr_t)((x354)<(x323)))+((uintptr_t)((x355)<(x336))))+(x324); + x357 = (x356)+(x342); + x358 = (((uintptr_t)((x356)<(x324)))+((uintptr_t)((x357)<(x342))))+(x325); + x359 = (x358)+(x344); + x360 = (((uintptr_t)((x358)<(x325)))+((uintptr_t)((x359)<(x344))))+(x326); + x361 = (x360)+(x346); + x362 = (((uintptr_t)((x360)<(x326)))+((uintptr_t)((x361)<(x346))))+(x327); + x363 = (x362)+(x348); + x364 = (((uintptr_t)((x362)<(x327)))+((uintptr_t)((x363)<(x348))))+((x328)+(x319)); + x365 = (x364)+((x349)+(x330)); + x366 = ((uintptr_t)((x364)<((x328)+(x319))))+((uintptr_t)((x365)<((x349)+(x330)))); + x367 = (x351)-((uintptr_t)(UINTMAX_C(4294967295))); + x368 = (x353)-((uintptr_t)(UINTMAX_C(4294967295))); + x369 = (x368)-((uintptr_t)((x351)<(x367))); + x370 = (x355)-(((uintptr_t)((x353)<(x368)))+((uintptr_t)((x368)<(x369)))); + x371 = (x357)-((uintptr_t)(UINTMAX_C(4294967295))); + x372 = (x371)-((uintptr_t)((x355)<(x370))); + x373 = (x359)-((uintptr_t)(UINTMAX_C(4294967295))); + x374 = (x373)-(((uintptr_t)((x357)<(x371)))+((uintptr_t)((x371)<(x372)))); + x375 = (x361)-((uintptr_t)(UINTMAX_C(4294967295))); + x376 = (x375)-(((uintptr_t)((x359)<(x373)))+((uintptr_t)((x373)<(x374)))); + x377 = (x363)-((uintptr_t)(UINTMAX_C(4294967295))); + x378 = (x377)-(((uintptr_t)((x361)<(x375)))+((uintptr_t)((x375)<(x376)))); + x379 = (x365)-((uintptr_t)(UINTMAX_C(4294967294))); + x380 = (x379)-(((uintptr_t)((x363)<(x377)))+((uintptr_t)((x377)<(x378)))); + x381 = (uintptr_t)((x366)<((x366)-(((uintptr_t)((x365)<(x379)))+((uintptr_t)((x379)<(x380)))))); + x382 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x383 = (x382)^((uintptr_t)(UINTMAX_C(4294967295))); + x384 = ((x351)&(x382))|((x367)&(x383)); + x385 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x386 = (x385)^((uintptr_t)(UINTMAX_C(4294967295))); + x387 = ((x353)&(x385))|((x369)&(x386)); + x388 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x389 = (x388)^((uintptr_t)(UINTMAX_C(4294967295))); + x390 = ((x355)&(x388))|((x370)&(x389)); + x391 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x392 = (x391)^((uintptr_t)(UINTMAX_C(4294967295))); + x393 = ((x357)&(x391))|((x372)&(x392)); + x394 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x395 = (x394)^((uintptr_t)(UINTMAX_C(4294967295))); + x396 = ((x359)&(x394))|((x374)&(x395)); + x397 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x398 = (x397)^((uintptr_t)(UINTMAX_C(4294967295))); + x399 = ((x361)&(x397))|((x376)&(x398)); + x400 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x401 = (x400)^((uintptr_t)(UINTMAX_C(4294967295))); + x402 = ((x363)&(x400))|((x378)&(x401)); + x403 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x381)==((uintptr_t)(UINTMAX_C(0))))); + x404 = (x403)^((uintptr_t)(UINTMAX_C(4294967295))); + x405 = ((x365)&(x403))|((x380)&(x404)); + x406 = x384; + x407 = x387; + x408 = x390; + x409 = x393; + x410 = x396; + x411 = x399; + x412 = x402; + x413 = x405; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x406, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x407, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x408, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x409, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x410, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x411, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x412, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x413, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_from_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x4, x5, x6, x7, x0, x26, x28, x24, x22, x30, x23, x20, x32, x21, x15, x18, x36, x19, x16, x49, x47, x53, x45, x43, x55, x44, x41, x57, x42, x39, x25, x60, x27, x50, x62, x29, x51, x48, x64, x31, x46, x66, x33, x52, x68, x34, x54, x70, x35, x56, x72, x37, x58, x74, x38, x17, x59, x40, x86, x88, x85, x83, x90, x84, x81, x92, x82, x79, x96, x80, x77, x8, x61, x100, x63, x87, x102, x65, x89, x104, x67, x91, x106, x69, x93, x108, x71, x94, x110, x73, x95, x112, x75, x97, x125, x123, x129, x121, x119, x131, x120, x117, x133, x118, x115, x99, x136, x101, x126, x138, x103, x127, x124, x140, x105, x122, x142, x107, x128, x144, x109, x130, x146, x111, x132, x148, x113, x134, x150, x114, x76, x98, x78, x135, x116, x162, x164, x161, x159, x166, x160, x157, x168, x158, x155, x172, x156, x153, x9, x137, x176, x139, x163, x178, x141, x165, x180, x143, x167, x182, x145, x169, x184, x147, x170, x186, x149, x171, x188, x151, x173, x201, x199, x205, x197, x195, x207, x196, x193, x209, x194, x191, x175, x212, x177, x202, x214, x179, x203, x200, x216, x181, x198, x218, x183, x204, x220, x185, x206, x222, x187, x208, x224, x189, x210, x226, x190, x152, x174, x154, x211, x192, x238, x240, x237, x235, x242, x236, x233, x244, x234, x231, x248, x232, x229, x10, x213, x252, x215, x239, x254, x217, x241, x256, x219, x243, x258, x221, x245, x260, x223, x246, x262, x225, x247, x264, x227, x249, x277, x275, x281, x273, x271, x283, x272, x269, x285, x270, x267, x251, x288, x253, x278, x290, x255, x279, x276, x292, x257, x274, x294, x259, x280, x296, x261, x282, x298, x263, x284, x300, x265, x286, x302, x266, x228, x250, x230, x287, x268, x314, x316, x313, x311, x318, x312, x309, x320, x310, x307, x324, x308, x305, x11, x289, x328, x291, x315, x330, x293, x317, x332, x295, x319, x334, x297, x321, x336, x299, x322, x338, x301, x323, x340, x303, x325, x353, x351, x357, x349, x347, x359, x348, x345, x361, x346, x343, x327, x364, x329, x354, x366, x331, x355, x352, x368, x333, x350, x370, x335, x356, x372, x337, x358, x374, x339, x360, x376, x341, x362, x378, x342, x304, x326, x306, x363, x344, x390, x392, x389, x387, x394, x388, x385, x396, x386, x383, x400, x384, x381, x12, x365, x404, x367, x391, x406, x369, x393, x408, x371, x395, x410, x373, x397, x412, x375, x398, x414, x377, x399, x416, x379, x401, x429, x427, x433, x425, x423, x435, x424, x421, x437, x422, x419, x403, x440, x405, x430, x442, x407, x431, x428, x444, x409, x426, x446, x411, x432, x448, x413, x434, x450, x415, x436, x452, x417, x438, x454, x418, x380, x402, x382, x439, x420, x466, x468, x465, x463, x470, x464, x461, x472, x462, x459, x476, x460, x457, x13, x441, x480, x443, x467, x482, x445, x469, x484, x447, x471, x486, x449, x473, x488, x451, x474, x490, x453, x475, x492, x455, x477, x505, x503, x509, x501, x499, x511, x500, x497, x513, x498, x495, x479, x516, x481, x506, x518, x483, x507, x504, x520, x485, x502, x522, x487, x508, x524, x489, x510, x526, x491, x512, x528, x493, x514, x530, x494, x456, x478, x458, x515, x496, x542, x544, x541, x539, x546, x540, x537, x548, x538, x535, x552, x536, x533, x14, x517, x556, x519, x543, x558, x521, x545, x560, x523, x547, x562, x525, x549, x564, x527, x550, x566, x529, x551, x568, x531, x553, x581, x579, x585, x577, x575, x587, x576, x573, x589, x574, x571, x555, x592, x557, x582, x594, x559, x583, x580, x596, x561, x578, x598, x563, x584, x600, x565, x586, x602, x567, x588, x604, x569, x590, x606, x570, x532, x554, x534, x591, x572, x610, x613, x615, x617, x619, x608, x621, x593, x624, x609, x625, x595, x627, x611, x628, x597, x630, x612, x631, x599, x633, x614, x634, x601, x636, x616, x637, x603, x639, x618, x640, x605, x642, x620, x643, x623, x607, x645, x622, x646, x626, x629, x632, x635, x638, x641, x644, x647, x648, x649, x650, x651, x652, x653, x654, x655; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(4))); + x17 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(4)))); + x18 = (x15)*((uintptr_t)(UINTMAX_C(2))); + x19 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(2)))); + x20 = (x15)*((uintptr_t)(UINTMAX_C(2))); + x21 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(2)))); + x22 = (x15)*((uintptr_t)(UINTMAX_C(4294967295))); + x23 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(4294967295)))); + x24 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(2)))); + x25 = (x15)*((uintptr_t)(UINTMAX_C(3))); + x26 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(3)))); + x27 = (x26)+((x15)*((uintptr_t)(UINTMAX_C(2)))); + x28 = ((uintptr_t)((x27)<(x26)))+(x24); + x29 = (x28)+(x22); + x30 = (((uintptr_t)((x28)<(x24)))+((uintptr_t)((x29)<(x22))))+(x23); + x31 = (x30)+(x20); + x32 = (((uintptr_t)((x30)<(x23)))+((uintptr_t)((x31)<(x20))))+(x21); + x33 = (x32)+(x15); + x34 = (((uintptr_t)((x32)<(x21)))+((uintptr_t)((x33)<(x15))))+(x15); + x35 = ((uintptr_t)((x34)<(x15)))+(x18); + x36 = ((uintptr_t)((x35)<(x18)))+(x19); + x37 = (x36)+(x16); + x38 = ((uintptr_t)((x36)<(x19)))+((uintptr_t)((x37)<(x16))); + x39 = (x25)*((uintptr_t)(UINTMAX_C(4294967294))); + x40 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967294)))); + x41 = (x25)*((uintptr_t)(UINTMAX_C(4294967295))); + x42 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967295)))); + x43 = (x25)*((uintptr_t)(UINTMAX_C(4294967295))); + x44 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967295)))); + x45 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967295)))); + x46 = (x25)*((uintptr_t)(UINTMAX_C(4294967295))); + x47 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967295)))); + x48 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967295)))); + x49 = _br2_mulhuu((x25), ((uintptr_t)(UINTMAX_C(4294967295)))); + x50 = (x49)+((x25)*((uintptr_t)(UINTMAX_C(4294967295)))); + x51 = (uintptr_t)((x50)<(x49)); + x52 = (x47)+((x25)*((uintptr_t)(UINTMAX_C(4294967295)))); + x53 = ((uintptr_t)((x52)<(x47)))+(x45); + x54 = (x53)+(x43); + x55 = (((uintptr_t)((x53)<(x45)))+((uintptr_t)((x54)<(x43))))+(x44); + x56 = (x55)+(x41); + x57 = (((uintptr_t)((x55)<(x44)))+((uintptr_t)((x56)<(x41))))+(x42); + x58 = (x57)+(x39); + x59 = ((uintptr_t)((x57)<(x42)))+((uintptr_t)((x58)<(x39))); + x60 = ((uintptr_t)(((x25)+((x25)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x25)))+(x27); + x61 = (x60)+(x50); + x62 = (((uintptr_t)((x60)<(x27)))+((uintptr_t)((x61)<(x50))))+(x29); + x63 = (x62)+((x51)+(x48)); + x64 = (((uintptr_t)((x62)<(x29)))+((uintptr_t)((x63)<((x51)+(x48)))))+(x31); + x65 = (x64)+(x46); + x66 = (((uintptr_t)((x64)<(x31)))+((uintptr_t)((x65)<(x46))))+(x33); + x67 = (x66)+(x52); + x68 = (((uintptr_t)((x66)<(x33)))+((uintptr_t)((x67)<(x52))))+(x34); + x69 = (x68)+(x54); + x70 = (((uintptr_t)((x68)<(x34)))+((uintptr_t)((x69)<(x54))))+(x35); + x71 = (x70)+(x56); + x72 = (((uintptr_t)((x70)<(x35)))+((uintptr_t)((x71)<(x56))))+(x37); + x73 = (x72)+(x58); + x74 = (((uintptr_t)((x72)<(x37)))+((uintptr_t)((x73)<(x58))))+((x38)+(x17)); + x75 = (x74)+((x59)+(x40)); + x76 = ((uintptr_t)((x74)<((x38)+(x17))))+((uintptr_t)((x75)<((x59)+(x40)))); + x77 = (x8)*((uintptr_t)(UINTMAX_C(4))); + x78 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4)))); + x79 = (x8)*((uintptr_t)(UINTMAX_C(2))); + x80 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(2)))); + x81 = (x8)*((uintptr_t)(UINTMAX_C(2))); + x82 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(2)))); + x83 = (x8)*((uintptr_t)(UINTMAX_C(4294967295))); + x84 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(4294967295)))); + x85 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(2)))); + x86 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(3)))); + x87 = (x86)+((x8)*((uintptr_t)(UINTMAX_C(2)))); + 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)+(x8); + x94 = (((uintptr_t)((x92)<(x82)))+((uintptr_t)((x93)<(x8))))+(x8); + x95 = ((uintptr_t)((x94)<(x8)))+(x79); + x96 = ((uintptr_t)((x95)<(x79)))+(x80); + x97 = (x96)+(x77); + x98 = ((uintptr_t)((x96)<(x80)))+((uintptr_t)((x97)<(x77))); + x99 = (x61)+((x8)*((uintptr_t)(UINTMAX_C(3)))); + x100 = ((uintptr_t)((x99)<(x61)))+(x63); + x101 = (x100)+(x87); + x102 = (((uintptr_t)((x100)<(x63)))+((uintptr_t)((x101)<(x87))))+(x65); + x103 = (x102)+(x89); + x104 = (((uintptr_t)((x102)<(x65)))+((uintptr_t)((x103)<(x89))))+(x67); + x105 = (x104)+(x91); + x106 = (((uintptr_t)((x104)<(x67)))+((uintptr_t)((x105)<(x91))))+(x69); + x107 = (x106)+(x93); + x108 = (((uintptr_t)((x106)<(x69)))+((uintptr_t)((x107)<(x93))))+(x71); + x109 = (x108)+(x94); + x110 = (((uintptr_t)((x108)<(x71)))+((uintptr_t)((x109)<(x94))))+(x73); + x111 = (x110)+(x95); + x112 = (((uintptr_t)((x110)<(x73)))+((uintptr_t)((x111)<(x95))))+(x75); + x113 = (x112)+(x97); + x114 = ((uintptr_t)((x112)<(x75)))+((uintptr_t)((x113)<(x97))); + x115 = (x99)*((uintptr_t)(UINTMAX_C(4294967294))); + x116 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967294)))); + x117 = (x99)*((uintptr_t)(UINTMAX_C(4294967295))); + x118 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967295)))); + x119 = (x99)*((uintptr_t)(UINTMAX_C(4294967295))); + x120 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967295)))); + x121 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967295)))); + x122 = (x99)*((uintptr_t)(UINTMAX_C(4294967295))); + x123 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967295)))); + x124 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967295)))); + x125 = _br2_mulhuu((x99), ((uintptr_t)(UINTMAX_C(4294967295)))); + x126 = (x125)+((x99)*((uintptr_t)(UINTMAX_C(4294967295)))); + x127 = (uintptr_t)((x126)<(x125)); + x128 = (x123)+((x99)*((uintptr_t)(UINTMAX_C(4294967295)))); + x129 = ((uintptr_t)((x128)<(x123)))+(x121); + x130 = (x129)+(x119); + x131 = (((uintptr_t)((x129)<(x121)))+((uintptr_t)((x130)<(x119))))+(x120); + x132 = (x131)+(x117); + x133 = (((uintptr_t)((x131)<(x120)))+((uintptr_t)((x132)<(x117))))+(x118); + x134 = (x133)+(x115); + x135 = ((uintptr_t)((x133)<(x118)))+((uintptr_t)((x134)<(x115))); + x136 = ((uintptr_t)(((x99)+((x99)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x99)))+(x101); + x137 = (x136)+(x126); + x138 = (((uintptr_t)((x136)<(x101)))+((uintptr_t)((x137)<(x126))))+(x103); + x139 = (x138)+((x127)+(x124)); + x140 = (((uintptr_t)((x138)<(x103)))+((uintptr_t)((x139)<((x127)+(x124)))))+(x105); + x141 = (x140)+(x122); + x142 = (((uintptr_t)((x140)<(x105)))+((uintptr_t)((x141)<(x122))))+(x107); + x143 = (x142)+(x128); + x144 = (((uintptr_t)((x142)<(x107)))+((uintptr_t)((x143)<(x128))))+(x109); + x145 = (x144)+(x130); + x146 = (((uintptr_t)((x144)<(x109)))+((uintptr_t)((x145)<(x130))))+(x111); + x147 = (x146)+(x132); + x148 = (((uintptr_t)((x146)<(x111)))+((uintptr_t)((x147)<(x132))))+(x113); + x149 = (x148)+(x134); + x150 = (((uintptr_t)((x148)<(x113)))+((uintptr_t)((x149)<(x134))))+(((x114)+(x76))+((x98)+(x78))); + x151 = (x150)+((x135)+(x116)); + x152 = ((uintptr_t)((x150)<(((x114)+(x76))+((x98)+(x78)))))+((uintptr_t)((x151)<((x135)+(x116)))); + x153 = (x9)*((uintptr_t)(UINTMAX_C(4))); + x154 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(4)))); + x155 = (x9)*((uintptr_t)(UINTMAX_C(2))); + x156 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(2)))); + x157 = (x9)*((uintptr_t)(UINTMAX_C(2))); + x158 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(2)))); + x159 = (x9)*((uintptr_t)(UINTMAX_C(4294967295))); + x160 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(4294967295)))); + x161 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(2)))); + x162 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(3)))); + x163 = (x162)+((x9)*((uintptr_t)(UINTMAX_C(2)))); + x164 = ((uintptr_t)((x163)<(x162)))+(x161); + x165 = (x164)+(x159); + x166 = (((uintptr_t)((x164)<(x161)))+((uintptr_t)((x165)<(x159))))+(x160); + x167 = (x166)+(x157); + x168 = (((uintptr_t)((x166)<(x160)))+((uintptr_t)((x167)<(x157))))+(x158); + x169 = (x168)+(x9); + x170 = (((uintptr_t)((x168)<(x158)))+((uintptr_t)((x169)<(x9))))+(x9); + x171 = ((uintptr_t)((x170)<(x9)))+(x155); + x172 = ((uintptr_t)((x171)<(x155)))+(x156); + x173 = (x172)+(x153); + x174 = ((uintptr_t)((x172)<(x156)))+((uintptr_t)((x173)<(x153))); + x175 = (x137)+((x9)*((uintptr_t)(UINTMAX_C(3)))); + x176 = ((uintptr_t)((x175)<(x137)))+(x139); + x177 = (x176)+(x163); + x178 = (((uintptr_t)((x176)<(x139)))+((uintptr_t)((x177)<(x163))))+(x141); + x179 = (x178)+(x165); + x180 = (((uintptr_t)((x178)<(x141)))+((uintptr_t)((x179)<(x165))))+(x143); + x181 = (x180)+(x167); + x182 = (((uintptr_t)((x180)<(x143)))+((uintptr_t)((x181)<(x167))))+(x145); + x183 = (x182)+(x169); + x184 = (((uintptr_t)((x182)<(x145)))+((uintptr_t)((x183)<(x169))))+(x147); + x185 = (x184)+(x170); + x186 = (((uintptr_t)((x184)<(x147)))+((uintptr_t)((x185)<(x170))))+(x149); + x187 = (x186)+(x171); + x188 = (((uintptr_t)((x186)<(x149)))+((uintptr_t)((x187)<(x171))))+(x151); + x189 = (x188)+(x173); + x190 = ((uintptr_t)((x188)<(x151)))+((uintptr_t)((x189)<(x173))); + x191 = (x175)*((uintptr_t)(UINTMAX_C(4294967294))); + x192 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967294)))); + x193 = (x175)*((uintptr_t)(UINTMAX_C(4294967295))); + x194 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967295)))); + x195 = (x175)*((uintptr_t)(UINTMAX_C(4294967295))); + x196 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967295)))); + x197 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967295)))); + x198 = (x175)*((uintptr_t)(UINTMAX_C(4294967295))); + x199 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967295)))); + x200 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967295)))); + x201 = _br2_mulhuu((x175), ((uintptr_t)(UINTMAX_C(4294967295)))); + x202 = (x201)+((x175)*((uintptr_t)(UINTMAX_C(4294967295)))); + x203 = (uintptr_t)((x202)<(x201)); + x204 = (x199)+((x175)*((uintptr_t)(UINTMAX_C(4294967295)))); + x205 = ((uintptr_t)((x204)<(x199)))+(x197); + x206 = (x205)+(x195); + x207 = (((uintptr_t)((x205)<(x197)))+((uintptr_t)((x206)<(x195))))+(x196); + x208 = (x207)+(x193); + x209 = (((uintptr_t)((x207)<(x196)))+((uintptr_t)((x208)<(x193))))+(x194); + x210 = (x209)+(x191); + x211 = ((uintptr_t)((x209)<(x194)))+((uintptr_t)((x210)<(x191))); + x212 = ((uintptr_t)(((x175)+((x175)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x175)))+(x177); + x213 = (x212)+(x202); + x214 = (((uintptr_t)((x212)<(x177)))+((uintptr_t)((x213)<(x202))))+(x179); + x215 = (x214)+((x203)+(x200)); + x216 = (((uintptr_t)((x214)<(x179)))+((uintptr_t)((x215)<((x203)+(x200)))))+(x181); + x217 = (x216)+(x198); + x218 = (((uintptr_t)((x216)<(x181)))+((uintptr_t)((x217)<(x198))))+(x183); + x219 = (x218)+(x204); + x220 = (((uintptr_t)((x218)<(x183)))+((uintptr_t)((x219)<(x204))))+(x185); + x221 = (x220)+(x206); + x222 = (((uintptr_t)((x220)<(x185)))+((uintptr_t)((x221)<(x206))))+(x187); + x223 = (x222)+(x208); + x224 = (((uintptr_t)((x222)<(x187)))+((uintptr_t)((x223)<(x208))))+(x189); + x225 = (x224)+(x210); + x226 = (((uintptr_t)((x224)<(x189)))+((uintptr_t)((x225)<(x210))))+(((x190)+(x152))+((x174)+(x154))); + x227 = (x226)+((x211)+(x192)); + x228 = ((uintptr_t)((x226)<(((x190)+(x152))+((x174)+(x154)))))+((uintptr_t)((x227)<((x211)+(x192)))); + x229 = (x10)*((uintptr_t)(UINTMAX_C(4))); + x230 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(4)))); + x231 = (x10)*((uintptr_t)(UINTMAX_C(2))); + x232 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(2)))); + x233 = (x10)*((uintptr_t)(UINTMAX_C(2))); + x234 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(2)))); + x235 = (x10)*((uintptr_t)(UINTMAX_C(4294967295))); + x236 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(4294967295)))); + x237 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(2)))); + x238 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(3)))); + x239 = (x238)+((x10)*((uintptr_t)(UINTMAX_C(2)))); + x240 = ((uintptr_t)((x239)<(x238)))+(x237); + x241 = (x240)+(x235); + x242 = (((uintptr_t)((x240)<(x237)))+((uintptr_t)((x241)<(x235))))+(x236); + x243 = (x242)+(x233); + x244 = (((uintptr_t)((x242)<(x236)))+((uintptr_t)((x243)<(x233))))+(x234); + x245 = (x244)+(x10); + x246 = (((uintptr_t)((x244)<(x234)))+((uintptr_t)((x245)<(x10))))+(x10); + x247 = ((uintptr_t)((x246)<(x10)))+(x231); + x248 = ((uintptr_t)((x247)<(x231)))+(x232); + x249 = (x248)+(x229); + x250 = ((uintptr_t)((x248)<(x232)))+((uintptr_t)((x249)<(x229))); + x251 = (x213)+((x10)*((uintptr_t)(UINTMAX_C(3)))); + x252 = ((uintptr_t)((x251)<(x213)))+(x215); + x253 = (x252)+(x239); + x254 = (((uintptr_t)((x252)<(x215)))+((uintptr_t)((x253)<(x239))))+(x217); + x255 = (x254)+(x241); + x256 = (((uintptr_t)((x254)<(x217)))+((uintptr_t)((x255)<(x241))))+(x219); + x257 = (x256)+(x243); + x258 = (((uintptr_t)((x256)<(x219)))+((uintptr_t)((x257)<(x243))))+(x221); + x259 = (x258)+(x245); + x260 = (((uintptr_t)((x258)<(x221)))+((uintptr_t)((x259)<(x245))))+(x223); + x261 = (x260)+(x246); + x262 = (((uintptr_t)((x260)<(x223)))+((uintptr_t)((x261)<(x246))))+(x225); + x263 = (x262)+(x247); + x264 = (((uintptr_t)((x262)<(x225)))+((uintptr_t)((x263)<(x247))))+(x227); + x265 = (x264)+(x249); + x266 = ((uintptr_t)((x264)<(x227)))+((uintptr_t)((x265)<(x249))); + x267 = (x251)*((uintptr_t)(UINTMAX_C(4294967294))); + x268 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967294)))); + x269 = (x251)*((uintptr_t)(UINTMAX_C(4294967295))); + x270 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967295)))); + x271 = (x251)*((uintptr_t)(UINTMAX_C(4294967295))); + x272 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967295)))); + x273 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967295)))); + x274 = (x251)*((uintptr_t)(UINTMAX_C(4294967295))); + x275 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967295)))); + x276 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967295)))); + x277 = _br2_mulhuu((x251), ((uintptr_t)(UINTMAX_C(4294967295)))); + x278 = (x277)+((x251)*((uintptr_t)(UINTMAX_C(4294967295)))); + x279 = (uintptr_t)((x278)<(x277)); + x280 = (x275)+((x251)*((uintptr_t)(UINTMAX_C(4294967295)))); + x281 = ((uintptr_t)((x280)<(x275)))+(x273); + x282 = (x281)+(x271); + x283 = (((uintptr_t)((x281)<(x273)))+((uintptr_t)((x282)<(x271))))+(x272); + x284 = (x283)+(x269); + x285 = (((uintptr_t)((x283)<(x272)))+((uintptr_t)((x284)<(x269))))+(x270); + x286 = (x285)+(x267); + x287 = ((uintptr_t)((x285)<(x270)))+((uintptr_t)((x286)<(x267))); + x288 = ((uintptr_t)(((x251)+((x251)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x251)))+(x253); + x289 = (x288)+(x278); + x290 = (((uintptr_t)((x288)<(x253)))+((uintptr_t)((x289)<(x278))))+(x255); + x291 = (x290)+((x279)+(x276)); + x292 = (((uintptr_t)((x290)<(x255)))+((uintptr_t)((x291)<((x279)+(x276)))))+(x257); + x293 = (x292)+(x274); + x294 = (((uintptr_t)((x292)<(x257)))+((uintptr_t)((x293)<(x274))))+(x259); + x295 = (x294)+(x280); + x296 = (((uintptr_t)((x294)<(x259)))+((uintptr_t)((x295)<(x280))))+(x261); + x297 = (x296)+(x282); + x298 = (((uintptr_t)((x296)<(x261)))+((uintptr_t)((x297)<(x282))))+(x263); + x299 = (x298)+(x284); + x300 = (((uintptr_t)((x298)<(x263)))+((uintptr_t)((x299)<(x284))))+(x265); + x301 = (x300)+(x286); + x302 = (((uintptr_t)((x300)<(x265)))+((uintptr_t)((x301)<(x286))))+(((x266)+(x228))+((x250)+(x230))); + x303 = (x302)+((x287)+(x268)); + x304 = ((uintptr_t)((x302)<(((x266)+(x228))+((x250)+(x230)))))+((uintptr_t)((x303)<((x287)+(x268)))); + x305 = (x11)*((uintptr_t)(UINTMAX_C(4))); + x306 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(4)))); + x307 = (x11)*((uintptr_t)(UINTMAX_C(2))); + x308 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(2)))); + x309 = (x11)*((uintptr_t)(UINTMAX_C(2))); + x310 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(2)))); + x311 = (x11)*((uintptr_t)(UINTMAX_C(4294967295))); + x312 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(4294967295)))); + x313 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(2)))); + x314 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(3)))); + x315 = (x314)+((x11)*((uintptr_t)(UINTMAX_C(2)))); + x316 = ((uintptr_t)((x315)<(x314)))+(x313); + x317 = (x316)+(x311); + x318 = (((uintptr_t)((x316)<(x313)))+((uintptr_t)((x317)<(x311))))+(x312); + x319 = (x318)+(x309); + x320 = (((uintptr_t)((x318)<(x312)))+((uintptr_t)((x319)<(x309))))+(x310); + x321 = (x320)+(x11); + x322 = (((uintptr_t)((x320)<(x310)))+((uintptr_t)((x321)<(x11))))+(x11); + x323 = ((uintptr_t)((x322)<(x11)))+(x307); + x324 = ((uintptr_t)((x323)<(x307)))+(x308); + x325 = (x324)+(x305); + x326 = ((uintptr_t)((x324)<(x308)))+((uintptr_t)((x325)<(x305))); + x327 = (x289)+((x11)*((uintptr_t)(UINTMAX_C(3)))); + x328 = ((uintptr_t)((x327)<(x289)))+(x291); + x329 = (x328)+(x315); + x330 = (((uintptr_t)((x328)<(x291)))+((uintptr_t)((x329)<(x315))))+(x293); + x331 = (x330)+(x317); + x332 = (((uintptr_t)((x330)<(x293)))+((uintptr_t)((x331)<(x317))))+(x295); + x333 = (x332)+(x319); + x334 = (((uintptr_t)((x332)<(x295)))+((uintptr_t)((x333)<(x319))))+(x297); + x335 = (x334)+(x321); + x336 = (((uintptr_t)((x334)<(x297)))+((uintptr_t)((x335)<(x321))))+(x299); + x337 = (x336)+(x322); + x338 = (((uintptr_t)((x336)<(x299)))+((uintptr_t)((x337)<(x322))))+(x301); + x339 = (x338)+(x323); + x340 = (((uintptr_t)((x338)<(x301)))+((uintptr_t)((x339)<(x323))))+(x303); + x341 = (x340)+(x325); + x342 = ((uintptr_t)((x340)<(x303)))+((uintptr_t)((x341)<(x325))); + x343 = (x327)*((uintptr_t)(UINTMAX_C(4294967294))); + x344 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967294)))); + x345 = (x327)*((uintptr_t)(UINTMAX_C(4294967295))); + x346 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967295)))); + x347 = (x327)*((uintptr_t)(UINTMAX_C(4294967295))); + x348 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967295)))); + x349 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967295)))); + x350 = (x327)*((uintptr_t)(UINTMAX_C(4294967295))); + x351 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967295)))); + x352 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967295)))); + x353 = _br2_mulhuu((x327), ((uintptr_t)(UINTMAX_C(4294967295)))); + x354 = (x353)+((x327)*((uintptr_t)(UINTMAX_C(4294967295)))); + x355 = (uintptr_t)((x354)<(x353)); + x356 = (x351)+((x327)*((uintptr_t)(UINTMAX_C(4294967295)))); + x357 = ((uintptr_t)((x356)<(x351)))+(x349); + x358 = (x357)+(x347); + x359 = (((uintptr_t)((x357)<(x349)))+((uintptr_t)((x358)<(x347))))+(x348); + x360 = (x359)+(x345); + x361 = (((uintptr_t)((x359)<(x348)))+((uintptr_t)((x360)<(x345))))+(x346); + x362 = (x361)+(x343); + x363 = ((uintptr_t)((x361)<(x346)))+((uintptr_t)((x362)<(x343))); + x364 = ((uintptr_t)(((x327)+((x327)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x327)))+(x329); + x365 = (x364)+(x354); + x366 = (((uintptr_t)((x364)<(x329)))+((uintptr_t)((x365)<(x354))))+(x331); + x367 = (x366)+((x355)+(x352)); + x368 = (((uintptr_t)((x366)<(x331)))+((uintptr_t)((x367)<((x355)+(x352)))))+(x333); + x369 = (x368)+(x350); + x370 = (((uintptr_t)((x368)<(x333)))+((uintptr_t)((x369)<(x350))))+(x335); + x371 = (x370)+(x356); + x372 = (((uintptr_t)((x370)<(x335)))+((uintptr_t)((x371)<(x356))))+(x337); + x373 = (x372)+(x358); + x374 = (((uintptr_t)((x372)<(x337)))+((uintptr_t)((x373)<(x358))))+(x339); + x375 = (x374)+(x360); + x376 = (((uintptr_t)((x374)<(x339)))+((uintptr_t)((x375)<(x360))))+(x341); + x377 = (x376)+(x362); + x378 = (((uintptr_t)((x376)<(x341)))+((uintptr_t)((x377)<(x362))))+(((x342)+(x304))+((x326)+(x306))); + x379 = (x378)+((x363)+(x344)); + x380 = ((uintptr_t)((x378)<(((x342)+(x304))+((x326)+(x306)))))+((uintptr_t)((x379)<((x363)+(x344)))); + x381 = (x12)*((uintptr_t)(UINTMAX_C(4))); + x382 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(4)))); + x383 = (x12)*((uintptr_t)(UINTMAX_C(2))); + x384 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(2)))); + x385 = (x12)*((uintptr_t)(UINTMAX_C(2))); + x386 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(2)))); + x387 = (x12)*((uintptr_t)(UINTMAX_C(4294967295))); + x388 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(4294967295)))); + x389 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(2)))); + x390 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(3)))); + x391 = (x390)+((x12)*((uintptr_t)(UINTMAX_C(2)))); + x392 = ((uintptr_t)((x391)<(x390)))+(x389); + x393 = (x392)+(x387); + x394 = (((uintptr_t)((x392)<(x389)))+((uintptr_t)((x393)<(x387))))+(x388); + x395 = (x394)+(x385); + x396 = (((uintptr_t)((x394)<(x388)))+((uintptr_t)((x395)<(x385))))+(x386); + x397 = (x396)+(x12); + x398 = (((uintptr_t)((x396)<(x386)))+((uintptr_t)((x397)<(x12))))+(x12); + x399 = ((uintptr_t)((x398)<(x12)))+(x383); + x400 = ((uintptr_t)((x399)<(x383)))+(x384); + x401 = (x400)+(x381); + x402 = ((uintptr_t)((x400)<(x384)))+((uintptr_t)((x401)<(x381))); + x403 = (x365)+((x12)*((uintptr_t)(UINTMAX_C(3)))); + x404 = ((uintptr_t)((x403)<(x365)))+(x367); + x405 = (x404)+(x391); + x406 = (((uintptr_t)((x404)<(x367)))+((uintptr_t)((x405)<(x391))))+(x369); + x407 = (x406)+(x393); + x408 = (((uintptr_t)((x406)<(x369)))+((uintptr_t)((x407)<(x393))))+(x371); + x409 = (x408)+(x395); + x410 = (((uintptr_t)((x408)<(x371)))+((uintptr_t)((x409)<(x395))))+(x373); + x411 = (x410)+(x397); + x412 = (((uintptr_t)((x410)<(x373)))+((uintptr_t)((x411)<(x397))))+(x375); + x413 = (x412)+(x398); + x414 = (((uintptr_t)((x412)<(x375)))+((uintptr_t)((x413)<(x398))))+(x377); + x415 = (x414)+(x399); + x416 = (((uintptr_t)((x414)<(x377)))+((uintptr_t)((x415)<(x399))))+(x379); + x417 = (x416)+(x401); + x418 = ((uintptr_t)((x416)<(x379)))+((uintptr_t)((x417)<(x401))); + x419 = (x403)*((uintptr_t)(UINTMAX_C(4294967294))); + x420 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967294)))); + x421 = (x403)*((uintptr_t)(UINTMAX_C(4294967295))); + x422 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967295)))); + x423 = (x403)*((uintptr_t)(UINTMAX_C(4294967295))); + x424 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967295)))); + x425 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967295)))); + x426 = (x403)*((uintptr_t)(UINTMAX_C(4294967295))); + x427 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967295)))); + x428 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967295)))); + x429 = _br2_mulhuu((x403), ((uintptr_t)(UINTMAX_C(4294967295)))); + x430 = (x429)+((x403)*((uintptr_t)(UINTMAX_C(4294967295)))); + x431 = (uintptr_t)((x430)<(x429)); + x432 = (x427)+((x403)*((uintptr_t)(UINTMAX_C(4294967295)))); + x433 = ((uintptr_t)((x432)<(x427)))+(x425); + x434 = (x433)+(x423); + x435 = (((uintptr_t)((x433)<(x425)))+((uintptr_t)((x434)<(x423))))+(x424); + x436 = (x435)+(x421); + x437 = (((uintptr_t)((x435)<(x424)))+((uintptr_t)((x436)<(x421))))+(x422); + x438 = (x437)+(x419); + x439 = ((uintptr_t)((x437)<(x422)))+((uintptr_t)((x438)<(x419))); + x440 = ((uintptr_t)(((x403)+((x403)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x403)))+(x405); + x441 = (x440)+(x430); + x442 = (((uintptr_t)((x440)<(x405)))+((uintptr_t)((x441)<(x430))))+(x407); + x443 = (x442)+((x431)+(x428)); + x444 = (((uintptr_t)((x442)<(x407)))+((uintptr_t)((x443)<((x431)+(x428)))))+(x409); + x445 = (x444)+(x426); + x446 = (((uintptr_t)((x444)<(x409)))+((uintptr_t)((x445)<(x426))))+(x411); + x447 = (x446)+(x432); + x448 = (((uintptr_t)((x446)<(x411)))+((uintptr_t)((x447)<(x432))))+(x413); + x449 = (x448)+(x434); + x450 = (((uintptr_t)((x448)<(x413)))+((uintptr_t)((x449)<(x434))))+(x415); + x451 = (x450)+(x436); + x452 = (((uintptr_t)((x450)<(x415)))+((uintptr_t)((x451)<(x436))))+(x417); + x453 = (x452)+(x438); + x454 = (((uintptr_t)((x452)<(x417)))+((uintptr_t)((x453)<(x438))))+(((x418)+(x380))+((x402)+(x382))); + x455 = (x454)+((x439)+(x420)); + x456 = ((uintptr_t)((x454)<(((x418)+(x380))+((x402)+(x382)))))+((uintptr_t)((x455)<((x439)+(x420)))); + x457 = (x13)*((uintptr_t)(UINTMAX_C(4))); + x458 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(4)))); + x459 = (x13)*((uintptr_t)(UINTMAX_C(2))); + x460 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(2)))); + x461 = (x13)*((uintptr_t)(UINTMAX_C(2))); + x462 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(2)))); + x463 = (x13)*((uintptr_t)(UINTMAX_C(4294967295))); + x464 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(4294967295)))); + x465 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(2)))); + x466 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(3)))); + x467 = (x466)+((x13)*((uintptr_t)(UINTMAX_C(2)))); + x468 = ((uintptr_t)((x467)<(x466)))+(x465); + x469 = (x468)+(x463); + x470 = (((uintptr_t)((x468)<(x465)))+((uintptr_t)((x469)<(x463))))+(x464); + x471 = (x470)+(x461); + x472 = (((uintptr_t)((x470)<(x464)))+((uintptr_t)((x471)<(x461))))+(x462); + x473 = (x472)+(x13); + x474 = (((uintptr_t)((x472)<(x462)))+((uintptr_t)((x473)<(x13))))+(x13); + x475 = ((uintptr_t)((x474)<(x13)))+(x459); + x476 = ((uintptr_t)((x475)<(x459)))+(x460); + x477 = (x476)+(x457); + x478 = ((uintptr_t)((x476)<(x460)))+((uintptr_t)((x477)<(x457))); + x479 = (x441)+((x13)*((uintptr_t)(UINTMAX_C(3)))); + x480 = ((uintptr_t)((x479)<(x441)))+(x443); + x481 = (x480)+(x467); + x482 = (((uintptr_t)((x480)<(x443)))+((uintptr_t)((x481)<(x467))))+(x445); + x483 = (x482)+(x469); + x484 = (((uintptr_t)((x482)<(x445)))+((uintptr_t)((x483)<(x469))))+(x447); + x485 = (x484)+(x471); + x486 = (((uintptr_t)((x484)<(x447)))+((uintptr_t)((x485)<(x471))))+(x449); + x487 = (x486)+(x473); + x488 = (((uintptr_t)((x486)<(x449)))+((uintptr_t)((x487)<(x473))))+(x451); + x489 = (x488)+(x474); + x490 = (((uintptr_t)((x488)<(x451)))+((uintptr_t)((x489)<(x474))))+(x453); + x491 = (x490)+(x475); + x492 = (((uintptr_t)((x490)<(x453)))+((uintptr_t)((x491)<(x475))))+(x455); + x493 = (x492)+(x477); + x494 = ((uintptr_t)((x492)<(x455)))+((uintptr_t)((x493)<(x477))); + x495 = (x479)*((uintptr_t)(UINTMAX_C(4294967294))); + x496 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967294)))); + x497 = (x479)*((uintptr_t)(UINTMAX_C(4294967295))); + x498 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967295)))); + x499 = (x479)*((uintptr_t)(UINTMAX_C(4294967295))); + x500 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967295)))); + x501 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967295)))); + x502 = (x479)*((uintptr_t)(UINTMAX_C(4294967295))); + x503 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967295)))); + x504 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967295)))); + x505 = _br2_mulhuu((x479), ((uintptr_t)(UINTMAX_C(4294967295)))); + x506 = (x505)+((x479)*((uintptr_t)(UINTMAX_C(4294967295)))); + x507 = (uintptr_t)((x506)<(x505)); + x508 = (x503)+((x479)*((uintptr_t)(UINTMAX_C(4294967295)))); + x509 = ((uintptr_t)((x508)<(x503)))+(x501); + x510 = (x509)+(x499); + x511 = (((uintptr_t)((x509)<(x501)))+((uintptr_t)((x510)<(x499))))+(x500); + x512 = (x511)+(x497); + x513 = (((uintptr_t)((x511)<(x500)))+((uintptr_t)((x512)<(x497))))+(x498); + x514 = (x513)+(x495); + x515 = ((uintptr_t)((x513)<(x498)))+((uintptr_t)((x514)<(x495))); + x516 = ((uintptr_t)(((x479)+((x479)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x479)))+(x481); + x517 = (x516)+(x506); + x518 = (((uintptr_t)((x516)<(x481)))+((uintptr_t)((x517)<(x506))))+(x483); + x519 = (x518)+((x507)+(x504)); + x520 = (((uintptr_t)((x518)<(x483)))+((uintptr_t)((x519)<((x507)+(x504)))))+(x485); + x521 = (x520)+(x502); + x522 = (((uintptr_t)((x520)<(x485)))+((uintptr_t)((x521)<(x502))))+(x487); + x523 = (x522)+(x508); + x524 = (((uintptr_t)((x522)<(x487)))+((uintptr_t)((x523)<(x508))))+(x489); + x525 = (x524)+(x510); + x526 = (((uintptr_t)((x524)<(x489)))+((uintptr_t)((x525)<(x510))))+(x491); + x527 = (x526)+(x512); + x528 = (((uintptr_t)((x526)<(x491)))+((uintptr_t)((x527)<(x512))))+(x493); + x529 = (x528)+(x514); + x530 = (((uintptr_t)((x528)<(x493)))+((uintptr_t)((x529)<(x514))))+(((x494)+(x456))+((x478)+(x458))); + x531 = (x530)+((x515)+(x496)); + x532 = ((uintptr_t)((x530)<(((x494)+(x456))+((x478)+(x458)))))+((uintptr_t)((x531)<((x515)+(x496)))); + x533 = (x14)*((uintptr_t)(UINTMAX_C(4))); + x534 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(4)))); + x535 = (x14)*((uintptr_t)(UINTMAX_C(2))); + x536 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(2)))); + x537 = (x14)*((uintptr_t)(UINTMAX_C(2))); + x538 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(2)))); + x539 = (x14)*((uintptr_t)(UINTMAX_C(4294967295))); + x540 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(4294967295)))); + x541 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(2)))); + x542 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(3)))); + x543 = (x542)+((x14)*((uintptr_t)(UINTMAX_C(2)))); + x544 = ((uintptr_t)((x543)<(x542)))+(x541); + x545 = (x544)+(x539); + x546 = (((uintptr_t)((x544)<(x541)))+((uintptr_t)((x545)<(x539))))+(x540); + x547 = (x546)+(x537); + x548 = (((uintptr_t)((x546)<(x540)))+((uintptr_t)((x547)<(x537))))+(x538); + x549 = (x548)+(x14); + x550 = (((uintptr_t)((x548)<(x538)))+((uintptr_t)((x549)<(x14))))+(x14); + x551 = ((uintptr_t)((x550)<(x14)))+(x535); + x552 = ((uintptr_t)((x551)<(x535)))+(x536); + x553 = (x552)+(x533); + x554 = ((uintptr_t)((x552)<(x536)))+((uintptr_t)((x553)<(x533))); + x555 = (x517)+((x14)*((uintptr_t)(UINTMAX_C(3)))); + x556 = ((uintptr_t)((x555)<(x517)))+(x519); + x557 = (x556)+(x543); + x558 = (((uintptr_t)((x556)<(x519)))+((uintptr_t)((x557)<(x543))))+(x521); + x559 = (x558)+(x545); + x560 = (((uintptr_t)((x558)<(x521)))+((uintptr_t)((x559)<(x545))))+(x523); + x561 = (x560)+(x547); + x562 = (((uintptr_t)((x560)<(x523)))+((uintptr_t)((x561)<(x547))))+(x525); + x563 = (x562)+(x549); + x564 = (((uintptr_t)((x562)<(x525)))+((uintptr_t)((x563)<(x549))))+(x527); + x565 = (x564)+(x550); + x566 = (((uintptr_t)((x564)<(x527)))+((uintptr_t)((x565)<(x550))))+(x529); + x567 = (x566)+(x551); + x568 = (((uintptr_t)((x566)<(x529)))+((uintptr_t)((x567)<(x551))))+(x531); + x569 = (x568)+(x553); + x570 = ((uintptr_t)((x568)<(x531)))+((uintptr_t)((x569)<(x553))); + x571 = (x555)*((uintptr_t)(UINTMAX_C(4294967294))); + x572 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967294)))); + x573 = (x555)*((uintptr_t)(UINTMAX_C(4294967295))); + x574 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967295)))); + x575 = (x555)*((uintptr_t)(UINTMAX_C(4294967295))); + x576 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967295)))); + x577 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967295)))); + x578 = (x555)*((uintptr_t)(UINTMAX_C(4294967295))); + x579 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967295)))); + x580 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967295)))); + x581 = _br2_mulhuu((x555), ((uintptr_t)(UINTMAX_C(4294967295)))); + x582 = (x581)+((x555)*((uintptr_t)(UINTMAX_C(4294967295)))); + x583 = (uintptr_t)((x582)<(x581)); + x584 = (x579)+((x555)*((uintptr_t)(UINTMAX_C(4294967295)))); + x585 = ((uintptr_t)((x584)<(x579)))+(x577); + x586 = (x585)+(x575); + x587 = (((uintptr_t)((x585)<(x577)))+((uintptr_t)((x586)<(x575))))+(x576); + x588 = (x587)+(x573); + x589 = (((uintptr_t)((x587)<(x576)))+((uintptr_t)((x588)<(x573))))+(x574); + x590 = (x589)+(x571); + x591 = ((uintptr_t)((x589)<(x574)))+((uintptr_t)((x590)<(x571))); + x592 = ((uintptr_t)(((x555)+((x555)*((uintptr_t)(UINTMAX_C(4294967295)))))<(x555)))+(x557); + x593 = (x592)+(x582); + x594 = (((uintptr_t)((x592)<(x557)))+((uintptr_t)((x593)<(x582))))+(x559); + x595 = (x594)+((x583)+(x580)); + x596 = (((uintptr_t)((x594)<(x559)))+((uintptr_t)((x595)<((x583)+(x580)))))+(x561); + x597 = (x596)+(x578); + x598 = (((uintptr_t)((x596)<(x561)))+((uintptr_t)((x597)<(x578))))+(x563); + x599 = (x598)+(x584); + x600 = (((uintptr_t)((x598)<(x563)))+((uintptr_t)((x599)<(x584))))+(x565); + x601 = (x600)+(x586); + x602 = (((uintptr_t)((x600)<(x565)))+((uintptr_t)((x601)<(x586))))+(x567); + x603 = (x602)+(x588); + x604 = (((uintptr_t)((x602)<(x567)))+((uintptr_t)((x603)<(x588))))+(x569); + x605 = (x604)+(x590); + x606 = (((uintptr_t)((x604)<(x569)))+((uintptr_t)((x605)<(x590))))+(((x570)+(x532))+((x554)+(x534))); + x607 = (x606)+((x591)+(x572)); + x608 = ((uintptr_t)((x606)<(((x570)+(x532))+((x554)+(x534)))))+((uintptr_t)((x607)<((x591)+(x572)))); + x609 = (x593)-((uintptr_t)(UINTMAX_C(4294967295))); + x610 = (x595)-((uintptr_t)(UINTMAX_C(4294967295))); + x611 = (x610)-((uintptr_t)((x593)<(x609))); + x612 = (x597)-(((uintptr_t)((x595)<(x610)))+((uintptr_t)((x610)<(x611)))); + x613 = (x599)-((uintptr_t)(UINTMAX_C(4294967295))); + x614 = (x613)-((uintptr_t)((x597)<(x612))); + x615 = (x601)-((uintptr_t)(UINTMAX_C(4294967295))); + x616 = (x615)-(((uintptr_t)((x599)<(x613)))+((uintptr_t)((x613)<(x614)))); + x617 = (x603)-((uintptr_t)(UINTMAX_C(4294967295))); + x618 = (x617)-(((uintptr_t)((x601)<(x615)))+((uintptr_t)((x615)<(x616)))); + x619 = (x605)-((uintptr_t)(UINTMAX_C(4294967295))); + x620 = (x619)-(((uintptr_t)((x603)<(x617)))+((uintptr_t)((x617)<(x618)))); + x621 = (x607)-((uintptr_t)(UINTMAX_C(4294967294))); + x622 = (x621)-(((uintptr_t)((x605)<(x619)))+((uintptr_t)((x619)<(x620)))); + x623 = (uintptr_t)((x608)<((x608)-(((uintptr_t)((x607)<(x621)))+((uintptr_t)((x621)<(x622)))))); + x624 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x625 = (x624)^((uintptr_t)(UINTMAX_C(4294967295))); + x626 = ((x593)&(x624))|((x609)&(x625)); + x627 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x628 = (x627)^((uintptr_t)(UINTMAX_C(4294967295))); + x629 = ((x595)&(x627))|((x611)&(x628)); + x630 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x631 = (x630)^((uintptr_t)(UINTMAX_C(4294967295))); + x632 = ((x597)&(x630))|((x612)&(x631)); + x633 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x634 = (x633)^((uintptr_t)(UINTMAX_C(4294967295))); + x635 = ((x599)&(x633))|((x614)&(x634)); + x636 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x637 = (x636)^((uintptr_t)(UINTMAX_C(4294967295))); + x638 = ((x601)&(x636))|((x616)&(x637)); + x639 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x640 = (x639)^((uintptr_t)(UINTMAX_C(4294967295))); + x641 = ((x603)&(x639))|((x618)&(x640)); + x642 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x643 = (x642)^((uintptr_t)(UINTMAX_C(4294967295))); + x644 = ((x605)&(x642))|((x620)&(x643)); + x645 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x623)==((uintptr_t)(UINTMAX_C(0))))); + x646 = (x645)^((uintptr_t)(UINTMAX_C(4294967295))); + x647 = ((x607)&(x645))|((x622)&(x646)); + x648 = x626; + x649 = x629; + x650 = x632; + x651 = x635; + x652 = x638; + x653 = x641; + x654 = x644; + x655 = x647; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x648, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x649, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x650, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x651, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x652, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x653, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x654, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x655, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_to_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, out0, x9; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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_sm2_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + *out1 = (uint32_t)internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x17 = (x16)^((uintptr_t)(UINTMAX_C(4294967295))); + x18 = ((x8)&(x16))|((x0)&(x17)); + x19 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x20 = (x19)^((uintptr_t)(UINTMAX_C(4294967295))); + x21 = ((x9)&(x19))|((x1)&(x20)); + x22 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x23 = (x22)^((uintptr_t)(UINTMAX_C(4294967295))); + x24 = ((x10)&(x22))|((x2)&(x23)); + x25 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x26 = (x25)^((uintptr_t)(UINTMAX_C(4294967295))); + x27 = ((x11)&(x25))|((x3)&(x26)); + x28 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x29 = (x28)^((uintptr_t)(UINTMAX_C(4294967295))); + x30 = ((x12)&(x28))|((x4)&(x29)); + x31 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x32 = (x31)^((uintptr_t)(UINTMAX_C(4294967295))); + x33 = ((x13)&(x31))|((x5)&(x32)); + x34 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x35 = (x34)^((uintptr_t)(UINTMAX_C(4294967295))); + x36 = ((x14)&(x34))|((x6)&(x35)); + x37 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x38 = (x37)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x47, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_selectznz(uint32_t out1[8], uint8_t arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(255))); + x17 = (x15)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x18 = (x17)&((uintptr_t)(UINTMAX_C(255))); + x19 = (x17)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x20 = (x19)&((uintptr_t)(UINTMAX_C(255))); + x21 = (x19)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x22 = (x14)&((uintptr_t)(UINTMAX_C(255))); + x23 = (x14)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x24 = (x23)&((uintptr_t)(UINTMAX_C(255))); + x25 = (x23)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x26 = (x25)&((uintptr_t)(UINTMAX_C(255))); + x27 = (x25)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x28 = (x13)&((uintptr_t)(UINTMAX_C(255))); + x29 = (x13)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x30 = (x29)&((uintptr_t)(UINTMAX_C(255))); + x31 = (x29)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x32 = (x31)&((uintptr_t)(UINTMAX_C(255))); + x33 = (x31)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x34 = (x12)&((uintptr_t)(UINTMAX_C(255))); + x35 = (x12)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x36 = (x35)&((uintptr_t)(UINTMAX_C(255))); + x37 = (x35)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x38 = (x37)&((uintptr_t)(UINTMAX_C(255))); + x39 = (x37)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x40 = (x11)&((uintptr_t)(UINTMAX_C(255))); + x41 = (x11)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x42 = (x41)&((uintptr_t)(UINTMAX_C(255))); + x43 = (x41)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x44 = (x43)&((uintptr_t)(UINTMAX_C(255))); + x45 = (x43)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x46 = (x10)&((uintptr_t)(UINTMAX_C(255))); + x47 = (x10)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x48 = (x47)&((uintptr_t)(UINTMAX_C(255))); + x49 = (x47)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x50 = (x49)&((uintptr_t)(UINTMAX_C(255))); + x51 = (x49)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x52 = (x9)&((uintptr_t)(UINTMAX_C(255))); + x53 = (x9)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x54 = (x53)&((uintptr_t)(UINTMAX_C(255))); + x55 = (x53)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x56 = (x55)&((uintptr_t)(UINTMAX_C(255))); + x57 = (x55)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x58 = (x8)&((uintptr_t)(UINTMAX_C(255))); + x59 = (x8)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x60 = (x59)&((uintptr_t)(UINTMAX_C(255))); + x61 = (x59)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x62 = (x61)&((uintptr_t)(UINTMAX_C(255))); + x63 = (x61)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x64, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(1))), x65, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(2))), x66, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(3))), x67, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x68, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(5))), x69, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(6))), x70, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(7))), x71, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x72, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(9))), x73, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(10))), x74, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(11))), x75, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x76, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(13))), x77, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(14))), x78, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(15))), x79, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x80, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(17))), x81, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(18))), x82, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(19))), x83, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x84, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(21))), x85, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(22))), x86, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(23))), x87, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x88, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(25))), x89, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(26))), x90, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(27))), x91, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x92, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(29))), x93, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(30))), x94, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(31))), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), 1); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(1))), 1); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(2))), 1); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(3))), 1); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), 1); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(5))), 1); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(6))), 1); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(7))), 1); + x8 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), 1); + x9 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(9))), 1); + x10 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(10))), 1); + x11 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(11))), 1); + x12 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), 1); + x13 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(13))), 1); + x14 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(14))), 1); + x15 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(15))), 1); + x16 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), 1); + x17 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(17))), 1); + x18 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(18))), 1); + x19 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(19))), 1); + x20 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), 1); + x21 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(21))), 1); + x22 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(22))), 1); + x23 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(23))), 1); + x24 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), 1); + x25 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(25))), 1); + x26 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(26))), 1); + x27 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(27))), 1); + x28 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 1); + x29 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(29))), 1); + x30 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(30))), 1); + x31 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(31))), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x33 = (x30)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x34 = (x29)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x35 = x28; + x36 = (x27)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x37 = (x26)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x38 = (x25)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x39 = x24; + x40 = (x23)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x41 = (x22)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x42 = (x21)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x43 = x20; + x44 = (x19)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x45 = (x18)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x46 = (x17)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x47 = x16; + x48 = (x15)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x49 = (x14)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x50 = (x13)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x51 = x12; + x52 = (x11)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x53 = (x10)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x54 = (x9)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x55 = x8; + x56 = (x7)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x57 = (x6)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x58 = (x5)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x59 = x4; + x60 = (x3)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x61 = (x2)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x62 = (x1)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x88, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x89, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x90, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x91, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + internal_fiat_sm2_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_sm2_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(1)); + x1 = (uintptr_t)(UINTMAX_C(0)); + x2 = (uintptr_t)(UINTMAX_C(4294967295)); + x3 = (uintptr_t)(UINTMAX_C(0)); + x4 = (uintptr_t)(UINTMAX_C(0)); + x5 = (uintptr_t)(UINTMAX_C(0)); + x6 = (uintptr_t)(UINTMAX_C(0)); + x7 = (uintptr_t)(UINTMAX_C(1)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_set_one(uint32_t out1[8]) { + internal_fiat_sm2_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_sm2_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(4294967295)); + x1 = (uintptr_t)(UINTMAX_C(4294967295)); + x2 = (uintptr_t)(UINTMAX_C(0)); + x3 = (uintptr_t)(UINTMAX_C(4294967295)); + x4 = (uintptr_t)(UINTMAX_C(4294967295)); + x5 = (uintptr_t)(UINTMAX_C(4294967295)); + x6 = (uintptr_t)(UINTMAX_C(4294967295)); + x7 = (uintptr_t)(UINTMAX_C(4294967294)); + x8 = (uintptr_t)(UINTMAX_C(0)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(32))), x8, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_msat(uint32_t out1[9]) { + internal_fiat_sm2_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_sm2_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, x180, x181, x182, x184, x185, x186, x187, x189, x190, x191, x192, x194, x195, x196, x197, x199, 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, x254, x226, x255, x256, x258, x259, x230, x260, x261, x263, x264, x234, x265, x266, x268, x269, x238, x270, x271, x273, x274, x242, x275, x245, x246, x277, x26, x278, x250, x280, x27, x281, x253, x283, x28, x284, x257, x286, x29, x287, x262, x289, x30, x290, x267, x292, x31, x293, x272, 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, x437, x438, x439, x441, x442, x443, x444, x446, x447, x448, x449, x451, x452, x453, x454, x456, 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, x179, x482, x149, x484, x183, x485, x154, x487, x188, x488, x159, x490, x193, x491, x164, x493, x198, x494, x207, x169, x496, x203, x497, x392, x499, x429, x500, x396, x502, x433, x503, x401, x505, x436, x506, x406, x508, x440, x509, x411, x511, x445, x512, x416, x514, x450, x515, x421, x517, x455, 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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x9 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x18 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x19 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x20 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x21 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x22 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x23 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x24 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x25 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x26 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x27 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x28 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x29 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x30 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x31 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x32 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x33 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x34 = ((in0)^((uintptr_t)(UINTMAX_C(4294967295))))+((uintptr_t)(UINTMAX_C(1))); + x35 = ((x34)>>_br2_shamt((uintptr_t)(UINTMAX_C(31))))&((x9)&((uintptr_t)(UINTMAX_C(1)))); + x36 = ((in0)^((uintptr_t)(UINTMAX_C(4294967295))))+((uintptr_t)(UINTMAX_C(1))); + x37 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x38 = (x37)^((uintptr_t)(UINTMAX_C(4294967295))); + x39 = ((x36)&(x37))|((in0)&(x38)); + x40 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x41 = (x40)^((uintptr_t)(UINTMAX_C(4294967295))); + x42 = ((x9)&(x40))|((x0)&(x41)); + x43 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x44 = (x43)^((uintptr_t)(UINTMAX_C(4294967295))); + x45 = ((x10)&(x43))|((x1)&(x44)); + x46 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x47 = (x46)^((uintptr_t)(UINTMAX_C(4294967295))); + x48 = ((x11)&(x46))|((x2)&(x47)); + x49 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x50 = (x49)^((uintptr_t)(UINTMAX_C(4294967295))); + x51 = ((x12)&(x49))|((x3)&(x50)); + x52 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x53 = (x52)^((uintptr_t)(UINTMAX_C(4294967295))); + x54 = ((x13)&(x52))|((x4)&(x53)); + x55 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x56 = (x55)^((uintptr_t)(UINTMAX_C(4294967295))); + x57 = ((x14)&(x55))|((x5)&(x56)); + x58 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x59 = (x58)^((uintptr_t)(UINTMAX_C(4294967295))); + x60 = ((x15)&(x58))|((x6)&(x59)); + x61 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x62 = (x61)^((uintptr_t)(UINTMAX_C(4294967295))); + x63 = ((x16)&(x61))|((x7)&(x62)); + x64 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x65 = (x64)^((uintptr_t)(UINTMAX_C(4294967295))); + x66 = ((x17)&(x64))|((x8)&(x65)); + x67 = ((uintptr_t)(UINTMAX_C(1)))+((x0)^((uintptr_t)(UINTMAX_C(4294967295)))); + x68 = (uintptr_t)((x67)<((uintptr_t)(UINTMAX_C(1)))); + x69 = (x68)+((x1)^((uintptr_t)(UINTMAX_C(4294967295)))); + x70 = (uintptr_t)((x69)<((x1)^((uintptr_t)(UINTMAX_C(4294967295))))); + x71 = (x70)+((x2)^((uintptr_t)(UINTMAX_C(4294967295)))); + x72 = (uintptr_t)((x71)<((x2)^((uintptr_t)(UINTMAX_C(4294967295))))); + x73 = (x72)+((x3)^((uintptr_t)(UINTMAX_C(4294967295)))); + x74 = (uintptr_t)((x73)<((x3)^((uintptr_t)(UINTMAX_C(4294967295))))); + x75 = (x74)+((x4)^((uintptr_t)(UINTMAX_C(4294967295)))); + x76 = (uintptr_t)((x75)<((x4)^((uintptr_t)(UINTMAX_C(4294967295))))); + x77 = (x76)+((x5)^((uintptr_t)(UINTMAX_C(4294967295)))); + x78 = (uintptr_t)((x77)<((x5)^((uintptr_t)(UINTMAX_C(4294967295))))); + x79 = (x78)+((x6)^((uintptr_t)(UINTMAX_C(4294967295)))); + x80 = (uintptr_t)((x79)<((x6)^((uintptr_t)(UINTMAX_C(4294967295))))); + x81 = (x80)+((x7)^((uintptr_t)(UINTMAX_C(4294967295)))); + x82 = (uintptr_t)((x81)<((x7)^((uintptr_t)(UINTMAX_C(4294967295))))); + x83 = (x82)+((x8)^((uintptr_t)(UINTMAX_C(4294967295)))); + x84 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x85 = (x84)^((uintptr_t)(UINTMAX_C(4294967295))); + x86 = ((x67)&(x84))|((x9)&(x85)); + x87 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x88 = (x87)^((uintptr_t)(UINTMAX_C(4294967295))); + x89 = ((x69)&(x87))|((x10)&(x88)); + x90 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x91 = (x90)^((uintptr_t)(UINTMAX_C(4294967295))); + x92 = ((x71)&(x90))|((x11)&(x91)); + x93 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x94 = (x93)^((uintptr_t)(UINTMAX_C(4294967295))); + x95 = ((x73)&(x93))|((x12)&(x94)); + x96 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x97 = (x96)^((uintptr_t)(UINTMAX_C(4294967295))); + x98 = ((x75)&(x96))|((x13)&(x97)); + x99 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x100 = (x99)^((uintptr_t)(UINTMAX_C(4294967295))); + x101 = ((x77)&(x99))|((x14)&(x100)); + x102 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x103 = (x102)^((uintptr_t)(UINTMAX_C(4294967295))); + x104 = ((x79)&(x102))|((x15)&(x103)); + x105 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x106 = (x105)^((uintptr_t)(UINTMAX_C(4294967295))); + x107 = ((x81)&(x105))|((x16)&(x106)); + x108 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x109 = (x108)^((uintptr_t)(UINTMAX_C(4294967295))); + x110 = ((x83)&(x108))|((x17)&(x109)); + x111 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x112 = (x111)^((uintptr_t)(UINTMAX_C(4294967295))); + x113 = ((x26)&(x111))|((x18)&(x112)); + x114 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x115 = (x114)^((uintptr_t)(UINTMAX_C(4294967295))); + x116 = ((x27)&(x114))|((x19)&(x115)); + x117 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x118 = (x117)^((uintptr_t)(UINTMAX_C(4294967295))); + x119 = ((x28)&(x117))|((x20)&(x118)); + x120 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x121 = (x120)^((uintptr_t)(UINTMAX_C(4294967295))); + x122 = ((x29)&(x120))|((x21)&(x121)); + x123 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x124 = (x123)^((uintptr_t)(UINTMAX_C(4294967295))); + x125 = ((x30)&(x123))|((x22)&(x124)); + x126 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x127 = (x126)^((uintptr_t)(UINTMAX_C(4294967295))); + x128 = ((x31)&(x126))|((x23)&(x127)); + x129 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x130 = (x129)^((uintptr_t)(UINTMAX_C(4294967295))); + x131 = ((x32)&(x129))|((x24)&(x130)); + x132 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x133 = (x132)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(4294967295))); + x173 = (uintptr_t)((x135)<(x172)); + x174 = (x139)-((uintptr_t)(UINTMAX_C(4294967295))); + x175 = (uintptr_t)((x139)<(x174)); + x176 = (x174)-(x173); + x177 = (uintptr_t)((x174)<(x176)); + x178 = (x175)+(x177); + x179 = (x144)-(x178); + x180 = (uintptr_t)((x144)<(x179)); + x181 = (x149)-((uintptr_t)(UINTMAX_C(4294967295))); + x182 = (uintptr_t)((x149)<(x181)); + x183 = (x181)-(x180); + x184 = (uintptr_t)((x181)<(x183)); + x185 = (x182)+(x184); + x186 = (x154)-((uintptr_t)(UINTMAX_C(4294967295))); + x187 = (uintptr_t)((x154)<(x186)); + x188 = (x186)-(x185); + x189 = (uintptr_t)((x186)<(x188)); + x190 = (x187)+(x189); + x191 = (x159)-((uintptr_t)(UINTMAX_C(4294967295))); + x192 = (uintptr_t)((x159)<(x191)); + x193 = (x191)-(x190); + x194 = (uintptr_t)((x191)<(x193)); + x195 = (x192)+(x194); + x196 = (x164)-((uintptr_t)(UINTMAX_C(4294967295))); + x197 = (uintptr_t)((x164)<(x196)); + x198 = (x196)-(x195); + x199 = (uintptr_t)((x196)<(x198)); + x200 = (x197)+(x199); + x201 = (x169)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x215))); + x217 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x214))); + x218 = (((uintptr_t)(UINTMAX_C(0)))-(x214))-(x216); + x219 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x214))<(x218)); + x220 = (x217)+(x219); + x221 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x213))); + x222 = (((uintptr_t)(UINTMAX_C(0)))-(x213))-(x220); + x223 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x213))<(x222)); + x224 = (x221)+(x223); + x225 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x212))); + x226 = (((uintptr_t)(UINTMAX_C(0)))-(x212))-(x224); + x227 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x212))<(x226)); + x228 = (x225)+(x227); + x229 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x211))); + x230 = (((uintptr_t)(UINTMAX_C(0)))-(x211))-(x228); + x231 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x211))<(x230)); + x232 = (x229)+(x231); + x233 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x210))); + x234 = (((uintptr_t)(UINTMAX_C(0)))-(x210))-(x232); + x235 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x210))<(x234)); + x236 = (x233)+(x235); + x237 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x209))); + x238 = (((uintptr_t)(UINTMAX_C(0)))-(x209))-(x236); + x239 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x209))<(x238)); + x240 = (x237)+(x239); + x241 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x208))); + x242 = (((uintptr_t)(UINTMAX_C(0)))-(x208))-(x240); + x243 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x208))<(x242)); + x244 = (x241)+(x243); + x245 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x244)==((uintptr_t)(UINTMAX_C(0))))); + x246 = (((uintptr_t)(UINTMAX_C(0)))-(x215))+(x245); + x247 = (uintptr_t)((x246)<(((uintptr_t)(UINTMAX_C(0)))-(x215))); + x248 = (x247)+(x218); + x249 = (uintptr_t)((x248)<(x218)); + x250 = (x248)+(x245); + x251 = (uintptr_t)((x250)<(x245)); + x252 = (x249)+(x251); + x253 = (x252)+(x222); + x254 = (uintptr_t)((x253)<(x222)); + x255 = (x254)+(x226); + x256 = (uintptr_t)((x255)<(x226)); + x257 = (x255)+(x245); + x258 = (uintptr_t)((x257)<(x245)); + x259 = (x256)+(x258); + x260 = (x259)+(x230); + x261 = (uintptr_t)((x260)<(x230)); + x262 = (x260)+(x245); + x263 = (uintptr_t)((x262)<(x245)); + x264 = (x261)+(x263); + x265 = (x264)+(x234); + x266 = (uintptr_t)((x265)<(x234)); + x267 = (x265)+(x245); + x268 = (uintptr_t)((x267)<(x245)); + x269 = (x266)+(x268); + x270 = (x269)+(x238); + x271 = (uintptr_t)((x270)<(x238)); + x272 = (x270)+(x245); + x273 = (uintptr_t)((x272)<(x245)); + x274 = (x271)+(x273); + x275 = (x274)+(x242); + x276 = (x275)+((x245)&((uintptr_t)(UINTMAX_C(4294967294)))); + x277 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x278 = (x277)^((uintptr_t)(UINTMAX_C(4294967295))); + x279 = ((x246)&(x277))|((x26)&(x278)); + x280 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x281 = (x280)^((uintptr_t)(UINTMAX_C(4294967295))); + x282 = ((x250)&(x280))|((x27)&(x281)); + x283 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x284 = (x283)^((uintptr_t)(UINTMAX_C(4294967295))); + x285 = ((x253)&(x283))|((x28)&(x284)); + x286 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x287 = (x286)^((uintptr_t)(UINTMAX_C(4294967295))); + x288 = ((x257)&(x286))|((x29)&(x287)); + x289 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x290 = (x289)^((uintptr_t)(UINTMAX_C(4294967295))); + x291 = ((x262)&(x289))|((x30)&(x290)); + x292 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x293 = (x292)^((uintptr_t)(UINTMAX_C(4294967295))); + x294 = ((x267)&(x292))|((x31)&(x293)); + x295 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x296 = (x295)^((uintptr_t)(UINTMAX_C(4294967295))); + x297 = ((x272)&(x295))|((x32)&(x296)); + x298 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x299 = (x298)^((uintptr_t)(UINTMAX_C(4294967295))); + x300 = ((x276)&(x298))|((x33)&(x299)); + x301 = (x86)&((uintptr_t)(UINTMAX_C(1))); + x302 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x303 = (x302)^((uintptr_t)(UINTMAX_C(4294967295))); + x304 = ((x42)&(x302))|(((uintptr_t)(UINTMAX_C(0)))&(x303)); + x305 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x306 = (x305)^((uintptr_t)(UINTMAX_C(4294967295))); + x307 = ((x45)&(x305))|(((uintptr_t)(UINTMAX_C(0)))&(x306)); + x308 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x309 = (x308)^((uintptr_t)(UINTMAX_C(4294967295))); + x310 = ((x48)&(x308))|(((uintptr_t)(UINTMAX_C(0)))&(x309)); + x311 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x312 = (x311)^((uintptr_t)(UINTMAX_C(4294967295))); + x313 = ((x51)&(x311))|(((uintptr_t)(UINTMAX_C(0)))&(x312)); + x314 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x315 = (x314)^((uintptr_t)(UINTMAX_C(4294967295))); + x316 = ((x54)&(x314))|(((uintptr_t)(UINTMAX_C(0)))&(x315)); + x317 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x318 = (x317)^((uintptr_t)(UINTMAX_C(4294967295))); + x319 = ((x57)&(x317))|(((uintptr_t)(UINTMAX_C(0)))&(x318)); + x320 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x321 = (x320)^((uintptr_t)(UINTMAX_C(4294967295))); + x322 = ((x60)&(x320))|(((uintptr_t)(UINTMAX_C(0)))&(x321)); + x323 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x324 = (x323)^((uintptr_t)(UINTMAX_C(4294967295))); + x325 = ((x63)&(x323))|(((uintptr_t)(UINTMAX_C(0)))&(x324)); + x326 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x327 = (x326)^((uintptr_t)(UINTMAX_C(4294967295))); + x328 = ((x66)&(x326))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x369 = (x368)^((uintptr_t)(UINTMAX_C(4294967295))); + x370 = ((x113)&(x368))|(((uintptr_t)(UINTMAX_C(0)))&(x369)); + x371 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x372 = (x371)^((uintptr_t)(UINTMAX_C(4294967295))); + x373 = ((x116)&(x371))|(((uintptr_t)(UINTMAX_C(0)))&(x372)); + x374 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x375 = (x374)^((uintptr_t)(UINTMAX_C(4294967295))); + x376 = ((x119)&(x374))|(((uintptr_t)(UINTMAX_C(0)))&(x375)); + x377 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x378 = (x377)^((uintptr_t)(UINTMAX_C(4294967295))); + x379 = ((x122)&(x377))|(((uintptr_t)(UINTMAX_C(0)))&(x378)); + x380 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x381 = (x380)^((uintptr_t)(UINTMAX_C(4294967295))); + x382 = ((x125)&(x380))|(((uintptr_t)(UINTMAX_C(0)))&(x381)); + x383 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x384 = (x383)^((uintptr_t)(UINTMAX_C(4294967295))); + x385 = ((x128)&(x383))|(((uintptr_t)(UINTMAX_C(0)))&(x384)); + x386 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x387 = (x386)^((uintptr_t)(UINTMAX_C(4294967295))); + x388 = ((x131)&(x386))|(((uintptr_t)(UINTMAX_C(0)))&(x387)); + x389 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x301)==((uintptr_t)(UINTMAX_C(0))))); + x390 = (x389)^((uintptr_t)(UINTMAX_C(4294967295))); + x391 = ((x134)&(x389))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(4294967295))); + x430 = (uintptr_t)((x392)<(x429)); + x431 = (x396)-((uintptr_t)(UINTMAX_C(4294967295))); + x432 = (uintptr_t)((x396)<(x431)); + x433 = (x431)-(x430); + x434 = (uintptr_t)((x431)<(x433)); + x435 = (x432)+(x434); + x436 = (x401)-(x435); + x437 = (uintptr_t)((x401)<(x436)); + x438 = (x406)-((uintptr_t)(UINTMAX_C(4294967295))); + x439 = (uintptr_t)((x406)<(x438)); + x440 = (x438)-(x437); + x441 = (uintptr_t)((x438)<(x440)); + x442 = (x439)+(x441); + x443 = (x411)-((uintptr_t)(UINTMAX_C(4294967295))); + x444 = (uintptr_t)((x411)<(x443)); + x445 = (x443)-(x442); + x446 = (uintptr_t)((x443)<(x445)); + x447 = (x444)+(x446); + x448 = (x416)-((uintptr_t)(UINTMAX_C(4294967295))); + x449 = (uintptr_t)((x416)<(x448)); + x450 = (x448)-(x447); + x451 = (uintptr_t)((x448)<(x450)); + x452 = (x449)+(x451); + x453 = (x421)-((uintptr_t)(UINTMAX_C(4294967295))); + x454 = (uintptr_t)((x421)<(x453)); + x455 = (x453)-(x452); + x456 = (uintptr_t)((x453)<(x455)); + x457 = (x454)+(x456); + x458 = (x426)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(1))); + x466 = ((x329)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x333)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x467 = ((x333)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x338)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x468 = ((x338)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x343)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x469 = ((x343)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x348)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x470 = ((x348)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x353)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x471 = ((x353)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x358)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x472 = ((x358)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x363)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x473 = ((x363)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x367)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x474 = ((x367)&((uintptr_t)(UINTMAX_C(2147483648))))|((x367)>>_br2_shamt((uintptr_t)(UINTMAX_C(1)))); + x475 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x476 = (x475)^((uintptr_t)(UINTMAX_C(4294967295))); + x477 = ((x135)&(x475))|((x172)&(x476)); + x478 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x479 = (x478)^((uintptr_t)(UINTMAX_C(4294967295))); + x480 = ((x139)&(x478))|((x176)&(x479)); + x481 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x482 = (x481)^((uintptr_t)(UINTMAX_C(4294967295))); + x483 = ((x144)&(x481))|((x179)&(x482)); + x484 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x485 = (x484)^((uintptr_t)(UINTMAX_C(4294967295))); + x486 = ((x149)&(x484))|((x183)&(x485)); + x487 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x488 = (x487)^((uintptr_t)(UINTMAX_C(4294967295))); + x489 = ((x154)&(x487))|((x188)&(x488)); + x490 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x491 = (x490)^((uintptr_t)(UINTMAX_C(4294967295))); + x492 = ((x159)&(x490))|((x193)&(x491)); + x493 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x494 = (x493)^((uintptr_t)(UINTMAX_C(4294967295))); + x495 = ((x164)&(x493))|((x198)&(x494)); + x496 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x207)==((uintptr_t)(UINTMAX_C(0))))); + x497 = (x496)^((uintptr_t)(UINTMAX_C(4294967295))); + x498 = ((x169)&(x496))|((x203)&(x497)); + x499 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x500 = (x499)^((uintptr_t)(UINTMAX_C(4294967295))); + x501 = ((x392)&(x499))|((x429)&(x500)); + x502 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x503 = (x502)^((uintptr_t)(UINTMAX_C(4294967295))); + x504 = ((x396)&(x502))|((x433)&(x503)); + x505 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x506 = (x505)^((uintptr_t)(UINTMAX_C(4294967295))); + x507 = ((x401)&(x505))|((x436)&(x506)); + x508 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x509 = (x508)^((uintptr_t)(UINTMAX_C(4294967295))); + x510 = ((x406)&(x508))|((x440)&(x509)); + x511 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x512 = (x511)^((uintptr_t)(UINTMAX_C(4294967295))); + x513 = ((x411)&(x511))|((x445)&(x512)); + x514 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x515 = (x514)^((uintptr_t)(UINTMAX_C(4294967295))); + x516 = ((x416)&(x514))|((x450)&(x515)); + x517 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x518 = (x517)^((uintptr_t)(UINTMAX_C(4294967295))); + x519 = ((x421)&(x517))|((x455)&(x518)); + x520 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x464)==((uintptr_t)(UINTMAX_C(0))))); + x521 = (x520)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x524, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(4))), x525, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(8))), x526, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(12))), x527, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(16))), x528, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(20))), x529, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(24))), x530, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(28))), x531, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(32))), x532, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)(UINTMAX_C(0))), x533, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(4))), x534, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(8))), x535, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(12))), x536, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(16))), x537, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(20))), x538, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(24))), x539, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(28))), x540, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(32))), x541, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)(UINTMAX_C(0))), x542, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(4))), x543, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(8))), x544, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(12))), x545, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(16))), x546, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(20))), x547, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(24))), x548, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(28))), x549, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)(UINTMAX_C(0))), x550, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(4))), x551, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(8))), x552, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(12))), x553, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(16))), x554, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(20))), x555, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(24))), x556, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(28))), x557, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_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_sm2_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_sm2_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(2415919102)); + x1 = (uintptr_t)(UINTMAX_C(1342177282)); + x2 = (uintptr_t)(UINTMAX_C(2684354558)); + x3 = (uintptr_t)(UINTMAX_C(3892314112)); + x4 = (uintptr_t)(UINTMAX_C(2415919102)); + x5 = (uintptr_t)(UINTMAX_C(3489660929)); + x6 = (uintptr_t)(UINTMAX_C(536870909)); + x7 = (uintptr_t)(UINTMAX_C(671088641)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_divstep_precomp(uint32_t out1[8]) { + internal_fiat_sm2_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/sm2_64.c b/fiat-bedrock2/src/sm2_64.c new file mode 100644 index 00000000000..01439014135 --- /dev/null +++ b/fiat-bedrock2/src/sm2_64.c @@ -0,0 +1,2185 @@ +/* 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 sm2 64 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2 */ +/* 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") */ +/* */ +/* 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 +#include + +static __attribute__((constructor)) void _br2_preconditions(void) { + static_assert(~(intptr_t)0 == -(intptr_t)1, "two's complement"); + assert(((void)"two's complement", ~(intptr_t)0 == -(intptr_t)1)); + uintptr_t u = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&u)); + intptr_t i = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&i)); +} + +// 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 inline __attribute__((always_inline, unused)) +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 inline __attribute__((always_inline, unused)) +void _br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_mulhuu(uintptr_t a, uintptr_t b) { + #if (UINTPTR_MAX == (UINTMAX_C(1)<<31) - 1 + (UINTMAX_C(1)<<31)) + return ((uint64_t)a * b) >> 32; + #elif (UINTPTR_MAX == (UINTMAX_C(1)<<63) - 1 + (UINTMAX_C(1)<<63)) + return ((unsigned __int128)a * b) >> 64; + #else + #error "32-bit or 64-bit uintptr_t required" + #endif +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_divu(uintptr_t a, uintptr_t b) { + if (!b) return -1; + return a/b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_remu(uintptr_t a, uintptr_t b) { + if (!b) return a; + return a%b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_shamt(uintptr_t a) { + return a&(sizeof(uintptr_t)*8-1); +} + + +/* + * 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_sm2_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, x37, x40, x42, x38, x43, x35, x44, x46, x47, x36, x48, x33, x49, x51, x52, x34, x39, x54, x18, x55, x20, x56, x41, x57, x59, x60, x24, x61, x45, x62, x64, x65, x29, x66, x50, x67, x69, x70, x32, x71, x53, x72, x74, x8, x80, x83, x85, x81, x86, x78, x87, x89, x90, x79, x91, x76, x92, x94, x95, x77, x82, x58, x98, x63, x99, x84, x100, x102, x103, x68, x104, x88, x105, x107, x108, x73, x109, x93, x110, x112, x113, x75, x114, x96, x115, x117, x123, x126, x128, x124, x129, x121, x130, x132, x133, x122, x134, x119, x135, x137, x138, x120, x125, x140, x97, x141, x101, x142, x127, x143, x145, x146, x106, x147, x131, x148, x150, x151, x111, x152, x136, x153, x155, x156, x116, x157, x139, x158, x160, x161, x118, x9, x167, x170, x172, x168, x173, x165, x174, x176, x177, x166, x178, x163, x179, x181, x182, x164, x169, x144, x185, x149, x186, x171, x187, x189, x190, x154, x191, x175, x192, x194, x195, x159, x196, x180, x197, x199, x200, x162, x201, x183, x202, x204, x210, x213, x215, x211, x216, x208, x217, x219, x220, x209, x221, x206, x222, x224, x225, x207, x212, x227, x184, x228, x188, x229, x214, x230, x232, x233, x193, x234, x218, x235, x237, x238, x198, x239, x223, x240, x242, x243, x203, x244, x226, x245, x247, x248, x205, x7, x6, x5, x10, x4, x254, x257, x259, x255, x260, x252, x261, x263, x264, x253, x265, x250, x266, x268, x269, x251, x256, x231, x272, x236, x273, x258, x274, x276, x277, x241, x278, x262, x279, x281, x282, x246, x283, x267, x284, x286, x287, x249, x288, x270, x289, x291, x297, x300, x302, x298, x303, x295, x304, x306, x307, x296, x308, x293, x309, x311, x312, x294, x299, x314, x271, x315, x275, x316, x301, x317, x319, x320, x280, x321, x305, x322, x324, x325, x285, x326, x310, x327, x329, x330, x290, x331, x313, x332, x334, x335, x292, 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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x0; + x12 = (x11)*(x7); + x13 = _br2_mulhuu((x11), (x7)); + x14 = (x11)*(x6); + x15 = _br2_mulhuu((x11), (x6)); + x16 = (x11)*(x5); + x17 = _br2_mulhuu((x11), (x5)); + x18 = (x11)*(x4); + x19 = _br2_mulhuu((x11), (x4)); + 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)(UINTMAX_C(18446744069414584319))); + x34 = _br2_mulhuu((x18), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x35 = (x18)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x36 = _br2_mulhuu((x18), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x37 = (x18)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x38 = _br2_mulhuu((x18), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x39 = (x18)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x40 = _br2_mulhuu((x18), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x41 = (x40)+(x37); + x42 = (uintptr_t)((x41)<(x40)); + x43 = (x42)+(x38); + x44 = (uintptr_t)((x43)<(x38)); + x45 = (x43)+(x35); + x46 = (uintptr_t)((x45)<(x35)); + x47 = (x44)+(x46); + x48 = (x47)+(x36); + x49 = (uintptr_t)((x48)<(x36)); + x50 = (x48)+(x33); + x51 = (uintptr_t)((x50)<(x33)); + x52 = (x49)+(x51); + x53 = (x52)+(x34); + x54 = (x18)+(x39); + x55 = (uintptr_t)((x54)<(x18)); + x56 = (x55)+(x20); + x57 = (uintptr_t)((x56)<(x20)); + x58 = (x56)+(x41); + x59 = (uintptr_t)((x58)<(x41)); + x60 = (x57)+(x59); + x61 = (x60)+(x24); + x62 = (uintptr_t)((x61)<(x24)); + x63 = (x61)+(x45); + x64 = (uintptr_t)((x63)<(x45)); + x65 = (x62)+(x64); + x66 = (x65)+(x29); + x67 = (uintptr_t)((x66)<(x29)); + x68 = (x66)+(x50); + x69 = (uintptr_t)((x68)<(x50)); + x70 = (x67)+(x69); + x71 = (x70)+(x32); + x72 = (uintptr_t)((x71)<(x32)); + x73 = (x71)+(x53); + x74 = (uintptr_t)((x73)<(x53)); + x75 = (x72)+(x74); + x76 = (x8)*(x7); + x77 = _br2_mulhuu((x8), (x7)); + x78 = (x8)*(x6); + x79 = _br2_mulhuu((x8), (x6)); + x80 = (x8)*(x5); + x81 = _br2_mulhuu((x8), (x5)); + x82 = (x8)*(x4); + x83 = _br2_mulhuu((x8), (x4)); + 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 = (x58)+(x82); + x98 = (uintptr_t)((x97)<(x58)); + x99 = (x98)+(x63); + x100 = (uintptr_t)((x99)<(x63)); + x101 = (x99)+(x84); + x102 = (uintptr_t)((x101)<(x84)); + x103 = (x100)+(x102); + x104 = (x103)+(x68); + x105 = (uintptr_t)((x104)<(x68)); + x106 = (x104)+(x88); + x107 = (uintptr_t)((x106)<(x88)); + x108 = (x105)+(x107); + x109 = (x108)+(x73); + x110 = (uintptr_t)((x109)<(x73)); + x111 = (x109)+(x93); + x112 = (uintptr_t)((x111)<(x93)); + x113 = (x110)+(x112); + x114 = (x113)+(x75); + x115 = (uintptr_t)((x114)<(x75)); + x116 = (x114)+(x96); + x117 = (uintptr_t)((x116)<(x96)); + x118 = (x115)+(x117); + x119 = (x97)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x120 = _br2_mulhuu((x97), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x121 = (x97)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x122 = _br2_mulhuu((x97), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x123 = (x97)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x124 = _br2_mulhuu((x97), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x125 = (x97)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x126 = _br2_mulhuu((x97), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + 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 = (x97)+(x125); + x141 = (uintptr_t)((x140)<(x97)); + x142 = (x141)+(x101); + x143 = (uintptr_t)((x142)<(x101)); + x144 = (x142)+(x127); + x145 = (uintptr_t)((x144)<(x127)); + x146 = (x143)+(x145); + x147 = (x146)+(x106); + x148 = (uintptr_t)((x147)<(x106)); + x149 = (x147)+(x131); + x150 = (uintptr_t)((x149)<(x131)); + x151 = (x148)+(x150); + x152 = (x151)+(x111); + x153 = (uintptr_t)((x152)<(x111)); + x154 = (x152)+(x136); + x155 = (uintptr_t)((x154)<(x136)); + x156 = (x153)+(x155); + x157 = (x156)+(x116); + x158 = (uintptr_t)((x157)<(x116)); + x159 = (x157)+(x139); + x160 = (uintptr_t)((x159)<(x139)); + x161 = (x158)+(x160); + x162 = (x161)+(x118); + x163 = (x9)*(x7); + x164 = _br2_mulhuu((x9), (x7)); + x165 = (x9)*(x6); + x166 = _br2_mulhuu((x9), (x6)); + x167 = (x9)*(x5); + x168 = _br2_mulhuu((x9), (x5)); + x169 = (x9)*(x4); + x170 = _br2_mulhuu((x9), (x4)); + x171 = (x170)+(x167); + x172 = (uintptr_t)((x171)<(x170)); + x173 = (x172)+(x168); + x174 = (uintptr_t)((x173)<(x168)); + x175 = (x173)+(x165); + x176 = (uintptr_t)((x175)<(x165)); + x177 = (x174)+(x176); + x178 = (x177)+(x166); + x179 = (uintptr_t)((x178)<(x166)); + x180 = (x178)+(x163); + x181 = (uintptr_t)((x180)<(x163)); + x182 = (x179)+(x181); + x183 = (x182)+(x164); + x184 = (x144)+(x169); + x185 = (uintptr_t)((x184)<(x144)); + x186 = (x185)+(x149); + x187 = (uintptr_t)((x186)<(x149)); + x188 = (x186)+(x171); + x189 = (uintptr_t)((x188)<(x171)); + x190 = (x187)+(x189); + x191 = (x190)+(x154); + x192 = (uintptr_t)((x191)<(x154)); + x193 = (x191)+(x175); + x194 = (uintptr_t)((x193)<(x175)); + x195 = (x192)+(x194); + x196 = (x195)+(x159); + x197 = (uintptr_t)((x196)<(x159)); + x198 = (x196)+(x180); + x199 = (uintptr_t)((x198)<(x180)); + x200 = (x197)+(x199); + x201 = (x200)+(x162); + x202 = (uintptr_t)((x201)<(x162)); + x203 = (x201)+(x183); + x204 = (uintptr_t)((x203)<(x183)); + x205 = (x202)+(x204); + x206 = (x184)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x207 = _br2_mulhuu((x184), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x208 = (x184)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x209 = _br2_mulhuu((x184), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x210 = (x184)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x211 = _br2_mulhuu((x184), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x212 = (x184)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x213 = _br2_mulhuu((x184), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x214 = (x213)+(x210); + x215 = (uintptr_t)((x214)<(x213)); + x216 = (x215)+(x211); + x217 = (uintptr_t)((x216)<(x211)); + x218 = (x216)+(x208); + x219 = (uintptr_t)((x218)<(x208)); + x220 = (x217)+(x219); + x221 = (x220)+(x209); + x222 = (uintptr_t)((x221)<(x209)); + x223 = (x221)+(x206); + x224 = (uintptr_t)((x223)<(x206)); + x225 = (x222)+(x224); + x226 = (x225)+(x207); + x227 = (x184)+(x212); + x228 = (uintptr_t)((x227)<(x184)); + x229 = (x228)+(x188); + x230 = (uintptr_t)((x229)<(x188)); + x231 = (x229)+(x214); + x232 = (uintptr_t)((x231)<(x214)); + x233 = (x230)+(x232); + x234 = (x233)+(x193); + x235 = (uintptr_t)((x234)<(x193)); + x236 = (x234)+(x218); + x237 = (uintptr_t)((x236)<(x218)); + x238 = (x235)+(x237); + x239 = (x238)+(x198); + x240 = (uintptr_t)((x239)<(x198)); + x241 = (x239)+(x223); + x242 = (uintptr_t)((x241)<(x223)); + x243 = (x240)+(x242); + x244 = (x243)+(x203); + x245 = (uintptr_t)((x244)<(x203)); + x246 = (x244)+(x226); + x247 = (uintptr_t)((x246)<(x226)); + x248 = (x245)+(x247); + x249 = (x248)+(x205); + x250 = (x10)*(x7); + x251 = _br2_mulhuu((x10), (x7)); + x252 = (x10)*(x6); + x253 = _br2_mulhuu((x10), (x6)); + x254 = (x10)*(x5); + x255 = _br2_mulhuu((x10), (x5)); + x256 = (x10)*(x4); + x257 = _br2_mulhuu((x10), (x4)); + x258 = (x257)+(x254); + x259 = (uintptr_t)((x258)<(x257)); + x260 = (x259)+(x255); + x261 = (uintptr_t)((x260)<(x255)); + x262 = (x260)+(x252); + x263 = (uintptr_t)((x262)<(x252)); + x264 = (x261)+(x263); + x265 = (x264)+(x253); + x266 = (uintptr_t)((x265)<(x253)); + x267 = (x265)+(x250); + x268 = (uintptr_t)((x267)<(x250)); + x269 = (x266)+(x268); + x270 = (x269)+(x251); + x271 = (x231)+(x256); + x272 = (uintptr_t)((x271)<(x231)); + x273 = (x272)+(x236); + x274 = (uintptr_t)((x273)<(x236)); + x275 = (x273)+(x258); + x276 = (uintptr_t)((x275)<(x258)); + x277 = (x274)+(x276); + x278 = (x277)+(x241); + x279 = (uintptr_t)((x278)<(x241)); + x280 = (x278)+(x262); + x281 = (uintptr_t)((x280)<(x262)); + x282 = (x279)+(x281); + x283 = (x282)+(x246); + x284 = (uintptr_t)((x283)<(x246)); + x285 = (x283)+(x267); + x286 = (uintptr_t)((x285)<(x267)); + x287 = (x284)+(x286); + x288 = (x287)+(x249); + x289 = (uintptr_t)((x288)<(x249)); + x290 = (x288)+(x270); + x291 = (uintptr_t)((x290)<(x270)); + x292 = (x289)+(x291); + x293 = (x271)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x294 = _br2_mulhuu((x271), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x295 = (x271)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x296 = _br2_mulhuu((x271), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x297 = (x271)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x298 = _br2_mulhuu((x271), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x299 = (x271)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x300 = _br2_mulhuu((x271), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + 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 = (x271)+(x299); + x315 = (uintptr_t)((x314)<(x271)); + x316 = (x315)+(x275); + x317 = (uintptr_t)((x316)<(x275)); + x318 = (x316)+(x301); + x319 = (uintptr_t)((x318)<(x301)); + x320 = (x317)+(x319); + x321 = (x320)+(x280); + x322 = (uintptr_t)((x321)<(x280)); + x323 = (x321)+(x305); + x324 = (uintptr_t)((x323)<(x305)); + x325 = (x322)+(x324); + x326 = (x325)+(x285); + x327 = (uintptr_t)((x326)<(x285)); + x328 = (x326)+(x310); + x329 = (uintptr_t)((x328)<(x310)); + x330 = (x327)+(x329); + x331 = (x330)+(x290); + x332 = (uintptr_t)((x331)<(x290)); + x333 = (x331)+(x313); + x334 = (uintptr_t)((x333)<(x313)); + x335 = (x332)+(x334); + x336 = (x335)+(x292); + x337 = (x318)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x338 = (uintptr_t)((x318)<(x337)); + x339 = (x323)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x340 = (uintptr_t)((x323)<(x339)); + x341 = (x339)-(x338); + x342 = (uintptr_t)((x339)<(x341)); + x343 = (x340)+(x342); + x344 = (x328)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x345 = (uintptr_t)((x328)<(x344)); + x346 = (x344)-(x343); + x347 = (uintptr_t)((x344)<(x346)); + x348 = (x345)+(x347); + x349 = (x333)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x357 = (x356)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x358 = ((x318)&(x356))|((x337)&(x357)); + x359 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x360 = (x359)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x361 = ((x323)&(x359))|((x341)&(x360)); + x362 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x363 = (x362)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x364 = ((x328)&(x362))|((x346)&(x363)); + x365 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x366 = (x365)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x367 = ((x333)&(x365))|((x351)&(x366)); + x368 = x358; + x369 = x361; + x370 = x364; + x371 = x367; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x368, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x369, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x370, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x371, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_mul(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_sm2_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_sm2_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, x33, x36, x38, x34, x39, x31, x40, x42, x43, x32, x44, x29, x45, x47, x48, x30, x35, x50, x14, x51, x16, x52, x37, x53, x55, x56, x20, x57, x41, x58, x60, x61, x25, x62, x46, x63, x65, x66, x28, x67, x49, x68, x70, x4, x76, x79, x81, x77, x82, x74, x83, x85, x86, x75, x87, x72, x88, x90, x91, x73, x78, x54, x94, x59, x95, x80, x96, x98, x99, x64, x100, x84, x101, x103, x104, x69, x105, x89, x106, x108, x109, x71, x110, x92, x111, x113, x119, x122, x124, x120, x125, x117, x126, x128, x129, x118, x130, x115, x131, x133, x134, x116, x121, x136, x93, x137, x97, x138, x123, x139, x141, x142, x102, x143, x127, x144, x146, x147, x107, x148, x132, x149, x151, x152, x112, x153, x135, x154, x156, x157, x114, x5, x163, x166, x168, x164, x169, x161, x170, x172, x173, x162, x174, x159, x175, x177, x178, x160, x165, x140, x181, x145, x182, x167, x183, x185, x186, x150, x187, x171, x188, x190, x191, x155, x192, x176, x193, x195, x196, x158, x197, x179, x198, x200, x206, x209, x211, x207, x212, x204, x213, x215, x216, x205, x217, x202, x218, x220, x221, x203, x208, x223, x180, x224, x184, x225, x210, x226, x228, x229, x189, x230, x214, x231, x233, x234, x194, x235, x219, x236, x238, x239, x199, x240, x222, x241, x243, x244, x201, x3, x2, x1, x6, x0, x250, x253, x255, x251, x256, x248, x257, x259, x260, x249, x261, x246, x262, x264, x265, x247, x252, x227, x268, x232, x269, x254, x270, x272, x273, x237, x274, x258, x275, x277, x278, x242, x279, x263, x280, x282, x283, x245, x284, x266, x285, x287, x293, x296, x298, x294, x299, x291, x300, x302, x303, x292, x304, x289, x305, x307, x308, x290, x295, x310, x267, x311, x271, x312, x297, x313, x315, x316, x276, x317, x301, x318, x320, x321, x281, x322, x306, x323, x325, x326, x286, x327, x309, x328, x330, x331, x288, x334, x335, x336, x338, x339, x340, x341, x343, x344, x345, x346, x348, x349, x332, x350, x314, x352, x333, x353, x319, x355, x337, x356, x324, x358, x342, x359, x351, x329, x361, x347, x362, x354, x357, x360, x363, x364, x365, x366, x367; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*(x3); + x9 = _br2_mulhuu((x7), (x3)); + x10 = (x7)*(x2); + x11 = _br2_mulhuu((x7), (x2)); + x12 = (x7)*(x1); + x13 = _br2_mulhuu((x7), (x1)); + x14 = (x7)*(x0); + x15 = _br2_mulhuu((x7), (x0)); + 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)(UINTMAX_C(18446744069414584319))); + x30 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x31 = (x14)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x32 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x33 = (x14)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x34 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x35 = (x14)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x36 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x37 = (x36)+(x33); + x38 = (uintptr_t)((x37)<(x36)); + x39 = (x38)+(x34); + x40 = (uintptr_t)((x39)<(x34)); + x41 = (x39)+(x31); + x42 = (uintptr_t)((x41)<(x31)); + x43 = (x40)+(x42); + x44 = (x43)+(x32); + x45 = (uintptr_t)((x44)<(x32)); + x46 = (x44)+(x29); + x47 = (uintptr_t)((x46)<(x29)); + x48 = (x45)+(x47); + x49 = (x48)+(x30); + x50 = (x14)+(x35); + x51 = (uintptr_t)((x50)<(x14)); + x52 = (x51)+(x16); + x53 = (uintptr_t)((x52)<(x16)); + x54 = (x52)+(x37); + x55 = (uintptr_t)((x54)<(x37)); + x56 = (x53)+(x55); + x57 = (x56)+(x20); + x58 = (uintptr_t)((x57)<(x20)); + x59 = (x57)+(x41); + x60 = (uintptr_t)((x59)<(x41)); + x61 = (x58)+(x60); + x62 = (x61)+(x25); + x63 = (uintptr_t)((x62)<(x25)); + x64 = (x62)+(x46); + x65 = (uintptr_t)((x64)<(x46)); + x66 = (x63)+(x65); + x67 = (x66)+(x28); + x68 = (uintptr_t)((x67)<(x28)); + x69 = (x67)+(x49); + x70 = (uintptr_t)((x69)<(x49)); + x71 = (x68)+(x70); + x72 = (x4)*(x3); + x73 = _br2_mulhuu((x4), (x3)); + x74 = (x4)*(x2); + x75 = _br2_mulhuu((x4), (x2)); + x76 = (x4)*(x1); + x77 = _br2_mulhuu((x4), (x1)); + x78 = (x4)*(x0); + x79 = _br2_mulhuu((x4), (x0)); + 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 = (x54)+(x78); + x94 = (uintptr_t)((x93)<(x54)); + x95 = (x94)+(x59); + x96 = (uintptr_t)((x95)<(x59)); + x97 = (x95)+(x80); + x98 = (uintptr_t)((x97)<(x80)); + x99 = (x96)+(x98); + x100 = (x99)+(x64); + x101 = (uintptr_t)((x100)<(x64)); + x102 = (x100)+(x84); + x103 = (uintptr_t)((x102)<(x84)); + x104 = (x101)+(x103); + x105 = (x104)+(x69); + x106 = (uintptr_t)((x105)<(x69)); + x107 = (x105)+(x89); + x108 = (uintptr_t)((x107)<(x89)); + x109 = (x106)+(x108); + x110 = (x109)+(x71); + x111 = (uintptr_t)((x110)<(x71)); + x112 = (x110)+(x92); + x113 = (uintptr_t)((x112)<(x92)); + x114 = (x111)+(x113); + x115 = (x93)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x116 = _br2_mulhuu((x93), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x117 = (x93)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x118 = _br2_mulhuu((x93), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x119 = (x93)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x120 = _br2_mulhuu((x93), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x121 = (x93)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x122 = _br2_mulhuu((x93), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x123 = (x122)+(x119); + x124 = (uintptr_t)((x123)<(x122)); + x125 = (x124)+(x120); + x126 = (uintptr_t)((x125)<(x120)); + x127 = (x125)+(x117); + x128 = (uintptr_t)((x127)<(x117)); + x129 = (x126)+(x128); + x130 = (x129)+(x118); + x131 = (uintptr_t)((x130)<(x118)); + x132 = (x130)+(x115); + x133 = (uintptr_t)((x132)<(x115)); + x134 = (x131)+(x133); + x135 = (x134)+(x116); + x136 = (x93)+(x121); + x137 = (uintptr_t)((x136)<(x93)); + x138 = (x137)+(x97); + x139 = (uintptr_t)((x138)<(x97)); + x140 = (x138)+(x123); + x141 = (uintptr_t)((x140)<(x123)); + x142 = (x139)+(x141); + x143 = (x142)+(x102); + x144 = (uintptr_t)((x143)<(x102)); + x145 = (x143)+(x127); + x146 = (uintptr_t)((x145)<(x127)); + x147 = (x144)+(x146); + x148 = (x147)+(x107); + x149 = (uintptr_t)((x148)<(x107)); + x150 = (x148)+(x132); + x151 = (uintptr_t)((x150)<(x132)); + x152 = (x149)+(x151); + x153 = (x152)+(x112); + x154 = (uintptr_t)((x153)<(x112)); + x155 = (x153)+(x135); + x156 = (uintptr_t)((x155)<(x135)); + x157 = (x154)+(x156); + x158 = (x157)+(x114); + x159 = (x5)*(x3); + x160 = _br2_mulhuu((x5), (x3)); + x161 = (x5)*(x2); + x162 = _br2_mulhuu((x5), (x2)); + x163 = (x5)*(x1); + x164 = _br2_mulhuu((x5), (x1)); + x165 = (x5)*(x0); + x166 = _br2_mulhuu((x5), (x0)); + x167 = (x166)+(x163); + x168 = (uintptr_t)((x167)<(x166)); + x169 = (x168)+(x164); + x170 = (uintptr_t)((x169)<(x164)); + x171 = (x169)+(x161); + x172 = (uintptr_t)((x171)<(x161)); + x173 = (x170)+(x172); + x174 = (x173)+(x162); + x175 = (uintptr_t)((x174)<(x162)); + x176 = (x174)+(x159); + x177 = (uintptr_t)((x176)<(x159)); + x178 = (x175)+(x177); + x179 = (x178)+(x160); + x180 = (x140)+(x165); + x181 = (uintptr_t)((x180)<(x140)); + x182 = (x181)+(x145); + x183 = (uintptr_t)((x182)<(x145)); + x184 = (x182)+(x167); + x185 = (uintptr_t)((x184)<(x167)); + x186 = (x183)+(x185); + x187 = (x186)+(x150); + x188 = (uintptr_t)((x187)<(x150)); + x189 = (x187)+(x171); + x190 = (uintptr_t)((x189)<(x171)); + x191 = (x188)+(x190); + x192 = (x191)+(x155); + x193 = (uintptr_t)((x192)<(x155)); + x194 = (x192)+(x176); + x195 = (uintptr_t)((x194)<(x176)); + x196 = (x193)+(x195); + x197 = (x196)+(x158); + x198 = (uintptr_t)((x197)<(x158)); + x199 = (x197)+(x179); + x200 = (uintptr_t)((x199)<(x179)); + x201 = (x198)+(x200); + x202 = (x180)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x203 = _br2_mulhuu((x180), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x204 = (x180)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x205 = _br2_mulhuu((x180), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x206 = (x180)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x207 = _br2_mulhuu((x180), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x208 = (x180)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x209 = _br2_mulhuu((x180), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x210 = (x209)+(x206); + x211 = (uintptr_t)((x210)<(x209)); + x212 = (x211)+(x207); + x213 = (uintptr_t)((x212)<(x207)); + x214 = (x212)+(x204); + x215 = (uintptr_t)((x214)<(x204)); + x216 = (x213)+(x215); + x217 = (x216)+(x205); + x218 = (uintptr_t)((x217)<(x205)); + x219 = (x217)+(x202); + x220 = (uintptr_t)((x219)<(x202)); + x221 = (x218)+(x220); + x222 = (x221)+(x203); + x223 = (x180)+(x208); + x224 = (uintptr_t)((x223)<(x180)); + x225 = (x224)+(x184); + x226 = (uintptr_t)((x225)<(x184)); + x227 = (x225)+(x210); + x228 = (uintptr_t)((x227)<(x210)); + x229 = (x226)+(x228); + x230 = (x229)+(x189); + x231 = (uintptr_t)((x230)<(x189)); + x232 = (x230)+(x214); + x233 = (uintptr_t)((x232)<(x214)); + x234 = (x231)+(x233); + x235 = (x234)+(x194); + x236 = (uintptr_t)((x235)<(x194)); + x237 = (x235)+(x219); + x238 = (uintptr_t)((x237)<(x219)); + x239 = (x236)+(x238); + x240 = (x239)+(x199); + x241 = (uintptr_t)((x240)<(x199)); + x242 = (x240)+(x222); + x243 = (uintptr_t)((x242)<(x222)); + x244 = (x241)+(x243); + x245 = (x244)+(x201); + x246 = (x6)*(x3); + x247 = _br2_mulhuu((x6), (x3)); + x248 = (x6)*(x2); + x249 = _br2_mulhuu((x6), (x2)); + x250 = (x6)*(x1); + x251 = _br2_mulhuu((x6), (x1)); + x252 = (x6)*(x0); + x253 = _br2_mulhuu((x6), (x0)); + x254 = (x253)+(x250); + x255 = (uintptr_t)((x254)<(x253)); + x256 = (x255)+(x251); + x257 = (uintptr_t)((x256)<(x251)); + x258 = (x256)+(x248); + x259 = (uintptr_t)((x258)<(x248)); + x260 = (x257)+(x259); + x261 = (x260)+(x249); + x262 = (uintptr_t)((x261)<(x249)); + x263 = (x261)+(x246); + x264 = (uintptr_t)((x263)<(x246)); + x265 = (x262)+(x264); + x266 = (x265)+(x247); + x267 = (x227)+(x252); + x268 = (uintptr_t)((x267)<(x227)); + x269 = (x268)+(x232); + x270 = (uintptr_t)((x269)<(x232)); + x271 = (x269)+(x254); + x272 = (uintptr_t)((x271)<(x254)); + x273 = (x270)+(x272); + x274 = (x273)+(x237); + x275 = (uintptr_t)((x274)<(x237)); + x276 = (x274)+(x258); + x277 = (uintptr_t)((x276)<(x258)); + x278 = (x275)+(x277); + x279 = (x278)+(x242); + x280 = (uintptr_t)((x279)<(x242)); + x281 = (x279)+(x263); + x282 = (uintptr_t)((x281)<(x263)); + x283 = (x280)+(x282); + x284 = (x283)+(x245); + x285 = (uintptr_t)((x284)<(x245)); + x286 = (x284)+(x266); + x287 = (uintptr_t)((x286)<(x266)); + x288 = (x285)+(x287); + x289 = (x267)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x290 = _br2_mulhuu((x267), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x291 = (x267)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x292 = _br2_mulhuu((x267), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x293 = (x267)*((uintptr_t)(UINTMAX_C(18446744069414584320))); + x294 = _br2_mulhuu((x267), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x295 = (x267)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x296 = _br2_mulhuu((x267), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x297 = (x296)+(x293); + x298 = (uintptr_t)((x297)<(x296)); + x299 = (x298)+(x294); + x300 = (uintptr_t)((x299)<(x294)); + x301 = (x299)+(x291); + x302 = (uintptr_t)((x301)<(x291)); + x303 = (x300)+(x302); + x304 = (x303)+(x292); + x305 = (uintptr_t)((x304)<(x292)); + x306 = (x304)+(x289); + x307 = (uintptr_t)((x306)<(x289)); + x308 = (x305)+(x307); + x309 = (x308)+(x290); + x310 = (x267)+(x295); + x311 = (uintptr_t)((x310)<(x267)); + x312 = (x311)+(x271); + x313 = (uintptr_t)((x312)<(x271)); + x314 = (x312)+(x297); + x315 = (uintptr_t)((x314)<(x297)); + x316 = (x313)+(x315); + x317 = (x316)+(x276); + x318 = (uintptr_t)((x317)<(x276)); + x319 = (x317)+(x301); + x320 = (uintptr_t)((x319)<(x301)); + x321 = (x318)+(x320); + x322 = (x321)+(x281); + x323 = (uintptr_t)((x322)<(x281)); + x324 = (x322)+(x306); + x325 = (uintptr_t)((x324)<(x306)); + x326 = (x323)+(x325); + x327 = (x326)+(x286); + x328 = (uintptr_t)((x327)<(x286)); + x329 = (x327)+(x309); + x330 = (uintptr_t)((x329)<(x309)); + x331 = (x328)+(x330); + x332 = (x331)+(x288); + x333 = (x314)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x334 = (uintptr_t)((x314)<(x333)); + x335 = (x319)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x336 = (uintptr_t)((x319)<(x335)); + x337 = (x335)-(x334); + x338 = (uintptr_t)((x335)<(x337)); + x339 = (x336)+(x338); + x340 = (x324)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x341 = (uintptr_t)((x324)<(x340)); + x342 = (x340)-(x339); + x343 = (uintptr_t)((x340)<(x342)); + x344 = (x341)+(x343); + x345 = (x329)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + x346 = (uintptr_t)((x329)<(x345)); + x347 = (x345)-(x344); + x348 = (uintptr_t)((x345)<(x347)); + x349 = (x346)+(x348); + x350 = (x332)-(x349); + x351 = (uintptr_t)((x332)<(x350)); + x352 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x351)==((uintptr_t)(UINTMAX_C(0))))); + x353 = (x352)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x354 = ((x314)&(x352))|((x333)&(x353)); + x355 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x351)==((uintptr_t)(UINTMAX_C(0))))); + x356 = (x355)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x357 = ((x319)&(x355))|((x337)&(x356)); + x358 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x351)==((uintptr_t)(UINTMAX_C(0))))); + x359 = (x358)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x360 = ((x324)&(x358))|((x342)&(x359)); + x361 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x351)==((uintptr_t)(UINTMAX_C(0))))); + x362 = (x361)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x363 = ((x329)&(x361))|((x347)&(x362)); + x364 = x354; + x365 = x357; + x366 = x360; + x367 = x363; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x364, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x365, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x366, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x367, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_square(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), 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)(UINTMAX_C(18446744073709551615))); + x17 = (x10)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x18 = (x17)-((uintptr_t)((x8)<(x16))); + x19 = (x12)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x20 = (x19)-(((uintptr_t)((x10)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x14)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x25 = (x24)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x26 = ((x8)&(x24))|((x16)&(x25)); + x27 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x28 = (x27)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x29 = ((x10)&(x27))|((x18)&(x28)); + x30 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x31 = (x30)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x32 = ((x12)&(x30))|((x20)&(x31)); + x33 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x34 = (x33)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x35 = ((x14)&(x33))|((x22)&(x34)); + x36 = x26; + x37 = x29; + x38 = x32; + x39 = x35; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x39, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_add(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), 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)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)((x3)<(x13)))+((uintptr_t)((x13)<(x14))))==((uintptr_t)(UINTMAX_C(0))))); + x16 = (x8)+(x15); + x17 = ((uintptr_t)((x16)<(x8)))+(x10); + x18 = (x17)+((x15)&((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x19 = (((uintptr_t)((x17)<(x10)))+((uintptr_t)((x18)<((x15)&((uintptr_t)(UINTMAX_C(18446744069414584320)))))))+(x12); + x20 = (x19)+(x15); + x21 = ((((uintptr_t)((x19)<(x12)))+((uintptr_t)((x20)<(x15))))+(x14))+((x15)&((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x22 = x16; + x23 = x18; + x24 = x20; + x25 = x21; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x23, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x24, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x25, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_sub(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = ((uintptr_t)(UINTMAX_C(0)))-(x0); + x5 = ((uintptr_t)(UINTMAX_C(0)))-(x1); + x6 = (x5)-((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x4))); + x7 = ((uintptr_t)(UINTMAX_C(0)))-(x2); + x8 = (x7)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x5)))+((uintptr_t)((x5)<(x6)))); + x9 = ((uintptr_t)(UINTMAX_C(0)))-(x3); + x10 = (x9)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x7)))+((uintptr_t)((x7)<(x8)))); + x11 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x9)))+((uintptr_t)((x9)<(x10))))==((uintptr_t)(UINTMAX_C(0))))); + x12 = (x4)+(x11); + x13 = ((uintptr_t)((x12)<(x4)))+(x6); + x14 = (x13)+((x11)&((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x15 = (((uintptr_t)((x13)<(x6)))+((uintptr_t)((x14)<((x11)&((uintptr_t)(UINTMAX_C(18446744069414584320)))))))+(x8); + x16 = (x15)+(x11); + x17 = ((((uintptr_t)((x15)<(x8)))+((uintptr_t)((x16)<(x11))))+(x10))+((x11)&((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x18 = x12; + x19 = x14; + x20 = x16; + x21 = x17; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x18, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x19, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x21, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_opp(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_from_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x0, x10, x12, x9, x7, x14, x8, x5, x4, x11, x13, x15, x1, x17, x18, x19, x30, x32, x29, x27, x34, x28, x25, x21, x37, x22, x31, x39, x23, x33, x41, x24, x20, x16, x6, x35, x2, x38, x40, x42, x53, x55, x52, x50, x57, x51, x48, x44, x60, x45, x54, x62, x46, x56, x64, x47, x43, x36, x26, x58, x3, x61, x63, x65, x75, x77, x74, x72, x81, x68, x76, x83, x69, x78, x85, x70, x66, x59, x49, x79, x73, x80, x71, x67, x89, x91, x93, x82, x96, x88, x97, x84, x99, x90, x100, x86, x102, x92, x103, x95, x87, x105, x94, x106, x98, x101, x104, x107, x108, x109, x110, x111; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x0; + x5 = (x4)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x6 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x7 = (x4)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x8 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x9 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x10 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x11 = (x10)+((x4)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x12 = ((uintptr_t)((x11)<(x10)))+(x9); + x13 = (x12)+(x7); + x14 = (((uintptr_t)((x12)<(x9)))+((uintptr_t)((x13)<(x7))))+(x8); + x15 = (x14)+(x5); + x16 = ((uintptr_t)((x14)<(x8)))+((uintptr_t)((x15)<(x5))); + x17 = ((uintptr_t)(((x4)+((x4)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x4)))+(x11); + x18 = ((uintptr_t)((x17)<(x11)))+(x13); + x19 = ((uintptr_t)((x18)<(x13)))+(x15); + x20 = (uintptr_t)((x19)<(x15)); + x21 = (x17)+(x1); + x22 = ((uintptr_t)((x21)<(x17)))+(x18); + x23 = ((uintptr_t)((x22)<(x18)))+(x19); + x24 = (uintptr_t)((x23)<(x19)); + x25 = (x21)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x26 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x27 = (x21)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x28 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x29 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x30 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x31 = (x30)+((x21)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x32 = ((uintptr_t)((x31)<(x30)))+(x29); + x33 = (x32)+(x27); + x34 = (((uintptr_t)((x32)<(x29)))+((uintptr_t)((x33)<(x27))))+(x28); + x35 = (x34)+(x25); + x36 = ((uintptr_t)((x34)<(x28)))+((uintptr_t)((x35)<(x25))); + x37 = ((uintptr_t)(((x21)+((x21)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x21)))+(x22); + x38 = (x37)+(x31); + x39 = (((uintptr_t)((x37)<(x22)))+((uintptr_t)((x38)<(x31))))+(x23); + x40 = (x39)+(x33); + x41 = (((uintptr_t)((x39)<(x23)))+((uintptr_t)((x40)<(x33))))+((x24)+((x20)+((x16)+(x6)))); + x42 = (x41)+(x35); + x43 = ((uintptr_t)((x41)<((x24)+((x20)+((x16)+(x6))))))+((uintptr_t)((x42)<(x35))); + x44 = (x38)+(x2); + x45 = ((uintptr_t)((x44)<(x38)))+(x40); + x46 = ((uintptr_t)((x45)<(x40)))+(x42); + x47 = (uintptr_t)((x46)<(x42)); + x48 = (x44)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x49 = _br2_mulhuu((x44), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x50 = (x44)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x51 = _br2_mulhuu((x44), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x52 = _br2_mulhuu((x44), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x53 = _br2_mulhuu((x44), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x54 = (x53)+((x44)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + 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)(((x44)+((x44)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x44)))+(x45); + x61 = (x60)+(x54); + x62 = (((uintptr_t)((x60)<(x45)))+((uintptr_t)((x61)<(x54))))+(x46); + x63 = (x62)+(x56); + x64 = (((uintptr_t)((x62)<(x46)))+((uintptr_t)((x63)<(x56))))+((x47)+((x43)+((x36)+(x26)))); + x65 = (x64)+(x58); + x66 = ((uintptr_t)((x64)<((x47)+((x43)+((x36)+(x26))))))+((uintptr_t)((x65)<(x58))); + x67 = (x61)+(x3); + x68 = ((uintptr_t)((x67)<(x61)))+(x63); + x69 = ((uintptr_t)((x68)<(x63)))+(x65); + x70 = (uintptr_t)((x69)<(x65)); + x71 = (x67)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x72 = (x67)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x73 = _br2_mulhuu((x67), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x74 = _br2_mulhuu((x67), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x75 = _br2_mulhuu((x67), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x76 = (x75)+((x67)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x77 = ((uintptr_t)((x76)<(x75)))+(x74); + x78 = (x77)+(x72); + x79 = (((uintptr_t)((x77)<(x74)))+((uintptr_t)((x78)<(x72))))+(x73); + x80 = (x79)+(x71); + x81 = ((uintptr_t)(((x67)+((x67)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x67)))+(x68); + x82 = (x81)+(x76); + x83 = (((uintptr_t)((x81)<(x68)))+((uintptr_t)((x82)<(x76))))+(x69); + x84 = (x83)+(x78); + x85 = (((uintptr_t)((x83)<(x69)))+((uintptr_t)((x84)<(x78))))+((x70)+((x66)+((x59)+(x49)))); + x86 = (x85)+(x80); + x87 = (((uintptr_t)((x85)<((x70)+((x66)+((x59)+(x49))))))+((uintptr_t)((x86)<(x80))))+((((uintptr_t)((x79)<(x73)))+((uintptr_t)((x80)<(x71))))+(_br2_mulhuu((x67), ((uintptr_t)(UINTMAX_C(18446744069414584319)))))); + x88 = (x82)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x89 = (x84)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x90 = (x89)-((uintptr_t)((x82)<(x88))); + x91 = (x86)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x92 = (x91)-(((uintptr_t)((x84)<(x89)))+((uintptr_t)((x89)<(x90)))); + x93 = (x87)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + x94 = (x93)-(((uintptr_t)((x86)<(x91)))+((uintptr_t)((x91)<(x92)))); + x95 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(((uintptr_t)((x87)<(x93)))+((uintptr_t)((x93)<(x94)))))); + x96 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x95)==((uintptr_t)(UINTMAX_C(0))))); + x97 = (x96)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x98 = ((x82)&(x96))|((x88)&(x97)); + x99 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x95)==((uintptr_t)(UINTMAX_C(0))))); + x100 = (x99)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x101 = ((x84)&(x99))|((x90)&(x100)); + x102 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x95)==((uintptr_t)(UINTMAX_C(0))))); + x103 = (x102)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x104 = ((x86)&(x102))|((x92)&(x103)); + x105 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x95)==((uintptr_t)(UINTMAX_C(0))))); + x106 = (x105)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x107 = ((x87)&(x105))|((x94)&(x106)); + x108 = x98; + x109 = x101; + x110 = x104; + x111 = x107; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x108, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x109, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x110, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x111, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_from_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_to_montgomery(uintptr_t out0, uintptr_t in0) { + uintptr_t x1, x2, x3, x0, x7, x14, x16, x12, x10, x18, x11, x8, x26, x28, x25, x23, x30, x24, x21, x13, x33, x15, x27, x35, x17, x29, x37, x19, x31, x39, x20, x9, x32, x22, x47, x49, x46, x44, x51, x45, x42, x4, x34, x55, x36, x48, x57, x38, x50, x59, x40, x52, x67, x69, x66, x64, x71, x65, x62, x54, x74, x56, x68, x76, x58, x70, x78, x60, x72, x80, x61, x41, x53, x43, x73, x63, x88, x90, x87, x85, x92, x86, x83, x5, x75, x96, x77, x89, x98, x79, x91, x100, x81, x93, x108, x110, x107, x105, x112, x106, x103, x95, x115, x97, x109, x117, x99, x111, x119, x101, x113, x121, x102, x82, x94, x84, x114, x104, x129, x131, x128, x126, x133, x127, x124, x6, x116, x137, x118, x130, x139, x120, x132, x141, x122, x134, x149, x151, x148, x146, x153, x147, x144, x136, x156, x138, x150, x158, x140, x152, x160, x142, x154, x162, x143, x123, x135, x125, x155, x145, x166, x168, x164, x170, x157, x173, x165, x174, x159, x176, x167, x177, x161, x179, x169, x180, x172, x163, x182, x171, x183, x175, x178, x181, x184, x185, x186, x187, x188; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*((uintptr_t)(UINTMAX_C(17179869186))); + x9 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(17179869186)))); + x10 = (x7)*((uintptr_t)(UINTMAX_C(4294967297))); + x11 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(4294967297)))); + x12 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(12884901887)))); + x13 = (x7)*((uintptr_t)(UINTMAX_C(8589934595))); + x14 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(8589934595)))); + x15 = (x14)+((x7)*((uintptr_t)(UINTMAX_C(12884901887)))); + 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)(UINTMAX_C(18446744069414584319))); + x22 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x23 = (x13)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x24 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x25 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x26 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x27 = (x26)+((x13)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x28 = ((uintptr_t)((x27)<(x26)))+(x25); + x29 = (x28)+(x23); + x30 = (((uintptr_t)((x28)<(x25)))+((uintptr_t)((x29)<(x23))))+(x24); + x31 = (x30)+(x21); + x32 = ((uintptr_t)((x30)<(x24)))+((uintptr_t)((x31)<(x21))); + x33 = ((uintptr_t)(((x13)+((x13)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x13)))+(x15); + x34 = (x33)+(x27); + x35 = (((uintptr_t)((x33)<(x15)))+((uintptr_t)((x34)<(x27))))+(x17); + x36 = (x35)+(x29); + x37 = (((uintptr_t)((x35)<(x17)))+((uintptr_t)((x36)<(x29))))+(x19); + x38 = (x37)+(x31); + x39 = (((uintptr_t)((x37)<(x19)))+((uintptr_t)((x38)<(x31))))+((x20)+(x9)); + x40 = (x39)+((x32)+(x22)); + x41 = ((uintptr_t)((x39)<((x20)+(x9))))+((uintptr_t)((x40)<((x32)+(x22)))); + x42 = (x4)*((uintptr_t)(UINTMAX_C(17179869186))); + x43 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(17179869186)))); + x44 = (x4)*((uintptr_t)(UINTMAX_C(4294967297))); + x45 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(4294967297)))); + x46 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(12884901887)))); + x47 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(8589934595)))); + x48 = (x47)+((x4)*((uintptr_t)(UINTMAX_C(12884901887)))); + x49 = ((uintptr_t)((x48)<(x47)))+(x46); + x50 = (x49)+(x44); + x51 = (((uintptr_t)((x49)<(x46)))+((uintptr_t)((x50)<(x44))))+(x45); + x52 = (x51)+(x42); + x53 = ((uintptr_t)((x51)<(x45)))+((uintptr_t)((x52)<(x42))); + x54 = (x34)+((x4)*((uintptr_t)(UINTMAX_C(8589934595)))); + x55 = ((uintptr_t)((x54)<(x34)))+(x36); + x56 = (x55)+(x48); + x57 = (((uintptr_t)((x55)<(x36)))+((uintptr_t)((x56)<(x48))))+(x38); + x58 = (x57)+(x50); + x59 = (((uintptr_t)((x57)<(x38)))+((uintptr_t)((x58)<(x50))))+(x40); + x60 = (x59)+(x52); + x61 = ((uintptr_t)((x59)<(x40)))+((uintptr_t)((x60)<(x52))); + x62 = (x54)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x63 = _br2_mulhuu((x54), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x64 = (x54)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x65 = _br2_mulhuu((x54), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x66 = _br2_mulhuu((x54), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x67 = _br2_mulhuu((x54), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x68 = (x67)+((x54)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x69 = ((uintptr_t)((x68)<(x67)))+(x66); + x70 = (x69)+(x64); + x71 = (((uintptr_t)((x69)<(x66)))+((uintptr_t)((x70)<(x64))))+(x65); + x72 = (x71)+(x62); + x73 = ((uintptr_t)((x71)<(x65)))+((uintptr_t)((x72)<(x62))); + x74 = ((uintptr_t)(((x54)+((x54)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x54)))+(x56); + x75 = (x74)+(x68); + x76 = (((uintptr_t)((x74)<(x56)))+((uintptr_t)((x75)<(x68))))+(x58); + x77 = (x76)+(x70); + x78 = (((uintptr_t)((x76)<(x58)))+((uintptr_t)((x77)<(x70))))+(x60); + x79 = (x78)+(x72); + x80 = (((uintptr_t)((x78)<(x60)))+((uintptr_t)((x79)<(x72))))+(((x61)+(x41))+((x53)+(x43))); + x81 = (x80)+((x73)+(x63)); + x82 = ((uintptr_t)((x80)<(((x61)+(x41))+((x53)+(x43)))))+((uintptr_t)((x81)<((x73)+(x63)))); + x83 = (x5)*((uintptr_t)(UINTMAX_C(17179869186))); + x84 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(17179869186)))); + x85 = (x5)*((uintptr_t)(UINTMAX_C(4294967297))); + x86 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(4294967297)))); + x87 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(12884901887)))); + x88 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(8589934595)))); + x89 = (x88)+((x5)*((uintptr_t)(UINTMAX_C(12884901887)))); + 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 = (x75)+((x5)*((uintptr_t)(UINTMAX_C(8589934595)))); + x96 = ((uintptr_t)((x95)<(x75)))+(x77); + x97 = (x96)+(x89); + x98 = (((uintptr_t)((x96)<(x77)))+((uintptr_t)((x97)<(x89))))+(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))); + x103 = (x95)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x104 = _br2_mulhuu((x95), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x105 = (x95)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x106 = _br2_mulhuu((x95), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x107 = _br2_mulhuu((x95), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x108 = _br2_mulhuu((x95), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x109 = (x108)+((x95)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x110 = ((uintptr_t)((x109)<(x108)))+(x107); + x111 = (x110)+(x105); + x112 = (((uintptr_t)((x110)<(x107)))+((uintptr_t)((x111)<(x105))))+(x106); + x113 = (x112)+(x103); + x114 = ((uintptr_t)((x112)<(x106)))+((uintptr_t)((x113)<(x103))); + x115 = ((uintptr_t)(((x95)+((x95)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x95)))+(x97); + x116 = (x115)+(x109); + x117 = (((uintptr_t)((x115)<(x97)))+((uintptr_t)((x116)<(x109))))+(x99); + x118 = (x117)+(x111); + x119 = (((uintptr_t)((x117)<(x99)))+((uintptr_t)((x118)<(x111))))+(x101); + x120 = (x119)+(x113); + x121 = (((uintptr_t)((x119)<(x101)))+((uintptr_t)((x120)<(x113))))+(((x102)+(x82))+((x94)+(x84))); + x122 = (x121)+((x114)+(x104)); + x123 = ((uintptr_t)((x121)<(((x102)+(x82))+((x94)+(x84)))))+((uintptr_t)((x122)<((x114)+(x104)))); + x124 = (x6)*((uintptr_t)(UINTMAX_C(17179869186))); + x125 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(17179869186)))); + x126 = (x6)*((uintptr_t)(UINTMAX_C(4294967297))); + x127 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(4294967297)))); + x128 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(12884901887)))); + x129 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(8589934595)))); + x130 = (x129)+((x6)*((uintptr_t)(UINTMAX_C(12884901887)))); + x131 = ((uintptr_t)((x130)<(x129)))+(x128); + x132 = (x131)+(x126); + x133 = (((uintptr_t)((x131)<(x128)))+((uintptr_t)((x132)<(x126))))+(x127); + x134 = (x133)+(x124); + x135 = ((uintptr_t)((x133)<(x127)))+((uintptr_t)((x134)<(x124))); + x136 = (x116)+((x6)*((uintptr_t)(UINTMAX_C(8589934595)))); + x137 = ((uintptr_t)((x136)<(x116)))+(x118); + x138 = (x137)+(x130); + x139 = (((uintptr_t)((x137)<(x118)))+((uintptr_t)((x138)<(x130))))+(x120); + x140 = (x139)+(x132); + x141 = (((uintptr_t)((x139)<(x120)))+((uintptr_t)((x140)<(x132))))+(x122); + x142 = (x141)+(x134); + x143 = ((uintptr_t)((x141)<(x122)))+((uintptr_t)((x142)<(x134))); + x144 = (x136)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x145 = _br2_mulhuu((x136), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x146 = (x136)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x147 = _br2_mulhuu((x136), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x148 = _br2_mulhuu((x136), ((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x149 = _br2_mulhuu((x136), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x150 = (x149)+((x136)*((uintptr_t)(UINTMAX_C(18446744069414584320)))); + 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))); + x156 = ((uintptr_t)(((x136)+((x136)*((uintptr_t)(UINTMAX_C(18446744073709551615)))))<(x136)))+(x138); + x157 = (x156)+(x150); + x158 = (((uintptr_t)((x156)<(x138)))+((uintptr_t)((x157)<(x150))))+(x140); + x159 = (x158)+(x152); + x160 = (((uintptr_t)((x158)<(x140)))+((uintptr_t)((x159)<(x152))))+(x142); + x161 = (x160)+(x154); + x162 = (((uintptr_t)((x160)<(x142)))+((uintptr_t)((x161)<(x154))))+(((x143)+(x123))+((x135)+(x125))); + x163 = (x162)+((x155)+(x145)); + x164 = ((uintptr_t)((x162)<(((x143)+(x123))+((x135)+(x125)))))+((uintptr_t)((x163)<((x155)+(x145)))); + x165 = (x157)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x166 = (x159)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x167 = (x166)-((uintptr_t)((x157)<(x165))); + x168 = (x161)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x169 = (x168)-(((uintptr_t)((x159)<(x166)))+((uintptr_t)((x166)<(x167)))); + x170 = (x163)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + x171 = (x170)-(((uintptr_t)((x161)<(x168)))+((uintptr_t)((x168)<(x169)))); + x172 = (uintptr_t)((x164)<((x164)-(((uintptr_t)((x163)<(x170)))+((uintptr_t)((x170)<(x171)))))); + x173 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x172)==((uintptr_t)(UINTMAX_C(0))))); + x174 = (x173)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x175 = ((x157)&(x173))|((x165)&(x174)); + x176 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x172)==((uintptr_t)(UINTMAX_C(0))))); + x177 = (x176)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x178 = ((x159)&(x176))|((x167)&(x177)); + x179 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x172)==((uintptr_t)(UINTMAX_C(0))))); + x180 = (x179)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x181 = ((x161)&(x179))|((x169)&(x180)); + x182 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x172)==((uintptr_t)(UINTMAX_C(0))))); + x183 = (x182)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x184 = ((x163)&(x182))|((x171)&(x183)); + x185 = x175; + x186 = x178; + x187 = x181; + x188 = x184; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x185, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x186, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x187, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x188, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_to_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, out0, x5; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), 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_sm2_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + *out1 = (uint64_t)internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x9 = (x8)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x10 = ((x4)&(x8))|((x0)&(x9)); + x11 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x12 = (x11)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x13 = ((x5)&(x11))|((x1)&(x12)); + x14 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x15 = (x14)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x16 = ((x6)&(x14))|((x2)&(x15)); + x17 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x18 = (x17)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x19 = ((x7)&(x17))|((x3)&(x18)); + x20 = x10; + x21 = x13; + x22 = x16; + x23 = x19; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x21, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x23, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_selectznz(uint64_t out1[4], uint8_t arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x3; + x5 = x2; + x6 = x1; + x7 = x0; + x8 = (x7)&((uintptr_t)(UINTMAX_C(255))); + x9 = (x7)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x10 = (x9)&((uintptr_t)(UINTMAX_C(255))); + x11 = (x9)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x12 = (x11)&((uintptr_t)(UINTMAX_C(255))); + x13 = (x11)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x14 = (x13)&((uintptr_t)(UINTMAX_C(255))); + x15 = (x13)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x16 = (x15)&((uintptr_t)(UINTMAX_C(255))); + x17 = (x15)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x18 = (x17)&((uintptr_t)(UINTMAX_C(255))); + x19 = (x17)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x20 = (x19)&((uintptr_t)(UINTMAX_C(255))); + x21 = (x19)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x22 = (x6)&((uintptr_t)(UINTMAX_C(255))); + x23 = (x6)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x24 = (x23)&((uintptr_t)(UINTMAX_C(255))); + x25 = (x23)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x26 = (x25)&((uintptr_t)(UINTMAX_C(255))); + x27 = (x25)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x28 = (x27)&((uintptr_t)(UINTMAX_C(255))); + x29 = (x27)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x30 = (x29)&((uintptr_t)(UINTMAX_C(255))); + x31 = (x29)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x32 = (x31)&((uintptr_t)(UINTMAX_C(255))); + x33 = (x31)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x34 = (x33)&((uintptr_t)(UINTMAX_C(255))); + x35 = (x33)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x36 = (x5)&((uintptr_t)(UINTMAX_C(255))); + x37 = (x5)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x38 = (x37)&((uintptr_t)(UINTMAX_C(255))); + x39 = (x37)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x40 = (x39)&((uintptr_t)(UINTMAX_C(255))); + x41 = (x39)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x42 = (x41)&((uintptr_t)(UINTMAX_C(255))); + x43 = (x41)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x44 = (x43)&((uintptr_t)(UINTMAX_C(255))); + x45 = (x43)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x46 = (x45)&((uintptr_t)(UINTMAX_C(255))); + x47 = (x45)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x48 = (x47)&((uintptr_t)(UINTMAX_C(255))); + x49 = (x47)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x50 = (x4)&((uintptr_t)(UINTMAX_C(255))); + x51 = (x4)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x52 = (x51)&((uintptr_t)(UINTMAX_C(255))); + x53 = (x51)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x54 = (x53)&((uintptr_t)(UINTMAX_C(255))); + x55 = (x53)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x56 = (x55)&((uintptr_t)(UINTMAX_C(255))); + x57 = (x55)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x58 = (x57)&((uintptr_t)(UINTMAX_C(255))); + x59 = (x57)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x60 = (x59)&((uintptr_t)(UINTMAX_C(255))); + x61 = (x59)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x62 = (x61)&((uintptr_t)(UINTMAX_C(255))); + x63 = (x61)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x64, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(1))), x65, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(2))), x66, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(3))), x67, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x68, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(5))), x69, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(6))), x70, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(7))), x71, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x72, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(9))), x73, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(10))), x74, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(11))), x75, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x76, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(13))), x77, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(14))), x78, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(15))), x79, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x80, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(17))), x81, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(18))), x82, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(19))), x83, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x84, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(21))), x85, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(22))), x86, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(23))), x87, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x88, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(25))), x89, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(26))), x90, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(27))), x91, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x92, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(29))), x93, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(30))), x94, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(31))), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), 1); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(1))), 1); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(2))), 1); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(3))), 1); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), 1); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(5))), 1); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(6))), 1); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(7))), 1); + x8 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), 1); + x9 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(9))), 1); + x10 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(10))), 1); + x11 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(11))), 1); + x12 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), 1); + x13 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(13))), 1); + x14 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(14))), 1); + x15 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(15))), 1); + x16 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), 1); + x17 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(17))), 1); + x18 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(18))), 1); + x19 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(19))), 1); + x20 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), 1); + x21 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(21))), 1); + x22 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(22))), 1); + x23 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(23))), 1); + x24 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), 1); + x25 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(25))), 1); + x26 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(26))), 1); + x27 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(27))), 1); + x28 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 1); + x29 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(29))), 1); + x30 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(30))), 1); + x31 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(31))), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x33 = (x30)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x34 = (x29)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x35 = (x28)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x36 = (x27)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x37 = (x26)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x38 = (x25)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x39 = x24; + x40 = (x23)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x41 = (x22)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x42 = (x21)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x43 = (x20)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x44 = (x19)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x45 = (x18)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x46 = (x17)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x47 = x16; + x48 = (x15)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x49 = (x14)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x50 = (x13)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x51 = (x12)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x52 = (x11)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x53 = (x10)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x54 = (x9)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x55 = x8; + x56 = (x7)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x57 = (x6)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x58 = (x5)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x59 = (x4)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x60 = (x3)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x61 = (x2)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x62 = (x1)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + internal_fiat_sm2_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_sm2_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(1)); + x1 = (uintptr_t)(UINTMAX_C(4294967295)); + x2 = (uintptr_t)(UINTMAX_C(0)); + x3 = (uintptr_t)(UINTMAX_C(4294967296)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_set_one(uint64_t out1[4]) { + internal_fiat_sm2_set_one((uintptr_t)out1); +} + + +/* + * Input Bounds: + * Output Bounds: + * out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] + */ +static +void internal_fiat_sm2_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(18446744073709551615)); + x1 = (uintptr_t)(UINTMAX_C(18446744069414584320)); + x2 = (uintptr_t)(UINTMAX_C(18446744073709551615)); + x3 = (uintptr_t)(UINTMAX_C(18446744069414584319)); + x4 = (uintptr_t)(UINTMAX_C(0)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(32))), x4, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_msat(uint64_t out1[5]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x5 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x10 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x11 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x12 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x14 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x15 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x16 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x17 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x18 = ((in0)^((uintptr_t)(UINTMAX_C(18446744073709551615))))+((uintptr_t)(UINTMAX_C(1))); + x19 = ((x18)>>_br2_shamt((uintptr_t)(UINTMAX_C(63))))&((x5)&((uintptr_t)(UINTMAX_C(1)))); + x20 = ((in0)^((uintptr_t)(UINTMAX_C(18446744073709551615))))+((uintptr_t)(UINTMAX_C(1))); + x21 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x22 = (x21)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x23 = ((x20)&(x21))|((in0)&(x22)); + x24 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x25 = (x24)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x26 = ((x5)&(x24))|((x0)&(x25)); + x27 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x28 = (x27)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x29 = ((x6)&(x27))|((x1)&(x28)); + x30 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x31 = (x30)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x32 = ((x7)&(x30))|((x2)&(x31)); + x33 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x34 = (x33)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x35 = ((x8)&(x33))|((x3)&(x34)); + x36 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x37 = (x36)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x38 = ((x9)&(x36))|((x4)&(x37)); + x39 = ((uintptr_t)(UINTMAX_C(1)))+((x0)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x40 = (uintptr_t)((x39)<((uintptr_t)(UINTMAX_C(1)))); + x41 = (x40)+((x1)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x42 = (uintptr_t)((x41)<((x1)^((uintptr_t)(UINTMAX_C(18446744073709551615))))); + x43 = (x42)+((x2)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x44 = (uintptr_t)((x43)<((x2)^((uintptr_t)(UINTMAX_C(18446744073709551615))))); + x45 = (x44)+((x3)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x46 = (uintptr_t)((x45)<((x3)^((uintptr_t)(UINTMAX_C(18446744073709551615))))); + x47 = (x46)+((x4)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x48 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x49 = (x48)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x50 = ((x39)&(x48))|((x5)&(x49)); + x51 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x52 = (x51)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x53 = ((x41)&(x51))|((x6)&(x52)); + x54 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x55 = (x54)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x56 = ((x43)&(x54))|((x7)&(x55)); + x57 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x58 = (x57)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x59 = ((x45)&(x57))|((x8)&(x58)); + x60 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x61 = (x60)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x62 = ((x47)&(x60))|((x9)&(x61)); + x63 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x64 = (x63)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x65 = ((x14)&(x63))|((x10)&(x64)); + x66 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x67 = (x66)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x68 = ((x15)&(x66))|((x11)&(x67)); + x69 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x70 = (x69)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x71 = ((x16)&(x69))|((x12)&(x70)); + x72 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x73 = (x72)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + 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)(UINTMAX_C(18446744073709551615))); + x93 = (uintptr_t)((x75)<(x92)); + x94 = (x79)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x95 = (uintptr_t)((x79)<(x94)); + x96 = (x94)-(x93); + x97 = (uintptr_t)((x94)<(x96)); + x98 = (x95)+(x97); + x99 = (x84)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x100 = (uintptr_t)((x84)<(x99)); + x101 = (x99)-(x98); + x102 = (uintptr_t)((x99)<(x101)); + x103 = (x100)+(x102); + x104 = (x89)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x114))); + x116 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x113))); + x117 = (((uintptr_t)(UINTMAX_C(0)))-(x113))-(x115); + x118 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x113))<(x117)); + x119 = (x116)+(x118); + x120 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x112))); + x121 = (((uintptr_t)(UINTMAX_C(0)))-(x112))-(x119); + x122 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x112))<(x121)); + x123 = (x120)+(x122); + x124 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x111))); + x125 = (((uintptr_t)(UINTMAX_C(0)))-(x111))-(x123); + x126 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x111))<(x125)); + x127 = (x124)+(x126); + x128 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x127)==((uintptr_t)(UINTMAX_C(0))))); + x129 = (((uintptr_t)(UINTMAX_C(0)))-(x114))+(x128); + x130 = (uintptr_t)((x129)<(((uintptr_t)(UINTMAX_C(0)))-(x114))); + x131 = (x130)+(x117); + x132 = (uintptr_t)((x131)<(x117)); + x133 = (x131)+((x128)&((uintptr_t)(UINTMAX_C(18446744069414584320)))); + x134 = (uintptr_t)((x133)<((x128)&((uintptr_t)(UINTMAX_C(18446744069414584320))))); + 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)(UINTMAX_C(18446744069414584319)))); + x143 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x144 = (x143)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x145 = ((x129)&(x143))|((x14)&(x144)); + x146 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x147 = (x146)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x148 = ((x133)&(x146))|((x15)&(x147)); + x149 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x150 = (x149)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x151 = ((x138)&(x149))|((x16)&(x150)); + x152 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x153 = (x152)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x154 = ((x142)&(x152))|((x17)&(x153)); + x155 = (x50)&((uintptr_t)(UINTMAX_C(1))); + x156 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x157 = (x156)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x158 = ((x26)&(x156))|(((uintptr_t)(UINTMAX_C(0)))&(x157)); + x159 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x160 = (x159)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x161 = ((x29)&(x159))|(((uintptr_t)(UINTMAX_C(0)))&(x160)); + x162 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x163 = (x162)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x164 = ((x32)&(x162))|(((uintptr_t)(UINTMAX_C(0)))&(x163)); + x165 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x166 = (x165)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x167 = ((x35)&(x165))|(((uintptr_t)(UINTMAX_C(0)))&(x166)); + x168 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x169 = (x168)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x170 = ((x38)&(x168))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x191 = (x190)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x192 = ((x65)&(x190))|(((uintptr_t)(UINTMAX_C(0)))&(x191)); + x193 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x194 = (x193)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x195 = ((x68)&(x193))|(((uintptr_t)(UINTMAX_C(0)))&(x194)); + x196 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x197 = (x196)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x198 = ((x71)&(x196))|(((uintptr_t)(UINTMAX_C(0)))&(x197)); + x199 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x200 = (x199)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x201 = ((x74)&(x199))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(18446744073709551615))); + x220 = (uintptr_t)((x202)<(x219)); + x221 = (x206)-((uintptr_t)(UINTMAX_C(18446744069414584320))); + x222 = (uintptr_t)((x206)<(x221)); + x223 = (x221)-(x220); + x224 = (uintptr_t)((x221)<(x223)); + x225 = (x222)+(x224); + x226 = (x211)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x227 = (uintptr_t)((x211)<(x226)); + x228 = (x226)-(x225); + x229 = (uintptr_t)((x226)<(x228)); + x230 = (x227)+(x229); + x231 = (x216)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(1))); + x239 = ((x171)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x175)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x240 = ((x175)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x180)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x241 = ((x180)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x185)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x242 = ((x185)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x189)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x243 = ((x189)&((uintptr_t)(UINTMAX_C(9223372036854775808))))|((x189)>>_br2_shamt((uintptr_t)(UINTMAX_C(1)))); + x244 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x245 = (x244)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x246 = ((x75)&(x244))|((x92)&(x245)); + x247 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x248 = (x247)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x249 = ((x79)&(x247))|((x96)&(x248)); + x250 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x251 = (x250)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x252 = ((x84)&(x250))|((x101)&(x251)); + x253 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x254 = (x253)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x255 = ((x89)&(x253))|((x106)&(x254)); + x256 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x257 = (x256)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x258 = ((x202)&(x256))|((x219)&(x257)); + x259 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x260 = (x259)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x261 = ((x206)&(x259))|((x223)&(x260)); + x262 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x263 = (x262)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x264 = ((x211)&(x262))|((x228)&(x263)); + x265 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x266 = (x265)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + 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)(UINTMAX_C(0))), x269, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(8))), x270, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(16))), x271, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(24))), x272, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(32))), x273, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)(UINTMAX_C(0))), x274, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(8))), x275, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(16))), x276, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(24))), x277, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(32))), x278, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)(UINTMAX_C(0))), x279, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(8))), x280, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(16))), x281, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(24))), x282, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)(UINTMAX_C(0))), x283, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(8))), x284, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(16))), x285, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(24))), x286, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_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_sm2_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_sm2_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(5764607534040088574)); + x1 = (uintptr_t)(UINTMAX_C(16717361819483635710)); + x2 = (uintptr_t)(UINTMAX_C(14987979566599897086)); + x3 = (uintptr_t)(UINTMAX_C(2882303766348955645)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_divstep_precomp(uint64_t out1[4]) { + internal_fiat_sm2_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/sm2_scalar_32.c b/fiat-bedrock2/src/sm2_scalar_32.c new file mode 100644 index 00000000000..71ede02ea7d --- /dev/null +++ b/fiat-bedrock2/src/sm2_scalar_32.c @@ -0,0 +1,5908 @@ +/* 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 sm2_scalar 32 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") */ +/* */ +/* 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 +#include + +static __attribute__((constructor)) void _br2_preconditions(void) { + static_assert(~(intptr_t)0 == -(intptr_t)1, "two's complement"); + assert(((void)"two's complement", ~(intptr_t)0 == -(intptr_t)1)); + uintptr_t u = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&u)); + intptr_t i = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&i)); +} + +// 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 inline __attribute__((always_inline, unused)) +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 inline __attribute__((always_inline, unused)) +void _br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_mulhuu(uintptr_t a, uintptr_t b) { + #if (UINTPTR_MAX == (UINTMAX_C(1)<<31) - 1 + (UINTMAX_C(1)<<31)) + return ((uint64_t)a * b) >> 32; + #elif (UINTPTR_MAX == (UINTMAX_C(1)<<63) - 1 + (UINTMAX_C(1)<<63)) + return ((unsigned __int128)a * b) >> 64; + #else + #error "32-bit or 64-bit uintptr_t required" + #endif +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_divu(uintptr_t a, uintptr_t b) { + if (!b) return -1; + return a/b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_remu(uintptr_t a, uintptr_t b) { + if (!b) return a; + return a%b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_shamt(uintptr_t a) { + return a&(sizeof(uintptr_t)*8-1); +} + + +/* + * 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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), 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 = _br2_mulhuu((x23), (x15)); + x26 = (x23)*(x14); + x27 = _br2_mulhuu((x23), (x14)); + x28 = (x23)*(x13); + x29 = _br2_mulhuu((x23), (x13)); + x30 = (x23)*(x12); + x31 = _br2_mulhuu((x23), (x12)); + x32 = (x23)*(x11); + x33 = _br2_mulhuu((x23), (x11)); + x34 = (x23)*(x10); + x35 = _br2_mulhuu((x23), (x10)); + x36 = (x23)*(x9); + x37 = _br2_mulhuu((x23), (x9)); + x38 = (x23)*(x8); + x39 = _br2_mulhuu((x23), (x8)); + 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)(UINTMAX_C(1916078453))); + x74 = (x73)*((uintptr_t)(UINTMAX_C(4294967294))); + x75 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(4294967294)))); + x76 = (x73)*((uintptr_t)(UINTMAX_C(4294967295))); + x77 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(4294967295)))); + x78 = (x73)*((uintptr_t)(UINTMAX_C(4294967295))); + x79 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(4294967295)))); + x80 = (x73)*((uintptr_t)(UINTMAX_C(4294967295))); + x81 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(4294967295)))); + x82 = (x73)*((uintptr_t)(UINTMAX_C(1912856427))); + x83 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(1912856427)))); + x84 = (x73)*((uintptr_t)(UINTMAX_C(566625579))); + x85 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(566625579)))); + x86 = (x73)*((uintptr_t)(UINTMAX_C(1404826633))); + x87 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(1404826633)))); + x88 = (x73)*((uintptr_t)(UINTMAX_C(970277155))); + x89 = _br2_mulhuu((x73), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x16), (x15)); + x167 = (x16)*(x14); + x168 = _br2_mulhuu((x16), (x14)); + x169 = (x16)*(x13); + x170 = _br2_mulhuu((x16), (x13)); + x171 = (x16)*(x12); + x172 = _br2_mulhuu((x16), (x12)); + x173 = (x16)*(x11); + x174 = _br2_mulhuu((x16), (x11)); + x175 = (x16)*(x10); + x176 = _br2_mulhuu((x16), (x10)); + x177 = (x16)*(x9); + x178 = _br2_mulhuu((x16), (x9)); + x179 = (x16)*(x8); + x180 = _br2_mulhuu((x16), (x8)); + 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)(UINTMAX_C(1916078453))); + x257 = (x256)*((uintptr_t)(UINTMAX_C(4294967294))); + x258 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(4294967294)))); + x259 = (x256)*((uintptr_t)(UINTMAX_C(4294967295))); + x260 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(4294967295)))); + x261 = (x256)*((uintptr_t)(UINTMAX_C(4294967295))); + x262 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(4294967295)))); + x263 = (x256)*((uintptr_t)(UINTMAX_C(4294967295))); + x264 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(4294967295)))); + x265 = (x256)*((uintptr_t)(UINTMAX_C(1912856427))); + x266 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(1912856427)))); + x267 = (x256)*((uintptr_t)(UINTMAX_C(566625579))); + x268 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(566625579)))); + x269 = (x256)*((uintptr_t)(UINTMAX_C(1404826633))); + x270 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(1404826633)))); + x271 = (x256)*((uintptr_t)(UINTMAX_C(970277155))); + x272 = _br2_mulhuu((x256), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x17), (x15)); + x351 = (x17)*(x14); + x352 = _br2_mulhuu((x17), (x14)); + x353 = (x17)*(x13); + x354 = _br2_mulhuu((x17), (x13)); + x355 = (x17)*(x12); + x356 = _br2_mulhuu((x17), (x12)); + x357 = (x17)*(x11); + x358 = _br2_mulhuu((x17), (x11)); + x359 = (x17)*(x10); + x360 = _br2_mulhuu((x17), (x10)); + x361 = (x17)*(x9); + x362 = _br2_mulhuu((x17), (x9)); + x363 = (x17)*(x8); + x364 = _br2_mulhuu((x17), (x8)); + 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)(UINTMAX_C(1916078453))); + x441 = (x440)*((uintptr_t)(UINTMAX_C(4294967294))); + x442 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(4294967294)))); + x443 = (x440)*((uintptr_t)(UINTMAX_C(4294967295))); + x444 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(4294967295)))); + x445 = (x440)*((uintptr_t)(UINTMAX_C(4294967295))); + x446 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(4294967295)))); + x447 = (x440)*((uintptr_t)(UINTMAX_C(4294967295))); + x448 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(4294967295)))); + x449 = (x440)*((uintptr_t)(UINTMAX_C(1912856427))); + x450 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(1912856427)))); + x451 = (x440)*((uintptr_t)(UINTMAX_C(566625579))); + x452 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(566625579)))); + x453 = (x440)*((uintptr_t)(UINTMAX_C(1404826633))); + x454 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(1404826633)))); + x455 = (x440)*((uintptr_t)(UINTMAX_C(970277155))); + x456 = _br2_mulhuu((x440), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x18), (x15)); + x535 = (x18)*(x14); + x536 = _br2_mulhuu((x18), (x14)); + x537 = (x18)*(x13); + x538 = _br2_mulhuu((x18), (x13)); + x539 = (x18)*(x12); + x540 = _br2_mulhuu((x18), (x12)); + x541 = (x18)*(x11); + x542 = _br2_mulhuu((x18), (x11)); + x543 = (x18)*(x10); + x544 = _br2_mulhuu((x18), (x10)); + x545 = (x18)*(x9); + x546 = _br2_mulhuu((x18), (x9)); + x547 = (x18)*(x8); + x548 = _br2_mulhuu((x18), (x8)); + 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)(UINTMAX_C(1916078453))); + x625 = (x624)*((uintptr_t)(UINTMAX_C(4294967294))); + x626 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(4294967294)))); + x627 = (x624)*((uintptr_t)(UINTMAX_C(4294967295))); + x628 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(4294967295)))); + x629 = (x624)*((uintptr_t)(UINTMAX_C(4294967295))); + x630 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(4294967295)))); + x631 = (x624)*((uintptr_t)(UINTMAX_C(4294967295))); + x632 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(4294967295)))); + x633 = (x624)*((uintptr_t)(UINTMAX_C(1912856427))); + x634 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(1912856427)))); + x635 = (x624)*((uintptr_t)(UINTMAX_C(566625579))); + x636 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(566625579)))); + x637 = (x624)*((uintptr_t)(UINTMAX_C(1404826633))); + x638 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(1404826633)))); + x639 = (x624)*((uintptr_t)(UINTMAX_C(970277155))); + x640 = _br2_mulhuu((x624), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x19), (x15)); + x719 = (x19)*(x14); + x720 = _br2_mulhuu((x19), (x14)); + x721 = (x19)*(x13); + x722 = _br2_mulhuu((x19), (x13)); + x723 = (x19)*(x12); + x724 = _br2_mulhuu((x19), (x12)); + x725 = (x19)*(x11); + x726 = _br2_mulhuu((x19), (x11)); + x727 = (x19)*(x10); + x728 = _br2_mulhuu((x19), (x10)); + x729 = (x19)*(x9); + x730 = _br2_mulhuu((x19), (x9)); + x731 = (x19)*(x8); + x732 = _br2_mulhuu((x19), (x8)); + 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)(UINTMAX_C(1916078453))); + x809 = (x808)*((uintptr_t)(UINTMAX_C(4294967294))); + x810 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(4294967294)))); + x811 = (x808)*((uintptr_t)(UINTMAX_C(4294967295))); + x812 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(4294967295)))); + x813 = (x808)*((uintptr_t)(UINTMAX_C(4294967295))); + x814 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(4294967295)))); + x815 = (x808)*((uintptr_t)(UINTMAX_C(4294967295))); + x816 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(4294967295)))); + x817 = (x808)*((uintptr_t)(UINTMAX_C(1912856427))); + x818 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(1912856427)))); + x819 = (x808)*((uintptr_t)(UINTMAX_C(566625579))); + x820 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(566625579)))); + x821 = (x808)*((uintptr_t)(UINTMAX_C(1404826633))); + x822 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(1404826633)))); + x823 = (x808)*((uintptr_t)(UINTMAX_C(970277155))); + x824 = _br2_mulhuu((x808), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x20), (x15)); + x903 = (x20)*(x14); + x904 = _br2_mulhuu((x20), (x14)); + x905 = (x20)*(x13); + x906 = _br2_mulhuu((x20), (x13)); + x907 = (x20)*(x12); + x908 = _br2_mulhuu((x20), (x12)); + x909 = (x20)*(x11); + x910 = _br2_mulhuu((x20), (x11)); + x911 = (x20)*(x10); + x912 = _br2_mulhuu((x20), (x10)); + x913 = (x20)*(x9); + x914 = _br2_mulhuu((x20), (x9)); + x915 = (x20)*(x8); + x916 = _br2_mulhuu((x20), (x8)); + 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)(UINTMAX_C(1916078453))); + x993 = (x992)*((uintptr_t)(UINTMAX_C(4294967294))); + x994 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(4294967294)))); + x995 = (x992)*((uintptr_t)(UINTMAX_C(4294967295))); + x996 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(4294967295)))); + x997 = (x992)*((uintptr_t)(UINTMAX_C(4294967295))); + x998 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(4294967295)))); + x999 = (x992)*((uintptr_t)(UINTMAX_C(4294967295))); + x1000 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1001 = (x992)*((uintptr_t)(UINTMAX_C(1912856427))); + x1002 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(1912856427)))); + x1003 = (x992)*((uintptr_t)(UINTMAX_C(566625579))); + x1004 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(566625579)))); + x1005 = (x992)*((uintptr_t)(UINTMAX_C(1404826633))); + x1006 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(1404826633)))); + x1007 = (x992)*((uintptr_t)(UINTMAX_C(970277155))); + x1008 = _br2_mulhuu((x992), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x21), (x15)); + x1087 = (x21)*(x14); + x1088 = _br2_mulhuu((x21), (x14)); + x1089 = (x21)*(x13); + x1090 = _br2_mulhuu((x21), (x13)); + x1091 = (x21)*(x12); + x1092 = _br2_mulhuu((x21), (x12)); + x1093 = (x21)*(x11); + x1094 = _br2_mulhuu((x21), (x11)); + x1095 = (x21)*(x10); + x1096 = _br2_mulhuu((x21), (x10)); + x1097 = (x21)*(x9); + x1098 = _br2_mulhuu((x21), (x9)); + x1099 = (x21)*(x8); + x1100 = _br2_mulhuu((x21), (x8)); + 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)(UINTMAX_C(1916078453))); + x1177 = (x1176)*((uintptr_t)(UINTMAX_C(4294967294))); + x1178 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1179 = (x1176)*((uintptr_t)(UINTMAX_C(4294967295))); + x1180 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1181 = (x1176)*((uintptr_t)(UINTMAX_C(4294967295))); + x1182 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1183 = (x1176)*((uintptr_t)(UINTMAX_C(4294967295))); + x1184 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1185 = (x1176)*((uintptr_t)(UINTMAX_C(1912856427))); + x1186 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(1912856427)))); + x1187 = (x1176)*((uintptr_t)(UINTMAX_C(566625579))); + x1188 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(566625579)))); + x1189 = (x1176)*((uintptr_t)(UINTMAX_C(1404826633))); + x1190 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(1404826633)))); + x1191 = (x1176)*((uintptr_t)(UINTMAX_C(970277155))); + x1192 = _br2_mulhuu((x1176), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x22), (x15)); + x1271 = (x22)*(x14); + x1272 = _br2_mulhuu((x22), (x14)); + x1273 = (x22)*(x13); + x1274 = _br2_mulhuu((x22), (x13)); + x1275 = (x22)*(x12); + x1276 = _br2_mulhuu((x22), (x12)); + x1277 = (x22)*(x11); + x1278 = _br2_mulhuu((x22), (x11)); + x1279 = (x22)*(x10); + x1280 = _br2_mulhuu((x22), (x10)); + x1281 = (x22)*(x9); + x1282 = _br2_mulhuu((x22), (x9)); + x1283 = (x22)*(x8); + x1284 = _br2_mulhuu((x22), (x8)); + 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)(UINTMAX_C(1916078453))); + x1361 = (x1360)*((uintptr_t)(UINTMAX_C(4294967294))); + x1362 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1363 = (x1360)*((uintptr_t)(UINTMAX_C(4294967295))); + x1364 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1365 = (x1360)*((uintptr_t)(UINTMAX_C(4294967295))); + x1366 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1367 = (x1360)*((uintptr_t)(UINTMAX_C(4294967295))); + x1368 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1369 = (x1360)*((uintptr_t)(UINTMAX_C(1912856427))); + x1370 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(1912856427)))); + x1371 = (x1360)*((uintptr_t)(UINTMAX_C(566625579))); + x1372 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(566625579)))); + x1373 = (x1360)*((uintptr_t)(UINTMAX_C(1404826633))); + x1374 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(1404826633)))); + x1375 = (x1360)*((uintptr_t)(UINTMAX_C(970277155))); + x1376 = _br2_mulhuu((x1360), ((uintptr_t)(UINTMAX_C(970277155)))); + 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)(UINTMAX_C(970277155))); + x1454 = (uintptr_t)((x1414)<(x1453)); + x1455 = (x1419)-((uintptr_t)(UINTMAX_C(1404826633))); + x1456 = (uintptr_t)((x1419)<(x1455)); + x1457 = (x1455)-(x1454); + x1458 = (uintptr_t)((x1455)<(x1457)); + x1459 = (x1456)+(x1458); + x1460 = (x1424)-((uintptr_t)(UINTMAX_C(566625579))); + x1461 = (uintptr_t)((x1424)<(x1460)); + x1462 = (x1460)-(x1459); + x1463 = (uintptr_t)((x1460)<(x1462)); + x1464 = (x1461)+(x1463); + x1465 = (x1429)-((uintptr_t)(UINTMAX_C(1912856427))); + x1466 = (uintptr_t)((x1429)<(x1465)); + x1467 = (x1465)-(x1464); + x1468 = (uintptr_t)((x1465)<(x1467)); + x1469 = (x1466)+(x1468); + x1470 = (x1434)-((uintptr_t)(UINTMAX_C(4294967295))); + x1471 = (uintptr_t)((x1434)<(x1470)); + x1472 = (x1470)-(x1469); + x1473 = (uintptr_t)((x1470)<(x1472)); + x1474 = (x1471)+(x1473); + x1475 = (x1439)-((uintptr_t)(UINTMAX_C(4294967295))); + x1476 = (uintptr_t)((x1439)<(x1475)); + x1477 = (x1475)-(x1474); + x1478 = (uintptr_t)((x1475)<(x1477)); + x1479 = (x1476)+(x1478); + x1480 = (x1444)-((uintptr_t)(UINTMAX_C(4294967295))); + x1481 = (uintptr_t)((x1444)<(x1480)); + x1482 = (x1480)-(x1479); + x1483 = (uintptr_t)((x1480)<(x1482)); + x1484 = (x1481)+(x1483); + x1485 = (x1449)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1493 = (x1492)^((uintptr_t)(UINTMAX_C(4294967295))); + x1494 = ((x1414)&(x1492))|((x1453)&(x1493)); + x1495 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1496 = (x1495)^((uintptr_t)(UINTMAX_C(4294967295))); + x1497 = ((x1419)&(x1495))|((x1457)&(x1496)); + x1498 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1499 = (x1498)^((uintptr_t)(UINTMAX_C(4294967295))); + x1500 = ((x1424)&(x1498))|((x1462)&(x1499)); + x1501 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1502 = (x1501)^((uintptr_t)(UINTMAX_C(4294967295))); + x1503 = ((x1429)&(x1501))|((x1467)&(x1502)); + x1504 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1505 = (x1504)^((uintptr_t)(UINTMAX_C(4294967295))); + x1506 = ((x1434)&(x1504))|((x1472)&(x1505)); + x1507 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1508 = (x1507)^((uintptr_t)(UINTMAX_C(4294967295))); + x1509 = ((x1439)&(x1507))|((x1477)&(x1508)); + x1510 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1511 = (x1510)^((uintptr_t)(UINTMAX_C(4294967295))); + x1512 = ((x1444)&(x1510))|((x1482)&(x1511)); + x1513 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1491)==((uintptr_t)(UINTMAX_C(0))))); + x1514 = (x1513)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x1516, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1517, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1518, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x1519, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x1520, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x1521, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x1522, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x1523, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_mul(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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 = _br2_mulhuu((x15), (x7)); + x18 = (x15)*(x6); + x19 = _br2_mulhuu((x15), (x6)); + x20 = (x15)*(x5); + x21 = _br2_mulhuu((x15), (x5)); + x22 = (x15)*(x4); + x23 = _br2_mulhuu((x15), (x4)); + x24 = (x15)*(x3); + x25 = _br2_mulhuu((x15), (x3)); + x26 = (x15)*(x2); + x27 = _br2_mulhuu((x15), (x2)); + x28 = (x15)*(x1); + x29 = _br2_mulhuu((x15), (x1)); + x30 = (x15)*(x0); + x31 = _br2_mulhuu((x15), (x0)); + 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)(UINTMAX_C(1916078453))); + x66 = (x65)*((uintptr_t)(UINTMAX_C(4294967294))); + x67 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(4294967294)))); + x68 = (x65)*((uintptr_t)(UINTMAX_C(4294967295))); + x69 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(4294967295)))); + x70 = (x65)*((uintptr_t)(UINTMAX_C(4294967295))); + x71 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(4294967295)))); + x72 = (x65)*((uintptr_t)(UINTMAX_C(4294967295))); + x73 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(4294967295)))); + x74 = (x65)*((uintptr_t)(UINTMAX_C(1912856427))); + x75 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(1912856427)))); + x76 = (x65)*((uintptr_t)(UINTMAX_C(566625579))); + x77 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(566625579)))); + x78 = (x65)*((uintptr_t)(UINTMAX_C(1404826633))); + x79 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(1404826633)))); + x80 = (x65)*((uintptr_t)(UINTMAX_C(970277155))); + x81 = _br2_mulhuu((x65), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x8), (x7)); + x159 = (x8)*(x6); + x160 = _br2_mulhuu((x8), (x6)); + x161 = (x8)*(x5); + x162 = _br2_mulhuu((x8), (x5)); + x163 = (x8)*(x4); + x164 = _br2_mulhuu((x8), (x4)); + x165 = (x8)*(x3); + x166 = _br2_mulhuu((x8), (x3)); + x167 = (x8)*(x2); + x168 = _br2_mulhuu((x8), (x2)); + x169 = (x8)*(x1); + x170 = _br2_mulhuu((x8), (x1)); + x171 = (x8)*(x0); + x172 = _br2_mulhuu((x8), (x0)); + 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)(UINTMAX_C(1916078453))); + x249 = (x248)*((uintptr_t)(UINTMAX_C(4294967294))); + x250 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(4294967294)))); + x251 = (x248)*((uintptr_t)(UINTMAX_C(4294967295))); + x252 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(4294967295)))); + x253 = (x248)*((uintptr_t)(UINTMAX_C(4294967295))); + x254 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(4294967295)))); + x255 = (x248)*((uintptr_t)(UINTMAX_C(4294967295))); + x256 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(4294967295)))); + x257 = (x248)*((uintptr_t)(UINTMAX_C(1912856427))); + x258 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(1912856427)))); + x259 = (x248)*((uintptr_t)(UINTMAX_C(566625579))); + x260 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(566625579)))); + x261 = (x248)*((uintptr_t)(UINTMAX_C(1404826633))); + x262 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(1404826633)))); + x263 = (x248)*((uintptr_t)(UINTMAX_C(970277155))); + x264 = _br2_mulhuu((x248), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x9), (x7)); + x343 = (x9)*(x6); + x344 = _br2_mulhuu((x9), (x6)); + x345 = (x9)*(x5); + x346 = _br2_mulhuu((x9), (x5)); + x347 = (x9)*(x4); + x348 = _br2_mulhuu((x9), (x4)); + x349 = (x9)*(x3); + x350 = _br2_mulhuu((x9), (x3)); + x351 = (x9)*(x2); + x352 = _br2_mulhuu((x9), (x2)); + x353 = (x9)*(x1); + x354 = _br2_mulhuu((x9), (x1)); + x355 = (x9)*(x0); + x356 = _br2_mulhuu((x9), (x0)); + 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)(UINTMAX_C(1916078453))); + x433 = (x432)*((uintptr_t)(UINTMAX_C(4294967294))); + x434 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(4294967294)))); + x435 = (x432)*((uintptr_t)(UINTMAX_C(4294967295))); + x436 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(4294967295)))); + x437 = (x432)*((uintptr_t)(UINTMAX_C(4294967295))); + x438 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(4294967295)))); + x439 = (x432)*((uintptr_t)(UINTMAX_C(4294967295))); + x440 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(4294967295)))); + x441 = (x432)*((uintptr_t)(UINTMAX_C(1912856427))); + x442 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(1912856427)))); + x443 = (x432)*((uintptr_t)(UINTMAX_C(566625579))); + x444 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(566625579)))); + x445 = (x432)*((uintptr_t)(UINTMAX_C(1404826633))); + x446 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(1404826633)))); + x447 = (x432)*((uintptr_t)(UINTMAX_C(970277155))); + x448 = _br2_mulhuu((x432), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x10), (x7)); + x527 = (x10)*(x6); + x528 = _br2_mulhuu((x10), (x6)); + x529 = (x10)*(x5); + x530 = _br2_mulhuu((x10), (x5)); + x531 = (x10)*(x4); + x532 = _br2_mulhuu((x10), (x4)); + x533 = (x10)*(x3); + x534 = _br2_mulhuu((x10), (x3)); + x535 = (x10)*(x2); + x536 = _br2_mulhuu((x10), (x2)); + x537 = (x10)*(x1); + x538 = _br2_mulhuu((x10), (x1)); + x539 = (x10)*(x0); + x540 = _br2_mulhuu((x10), (x0)); + 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)(UINTMAX_C(1916078453))); + x617 = (x616)*((uintptr_t)(UINTMAX_C(4294967294))); + x618 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(4294967294)))); + x619 = (x616)*((uintptr_t)(UINTMAX_C(4294967295))); + x620 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(4294967295)))); + x621 = (x616)*((uintptr_t)(UINTMAX_C(4294967295))); + x622 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(4294967295)))); + x623 = (x616)*((uintptr_t)(UINTMAX_C(4294967295))); + x624 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(4294967295)))); + x625 = (x616)*((uintptr_t)(UINTMAX_C(1912856427))); + x626 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(1912856427)))); + x627 = (x616)*((uintptr_t)(UINTMAX_C(566625579))); + x628 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(566625579)))); + x629 = (x616)*((uintptr_t)(UINTMAX_C(1404826633))); + x630 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(1404826633)))); + x631 = (x616)*((uintptr_t)(UINTMAX_C(970277155))); + x632 = _br2_mulhuu((x616), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x11), (x7)); + x711 = (x11)*(x6); + x712 = _br2_mulhuu((x11), (x6)); + x713 = (x11)*(x5); + x714 = _br2_mulhuu((x11), (x5)); + x715 = (x11)*(x4); + x716 = _br2_mulhuu((x11), (x4)); + x717 = (x11)*(x3); + x718 = _br2_mulhuu((x11), (x3)); + x719 = (x11)*(x2); + x720 = _br2_mulhuu((x11), (x2)); + x721 = (x11)*(x1); + x722 = _br2_mulhuu((x11), (x1)); + x723 = (x11)*(x0); + x724 = _br2_mulhuu((x11), (x0)); + 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)(UINTMAX_C(1916078453))); + x801 = (x800)*((uintptr_t)(UINTMAX_C(4294967294))); + x802 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(4294967294)))); + x803 = (x800)*((uintptr_t)(UINTMAX_C(4294967295))); + x804 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(4294967295)))); + x805 = (x800)*((uintptr_t)(UINTMAX_C(4294967295))); + x806 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(4294967295)))); + x807 = (x800)*((uintptr_t)(UINTMAX_C(4294967295))); + x808 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(4294967295)))); + x809 = (x800)*((uintptr_t)(UINTMAX_C(1912856427))); + x810 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(1912856427)))); + x811 = (x800)*((uintptr_t)(UINTMAX_C(566625579))); + x812 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(566625579)))); + x813 = (x800)*((uintptr_t)(UINTMAX_C(1404826633))); + x814 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(1404826633)))); + x815 = (x800)*((uintptr_t)(UINTMAX_C(970277155))); + x816 = _br2_mulhuu((x800), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x12), (x7)); + x895 = (x12)*(x6); + x896 = _br2_mulhuu((x12), (x6)); + x897 = (x12)*(x5); + x898 = _br2_mulhuu((x12), (x5)); + x899 = (x12)*(x4); + x900 = _br2_mulhuu((x12), (x4)); + x901 = (x12)*(x3); + x902 = _br2_mulhuu((x12), (x3)); + x903 = (x12)*(x2); + x904 = _br2_mulhuu((x12), (x2)); + x905 = (x12)*(x1); + x906 = _br2_mulhuu((x12), (x1)); + x907 = (x12)*(x0); + x908 = _br2_mulhuu((x12), (x0)); + 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)(UINTMAX_C(1916078453))); + x985 = (x984)*((uintptr_t)(UINTMAX_C(4294967294))); + x986 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(4294967294)))); + x987 = (x984)*((uintptr_t)(UINTMAX_C(4294967295))); + x988 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(4294967295)))); + x989 = (x984)*((uintptr_t)(UINTMAX_C(4294967295))); + x990 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(4294967295)))); + x991 = (x984)*((uintptr_t)(UINTMAX_C(4294967295))); + x992 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(4294967295)))); + x993 = (x984)*((uintptr_t)(UINTMAX_C(1912856427))); + x994 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(1912856427)))); + x995 = (x984)*((uintptr_t)(UINTMAX_C(566625579))); + x996 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(566625579)))); + x997 = (x984)*((uintptr_t)(UINTMAX_C(1404826633))); + x998 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(1404826633)))); + x999 = (x984)*((uintptr_t)(UINTMAX_C(970277155))); + x1000 = _br2_mulhuu((x984), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x13), (x7)); + x1079 = (x13)*(x6); + x1080 = _br2_mulhuu((x13), (x6)); + x1081 = (x13)*(x5); + x1082 = _br2_mulhuu((x13), (x5)); + x1083 = (x13)*(x4); + x1084 = _br2_mulhuu((x13), (x4)); + x1085 = (x13)*(x3); + x1086 = _br2_mulhuu((x13), (x3)); + x1087 = (x13)*(x2); + x1088 = _br2_mulhuu((x13), (x2)); + x1089 = (x13)*(x1); + x1090 = _br2_mulhuu((x13), (x1)); + x1091 = (x13)*(x0); + x1092 = _br2_mulhuu((x13), (x0)); + 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)(UINTMAX_C(1916078453))); + x1169 = (x1168)*((uintptr_t)(UINTMAX_C(4294967294))); + x1170 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1171 = (x1168)*((uintptr_t)(UINTMAX_C(4294967295))); + x1172 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1173 = (x1168)*((uintptr_t)(UINTMAX_C(4294967295))); + x1174 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1175 = (x1168)*((uintptr_t)(UINTMAX_C(4294967295))); + x1176 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1177 = (x1168)*((uintptr_t)(UINTMAX_C(1912856427))); + x1178 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(1912856427)))); + x1179 = (x1168)*((uintptr_t)(UINTMAX_C(566625579))); + x1180 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(566625579)))); + x1181 = (x1168)*((uintptr_t)(UINTMAX_C(1404826633))); + x1182 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(1404826633)))); + x1183 = (x1168)*((uintptr_t)(UINTMAX_C(970277155))); + x1184 = _br2_mulhuu((x1168), ((uintptr_t)(UINTMAX_C(970277155)))); + 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 = _br2_mulhuu((x14), (x7)); + x1263 = (x14)*(x6); + x1264 = _br2_mulhuu((x14), (x6)); + x1265 = (x14)*(x5); + x1266 = _br2_mulhuu((x14), (x5)); + x1267 = (x14)*(x4); + x1268 = _br2_mulhuu((x14), (x4)); + x1269 = (x14)*(x3); + x1270 = _br2_mulhuu((x14), (x3)); + x1271 = (x14)*(x2); + x1272 = _br2_mulhuu((x14), (x2)); + x1273 = (x14)*(x1); + x1274 = _br2_mulhuu((x14), (x1)); + x1275 = (x14)*(x0); + x1276 = _br2_mulhuu((x14), (x0)); + 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)(UINTMAX_C(1916078453))); + x1353 = (x1352)*((uintptr_t)(UINTMAX_C(4294967294))); + x1354 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(4294967294)))); + x1355 = (x1352)*((uintptr_t)(UINTMAX_C(4294967295))); + x1356 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1357 = (x1352)*((uintptr_t)(UINTMAX_C(4294967295))); + x1358 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1359 = (x1352)*((uintptr_t)(UINTMAX_C(4294967295))); + x1360 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(4294967295)))); + x1361 = (x1352)*((uintptr_t)(UINTMAX_C(1912856427))); + x1362 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(1912856427)))); + x1363 = (x1352)*((uintptr_t)(UINTMAX_C(566625579))); + x1364 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(566625579)))); + x1365 = (x1352)*((uintptr_t)(UINTMAX_C(1404826633))); + x1366 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(1404826633)))); + x1367 = (x1352)*((uintptr_t)(UINTMAX_C(970277155))); + x1368 = _br2_mulhuu((x1352), ((uintptr_t)(UINTMAX_C(970277155)))); + 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)(UINTMAX_C(970277155))); + x1446 = (uintptr_t)((x1406)<(x1445)); + x1447 = (x1411)-((uintptr_t)(UINTMAX_C(1404826633))); + x1448 = (uintptr_t)((x1411)<(x1447)); + x1449 = (x1447)-(x1446); + x1450 = (uintptr_t)((x1447)<(x1449)); + x1451 = (x1448)+(x1450); + x1452 = (x1416)-((uintptr_t)(UINTMAX_C(566625579))); + x1453 = (uintptr_t)((x1416)<(x1452)); + x1454 = (x1452)-(x1451); + x1455 = (uintptr_t)((x1452)<(x1454)); + x1456 = (x1453)+(x1455); + x1457 = (x1421)-((uintptr_t)(UINTMAX_C(1912856427))); + x1458 = (uintptr_t)((x1421)<(x1457)); + x1459 = (x1457)-(x1456); + x1460 = (uintptr_t)((x1457)<(x1459)); + x1461 = (x1458)+(x1460); + x1462 = (x1426)-((uintptr_t)(UINTMAX_C(4294967295))); + x1463 = (uintptr_t)((x1426)<(x1462)); + x1464 = (x1462)-(x1461); + x1465 = (uintptr_t)((x1462)<(x1464)); + x1466 = (x1463)+(x1465); + x1467 = (x1431)-((uintptr_t)(UINTMAX_C(4294967295))); + x1468 = (uintptr_t)((x1431)<(x1467)); + x1469 = (x1467)-(x1466); + x1470 = (uintptr_t)((x1467)<(x1469)); + x1471 = (x1468)+(x1470); + x1472 = (x1436)-((uintptr_t)(UINTMAX_C(4294967295))); + x1473 = (uintptr_t)((x1436)<(x1472)); + x1474 = (x1472)-(x1471); + x1475 = (uintptr_t)((x1472)<(x1474)); + x1476 = (x1473)+(x1475); + x1477 = (x1441)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1485 = (x1484)^((uintptr_t)(UINTMAX_C(4294967295))); + x1486 = ((x1406)&(x1484))|((x1445)&(x1485)); + x1487 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1488 = (x1487)^((uintptr_t)(UINTMAX_C(4294967295))); + x1489 = ((x1411)&(x1487))|((x1449)&(x1488)); + x1490 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1491 = (x1490)^((uintptr_t)(UINTMAX_C(4294967295))); + x1492 = ((x1416)&(x1490))|((x1454)&(x1491)); + x1493 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1494 = (x1493)^((uintptr_t)(UINTMAX_C(4294967295))); + x1495 = ((x1421)&(x1493))|((x1459)&(x1494)); + x1496 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1497 = (x1496)^((uintptr_t)(UINTMAX_C(4294967295))); + x1498 = ((x1426)&(x1496))|((x1464)&(x1497)); + x1499 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1500 = (x1499)^((uintptr_t)(UINTMAX_C(4294967295))); + x1501 = ((x1431)&(x1499))|((x1469)&(x1500)); + x1502 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1503 = (x1502)^((uintptr_t)(UINTMAX_C(4294967295))); + x1504 = ((x1436)&(x1502))|((x1474)&(x1503)); + x1505 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x1483)==((uintptr_t)(UINTMAX_C(0))))); + x1506 = (x1505)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x1508, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1509, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1510, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x1511, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x1512, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x1513, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x1514, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x1515, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_square(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(970277155))); + x33 = (x18)-((uintptr_t)(UINTMAX_C(1404826633))); + x34 = (x33)-((uintptr_t)((x16)<(x32))); + x35 = (x20)-((uintptr_t)(UINTMAX_C(566625579))); + x36 = (x35)-(((uintptr_t)((x18)<(x33)))+((uintptr_t)((x33)<(x34)))); + x37 = (x22)-((uintptr_t)(UINTMAX_C(1912856427))); + x38 = (x37)-(((uintptr_t)((x20)<(x35)))+((uintptr_t)((x35)<(x36)))); + x39 = (x24)-((uintptr_t)(UINTMAX_C(4294967295))); + x40 = (x39)-(((uintptr_t)((x22)<(x37)))+((uintptr_t)((x37)<(x38)))); + x41 = (x26)-((uintptr_t)(UINTMAX_C(4294967295))); + x42 = (x41)-(((uintptr_t)((x24)<(x39)))+((uintptr_t)((x39)<(x40)))); + x43 = (x28)-((uintptr_t)(UINTMAX_C(4294967295))); + x44 = (x43)-(((uintptr_t)((x26)<(x41)))+((uintptr_t)((x41)<(x42)))); + x45 = (x30)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x49 = (x48)^((uintptr_t)(UINTMAX_C(4294967295))); + x50 = ((x16)&(x48))|((x32)&(x49)); + x51 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x52 = (x51)^((uintptr_t)(UINTMAX_C(4294967295))); + x53 = ((x18)&(x51))|((x34)&(x52)); + x54 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x55 = (x54)^((uintptr_t)(UINTMAX_C(4294967295))); + x56 = ((x20)&(x54))|((x36)&(x55)); + x57 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x58 = (x57)^((uintptr_t)(UINTMAX_C(4294967295))); + x59 = ((x22)&(x57))|((x38)&(x58)); + x60 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x61 = (x60)^((uintptr_t)(UINTMAX_C(4294967295))); + x62 = ((x24)&(x60))|((x40)&(x61)); + x63 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x64 = (x63)^((uintptr_t)(UINTMAX_C(4294967295))); + x65 = ((x26)&(x63))|((x42)&(x64)); + x66 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x67 = (x66)^((uintptr_t)(UINTMAX_C(4294967295))); + x68 = ((x28)&(x66))|((x44)&(x67)); + x69 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x47)==((uintptr_t)(UINTMAX_C(0))))); + x70 = (x69)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x72, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x73, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x74, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x75, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x76, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x77, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x78, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x79, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_add(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)((x7)<(x29)))+((uintptr_t)((x29)<(x30))))==((uintptr_t)(UINTMAX_C(0))))); + x32 = (x16)+((x31)&((uintptr_t)(UINTMAX_C(970277155)))); + x33 = ((uintptr_t)((x32)<(x16)))+(x18); + x34 = (x33)+((x31)&((uintptr_t)(UINTMAX_C(1404826633)))); + x35 = (((uintptr_t)((x33)<(x18)))+((uintptr_t)((x34)<((x31)&((uintptr_t)(UINTMAX_C(1404826633)))))))+(x20); + x36 = (x35)+((x31)&((uintptr_t)(UINTMAX_C(566625579)))); + x37 = (((uintptr_t)((x35)<(x20)))+((uintptr_t)((x36)<((x31)&((uintptr_t)(UINTMAX_C(566625579)))))))+(x22); + x38 = (x37)+((x31)&((uintptr_t)(UINTMAX_C(1912856427)))); + x39 = (((uintptr_t)((x37)<(x22)))+((uintptr_t)((x38)<((x31)&((uintptr_t)(UINTMAX_C(1912856427)))))))+(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 = (x43)+(x31); + x45 = ((((uintptr_t)((x43)<(x28)))+((uintptr_t)((x44)<(x31))))+(x30))+((x31)&((uintptr_t)(UINTMAX_C(4294967294)))); + x46 = x32; + x47 = x34; + x48 = x36; + x49 = x38; + x50 = x40; + x51 = x42; + x52 = x44; + x53 = x45; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x47, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x48, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x49, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x50, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x51, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x52, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x53, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_sub(uint32_t out1[8], const uint32_t arg1[8], const uint32_t arg2[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)(UINTMAX_C(0)))-(x0); + x9 = ((uintptr_t)(UINTMAX_C(0)))-(x1); + x10 = (x9)-((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x8))); + x11 = ((uintptr_t)(UINTMAX_C(0)))-(x2); + x12 = (x11)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x9)))+((uintptr_t)((x9)<(x10)))); + x13 = ((uintptr_t)(UINTMAX_C(0)))-(x3); + x14 = (x13)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x11)))+((uintptr_t)((x11)<(x12)))); + x15 = ((uintptr_t)(UINTMAX_C(0)))-(x4); + x16 = (x15)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x13)))+((uintptr_t)((x13)<(x14)))); + x17 = ((uintptr_t)(UINTMAX_C(0)))-(x5); + x18 = (x17)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x15)))+((uintptr_t)((x15)<(x16)))); + x19 = ((uintptr_t)(UINTMAX_C(0)))-(x6); + x20 = (x19)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = ((uintptr_t)(UINTMAX_C(0)))-(x7); + x22 = (x21)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x19)))+((uintptr_t)((x19)<(x20)))); + x23 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)(UINTMAX_C(0))))); + x24 = (x8)+((x23)&((uintptr_t)(UINTMAX_C(970277155)))); + x25 = ((uintptr_t)((x24)<(x8)))+(x10); + x26 = (x25)+((x23)&((uintptr_t)(UINTMAX_C(1404826633)))); + x27 = (((uintptr_t)((x25)<(x10)))+((uintptr_t)((x26)<((x23)&((uintptr_t)(UINTMAX_C(1404826633)))))))+(x12); + x28 = (x27)+((x23)&((uintptr_t)(UINTMAX_C(566625579)))); + x29 = (((uintptr_t)((x27)<(x12)))+((uintptr_t)((x28)<((x23)&((uintptr_t)(UINTMAX_C(566625579)))))))+(x14); + x30 = (x29)+((x23)&((uintptr_t)(UINTMAX_C(1912856427)))); + x31 = (((uintptr_t)((x29)<(x14)))+((uintptr_t)((x30)<((x23)&((uintptr_t)(UINTMAX_C(1912856427)))))))+(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 = (x35)+(x23); + x37 = ((((uintptr_t)((x35)<(x20)))+((uintptr_t)((x36)<(x23))))+(x22))+((x23)&((uintptr_t)(UINTMAX_C(4294967294)))); + x38 = x24; + x39 = x26; + x40 = x28; + x41 = x30; + x42 = x32; + x43 = x34; + x44 = x36; + x45 = x37; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x39, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x45, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_opp(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_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, x1, x38, x39, x40, x41, x42, x43, x44, x45, x37, x11, x69, x71, x68, x66, x73, x67, x64, x75, x65, x62, x77, x63, x60, x79, x61, x58, x81, x59, x56, x55, x46, x84, x47, x70, x86, x48, x72, x88, x49, x74, x90, x50, x76, x92, x51, x78, x94, x52, x80, x96, x53, x82, x98, x54, x83, x57, x2, x85, x87, x89, x91, x93, x95, x97, x99, x124, x126, x123, x121, x128, x122, x119, x130, x120, x117, x132, x118, x115, x134, x116, x113, x136, x114, x111, x110, x101, x139, x102, x125, x141, x103, x127, x143, x104, x129, x145, x105, x131, x147, x106, x133, x149, x107, x135, x151, x108, x137, x153, x109, x100, x138, x112, x3, x140, x142, x144, x146, x148, x150, x152, x154, x179, x181, x178, x176, x183, x177, x174, x185, x175, x172, x187, x173, x170, x189, x171, x168, x191, x169, x166, x165, x156, x194, x157, x180, x196, x158, x182, x198, x159, x184, x200, x160, x186, x202, x161, x188, x204, x162, x190, x206, x163, x192, x208, x164, x155, x193, x167, x4, x195, x197, x199, x201, x203, x205, x207, x209, x234, x236, x233, x231, x238, x232, x229, x240, x230, x227, x242, x228, x225, x244, x226, x223, x246, x224, x221, x220, x211, x249, x212, x235, x251, x213, x237, x253, x214, x239, x255, x215, x241, x257, x216, x243, x259, x217, x245, x261, x218, x247, x263, x219, x210, x248, x222, x5, x250, x252, x254, x256, x258, x260, x262, x264, x289, x291, x288, x286, x293, x287, x284, x295, x285, x282, x297, x283, x280, x299, x281, x278, x301, x279, x276, x275, x266, x304, x267, x290, x306, x268, x292, x308, x269, x294, x310, x270, x296, x312, x271, x298, x314, x272, x300, x316, x273, x302, x318, x274, x265, x303, x277, x6, x305, x307, x309, x311, x313, x315, x317, x319, x344, x346, x343, x341, x348, x342, x339, x350, x340, x337, x352, x338, x335, x354, x336, x333, x356, x334, x331, x330, x321, x359, x322, x345, x361, x323, x347, x363, x324, x349, x365, x325, x351, x367, x326, x353, x369, x327, x355, x371, x328, x357, x373, x329, x320, x358, x332, x7, x360, x362, x364, x366, x368, x370, x372, x374, x399, x401, x398, x396, x403, x397, x394, x405, x395, x392, x407, x393, x390, x409, x391, x388, x411, x389, x386, x385, x376, x414, x377, x400, x416, x378, x402, x418, x379, x404, x420, x380, x406, x422, x381, x408, x424, x382, x410, x426, x383, x412, x428, x384, x375, x413, x387, x432, x434, x436, x438, x440, x442, x430, x444, x415, x447, x431, x448, x417, x450, x433, x451, x419, x453, x435, x454, x421, x456, x437, x457, x423, x459, x439, x460, x425, x462, x441, x463, x427, x465, x443, x466, x446, x429, x468, x445, x469, x449, x452, x455, x458, x461, x464, x467, x470, x471, x472, x473, x474, x475, x476, x477, x478; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x0; + x9 = (x8)*((uintptr_t)(UINTMAX_C(1916078453))); + x10 = (x9)*((uintptr_t)(UINTMAX_C(4294967294))); + x11 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(4294967294)))); + x12 = (x9)*((uintptr_t)(UINTMAX_C(4294967295))); + x13 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(4294967295)))); + x14 = (x9)*((uintptr_t)(UINTMAX_C(4294967295))); + x15 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(4294967295)))); + x16 = (x9)*((uintptr_t)(UINTMAX_C(4294967295))); + x17 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(4294967295)))); + x18 = (x9)*((uintptr_t)(UINTMAX_C(1912856427))); + x19 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(1912856427)))); + x20 = (x9)*((uintptr_t)(UINTMAX_C(566625579))); + x21 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(566625579)))); + x22 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(1404826633)))); + x23 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(970277155)))); + x24 = (x23)+((x9)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)); + x46 = (x38)+(x1); + x47 = ((uintptr_t)((x46)<(x38)))+(x39); + x48 = ((uintptr_t)((x47)<(x39)))+(x40); + x49 = ((uintptr_t)((x48)<(x40)))+(x41); + x50 = ((uintptr_t)((x49)<(x41)))+(x42); + x51 = ((uintptr_t)((x50)<(x42)))+(x43); + x52 = ((uintptr_t)((x51)<(x43)))+(x44); + x53 = ((uintptr_t)((x52)<(x44)))+((x45)+((x37)+(x11))); + x54 = (uintptr_t)((x53)<((x45)+((x37)+(x11)))); + x55 = (x46)*((uintptr_t)(UINTMAX_C(1916078453))); + x56 = (x55)*((uintptr_t)(UINTMAX_C(4294967294))); + x57 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(4294967294)))); + x58 = (x55)*((uintptr_t)(UINTMAX_C(4294967295))); + x59 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(4294967295)))); + x60 = (x55)*((uintptr_t)(UINTMAX_C(4294967295))); + x61 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(4294967295)))); + x62 = (x55)*((uintptr_t)(UINTMAX_C(4294967295))); + x63 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(4294967295)))); + x64 = (x55)*((uintptr_t)(UINTMAX_C(1912856427))); + x65 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(1912856427)))); + x66 = (x55)*((uintptr_t)(UINTMAX_C(566625579))); + x67 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(566625579)))); + x68 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(1404826633)))); + x69 = _br2_mulhuu((x55), ((uintptr_t)(UINTMAX_C(970277155)))); + x70 = (x69)+((x55)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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))))+(x65); + x76 = (x75)+(x62); + x77 = (((uintptr_t)((x75)<(x65)))+((uintptr_t)((x76)<(x62))))+(x63); + x78 = (x77)+(x60); + x79 = (((uintptr_t)((x77)<(x63)))+((uintptr_t)((x78)<(x60))))+(x61); + x80 = (x79)+(x58); + x81 = (((uintptr_t)((x79)<(x61)))+((uintptr_t)((x80)<(x58))))+(x59); + x82 = (x81)+(x56); + x83 = ((uintptr_t)((x81)<(x59)))+((uintptr_t)((x82)<(x56))); + x84 = ((uintptr_t)(((x46)+((x55)*((uintptr_t)(UINTMAX_C(970277155)))))<(x46)))+(x47); + x85 = (x84)+(x70); + x86 = (((uintptr_t)((x84)<(x47)))+((uintptr_t)((x85)<(x70))))+(x48); + x87 = (x86)+(x72); + x88 = (((uintptr_t)((x86)<(x48)))+((uintptr_t)((x87)<(x72))))+(x49); + x89 = (x88)+(x74); + x90 = (((uintptr_t)((x88)<(x49)))+((uintptr_t)((x89)<(x74))))+(x50); + x91 = (x90)+(x76); + x92 = (((uintptr_t)((x90)<(x50)))+((uintptr_t)((x91)<(x76))))+(x51); + x93 = (x92)+(x78); + x94 = (((uintptr_t)((x92)<(x51)))+((uintptr_t)((x93)<(x78))))+(x52); + x95 = (x94)+(x80); + x96 = (((uintptr_t)((x94)<(x52)))+((uintptr_t)((x95)<(x80))))+(x53); + x97 = (x96)+(x82); + x98 = (((uintptr_t)((x96)<(x53)))+((uintptr_t)((x97)<(x82))))+(x54); + x99 = (x98)+((x83)+(x57)); + x100 = ((uintptr_t)((x98)<(x54)))+((uintptr_t)((x99)<((x83)+(x57)))); + x101 = (x85)+(x2); + x102 = ((uintptr_t)((x101)<(x85)))+(x87); + x103 = ((uintptr_t)((x102)<(x87)))+(x89); + x104 = ((uintptr_t)((x103)<(x89)))+(x91); + x105 = ((uintptr_t)((x104)<(x91)))+(x93); + x106 = ((uintptr_t)((x105)<(x93)))+(x95); + x107 = ((uintptr_t)((x106)<(x95)))+(x97); + x108 = ((uintptr_t)((x107)<(x97)))+(x99); + x109 = (uintptr_t)((x108)<(x99)); + x110 = (x101)*((uintptr_t)(UINTMAX_C(1916078453))); + x111 = (x110)*((uintptr_t)(UINTMAX_C(4294967294))); + x112 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(4294967294)))); + x113 = (x110)*((uintptr_t)(UINTMAX_C(4294967295))); + x114 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(4294967295)))); + x115 = (x110)*((uintptr_t)(UINTMAX_C(4294967295))); + x116 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(4294967295)))); + x117 = (x110)*((uintptr_t)(UINTMAX_C(4294967295))); + x118 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(4294967295)))); + x119 = (x110)*((uintptr_t)(UINTMAX_C(1912856427))); + x120 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(1912856427)))); + x121 = (x110)*((uintptr_t)(UINTMAX_C(566625579))); + x122 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(566625579)))); + x123 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(1404826633)))); + x124 = _br2_mulhuu((x110), ((uintptr_t)(UINTMAX_C(970277155)))); + x125 = (x124)+((x110)*((uintptr_t)(UINTMAX_C(1404826633)))); + x126 = ((uintptr_t)((x125)<(x124)))+(x123); + x127 = (x126)+(x121); + x128 = (((uintptr_t)((x126)<(x123)))+((uintptr_t)((x127)<(x121))))+(x122); + x129 = (x128)+(x119); + x130 = (((uintptr_t)((x128)<(x122)))+((uintptr_t)((x129)<(x119))))+(x120); + x131 = (x130)+(x117); + x132 = (((uintptr_t)((x130)<(x120)))+((uintptr_t)((x131)<(x117))))+(x118); + x133 = (x132)+(x115); + x134 = (((uintptr_t)((x132)<(x118)))+((uintptr_t)((x133)<(x115))))+(x116); + x135 = (x134)+(x113); + x136 = (((uintptr_t)((x134)<(x116)))+((uintptr_t)((x135)<(x113))))+(x114); + x137 = (x136)+(x111); + x138 = ((uintptr_t)((x136)<(x114)))+((uintptr_t)((x137)<(x111))); + x139 = ((uintptr_t)(((x101)+((x110)*((uintptr_t)(UINTMAX_C(970277155)))))<(x101)))+(x102); + x140 = (x139)+(x125); + x141 = (((uintptr_t)((x139)<(x102)))+((uintptr_t)((x140)<(x125))))+(x103); + x142 = (x141)+(x127); + x143 = (((uintptr_t)((x141)<(x103)))+((uintptr_t)((x142)<(x127))))+(x104); + x144 = (x143)+(x129); + x145 = (((uintptr_t)((x143)<(x104)))+((uintptr_t)((x144)<(x129))))+(x105); + x146 = (x145)+(x131); + x147 = (((uintptr_t)((x145)<(x105)))+((uintptr_t)((x146)<(x131))))+(x106); + x148 = (x147)+(x133); + x149 = (((uintptr_t)((x147)<(x106)))+((uintptr_t)((x148)<(x133))))+(x107); + x150 = (x149)+(x135); + x151 = (((uintptr_t)((x149)<(x107)))+((uintptr_t)((x150)<(x135))))+(x108); + x152 = (x151)+(x137); + x153 = (((uintptr_t)((x151)<(x108)))+((uintptr_t)((x152)<(x137))))+((x109)+(x100)); + x154 = (x153)+((x138)+(x112)); + x155 = ((uintptr_t)((x153)<((x109)+(x100))))+((uintptr_t)((x154)<((x138)+(x112)))); + x156 = (x140)+(x3); + x157 = ((uintptr_t)((x156)<(x140)))+(x142); + x158 = ((uintptr_t)((x157)<(x142)))+(x144); + x159 = ((uintptr_t)((x158)<(x144)))+(x146); + x160 = ((uintptr_t)((x159)<(x146)))+(x148); + x161 = ((uintptr_t)((x160)<(x148)))+(x150); + x162 = ((uintptr_t)((x161)<(x150)))+(x152); + x163 = ((uintptr_t)((x162)<(x152)))+(x154); + x164 = (uintptr_t)((x163)<(x154)); + x165 = (x156)*((uintptr_t)(UINTMAX_C(1916078453))); + x166 = (x165)*((uintptr_t)(UINTMAX_C(4294967294))); + x167 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(4294967294)))); + x168 = (x165)*((uintptr_t)(UINTMAX_C(4294967295))); + x169 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(4294967295)))); + x170 = (x165)*((uintptr_t)(UINTMAX_C(4294967295))); + x171 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(4294967295)))); + x172 = (x165)*((uintptr_t)(UINTMAX_C(4294967295))); + x173 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(4294967295)))); + x174 = (x165)*((uintptr_t)(UINTMAX_C(1912856427))); + x175 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(1912856427)))); + x176 = (x165)*((uintptr_t)(UINTMAX_C(566625579))); + x177 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(566625579)))); + x178 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(1404826633)))); + x179 = _br2_mulhuu((x165), ((uintptr_t)(UINTMAX_C(970277155)))); + x180 = (x179)+((x165)*((uintptr_t)(UINTMAX_C(1404826633)))); + x181 = ((uintptr_t)((x180)<(x179)))+(x178); + x182 = (x181)+(x176); + x183 = (((uintptr_t)((x181)<(x178)))+((uintptr_t)((x182)<(x176))))+(x177); + x184 = (x183)+(x174); + x185 = (((uintptr_t)((x183)<(x177)))+((uintptr_t)((x184)<(x174))))+(x175); + x186 = (x185)+(x172); + x187 = (((uintptr_t)((x185)<(x175)))+((uintptr_t)((x186)<(x172))))+(x173); + x188 = (x187)+(x170); + x189 = (((uintptr_t)((x187)<(x173)))+((uintptr_t)((x188)<(x170))))+(x171); + x190 = (x189)+(x168); + x191 = (((uintptr_t)((x189)<(x171)))+((uintptr_t)((x190)<(x168))))+(x169); + x192 = (x191)+(x166); + x193 = ((uintptr_t)((x191)<(x169)))+((uintptr_t)((x192)<(x166))); + x194 = ((uintptr_t)(((x156)+((x165)*((uintptr_t)(UINTMAX_C(970277155)))))<(x156)))+(x157); + x195 = (x194)+(x180); + x196 = (((uintptr_t)((x194)<(x157)))+((uintptr_t)((x195)<(x180))))+(x158); + x197 = (x196)+(x182); + x198 = (((uintptr_t)((x196)<(x158)))+((uintptr_t)((x197)<(x182))))+(x159); + x199 = (x198)+(x184); + x200 = (((uintptr_t)((x198)<(x159)))+((uintptr_t)((x199)<(x184))))+(x160); + x201 = (x200)+(x186); + x202 = (((uintptr_t)((x200)<(x160)))+((uintptr_t)((x201)<(x186))))+(x161); + x203 = (x202)+(x188); + x204 = (((uintptr_t)((x202)<(x161)))+((uintptr_t)((x203)<(x188))))+(x162); + x205 = (x204)+(x190); + x206 = (((uintptr_t)((x204)<(x162)))+((uintptr_t)((x205)<(x190))))+(x163); + x207 = (x206)+(x192); + x208 = (((uintptr_t)((x206)<(x163)))+((uintptr_t)((x207)<(x192))))+((x164)+(x155)); + x209 = (x208)+((x193)+(x167)); + x210 = ((uintptr_t)((x208)<((x164)+(x155))))+((uintptr_t)((x209)<((x193)+(x167)))); + x211 = (x195)+(x4); + x212 = ((uintptr_t)((x211)<(x195)))+(x197); + x213 = ((uintptr_t)((x212)<(x197)))+(x199); + x214 = ((uintptr_t)((x213)<(x199)))+(x201); + x215 = ((uintptr_t)((x214)<(x201)))+(x203); + x216 = ((uintptr_t)((x215)<(x203)))+(x205); + x217 = ((uintptr_t)((x216)<(x205)))+(x207); + x218 = ((uintptr_t)((x217)<(x207)))+(x209); + x219 = (uintptr_t)((x218)<(x209)); + x220 = (x211)*((uintptr_t)(UINTMAX_C(1916078453))); + x221 = (x220)*((uintptr_t)(UINTMAX_C(4294967294))); + x222 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(4294967294)))); + x223 = (x220)*((uintptr_t)(UINTMAX_C(4294967295))); + x224 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(4294967295)))); + x225 = (x220)*((uintptr_t)(UINTMAX_C(4294967295))); + x226 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(4294967295)))); + x227 = (x220)*((uintptr_t)(UINTMAX_C(4294967295))); + x228 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(4294967295)))); + x229 = (x220)*((uintptr_t)(UINTMAX_C(1912856427))); + x230 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(1912856427)))); + x231 = (x220)*((uintptr_t)(UINTMAX_C(566625579))); + x232 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(566625579)))); + x233 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(1404826633)))); + x234 = _br2_mulhuu((x220), ((uintptr_t)(UINTMAX_C(970277155)))); + x235 = (x234)+((x220)*((uintptr_t)(UINTMAX_C(1404826633)))); + x236 = ((uintptr_t)((x235)<(x234)))+(x233); + x237 = (x236)+(x231); + x238 = (((uintptr_t)((x236)<(x233)))+((uintptr_t)((x237)<(x231))))+(x232); + x239 = (x238)+(x229); + x240 = (((uintptr_t)((x238)<(x232)))+((uintptr_t)((x239)<(x229))))+(x230); + x241 = (x240)+(x227); + x242 = (((uintptr_t)((x240)<(x230)))+((uintptr_t)((x241)<(x227))))+(x228); + x243 = (x242)+(x225); + x244 = (((uintptr_t)((x242)<(x228)))+((uintptr_t)((x243)<(x225))))+(x226); + x245 = (x244)+(x223); + x246 = (((uintptr_t)((x244)<(x226)))+((uintptr_t)((x245)<(x223))))+(x224); + x247 = (x246)+(x221); + x248 = ((uintptr_t)((x246)<(x224)))+((uintptr_t)((x247)<(x221))); + x249 = ((uintptr_t)(((x211)+((x220)*((uintptr_t)(UINTMAX_C(970277155)))))<(x211)))+(x212); + x250 = (x249)+(x235); + x251 = (((uintptr_t)((x249)<(x212)))+((uintptr_t)((x250)<(x235))))+(x213); + x252 = (x251)+(x237); + x253 = (((uintptr_t)((x251)<(x213)))+((uintptr_t)((x252)<(x237))))+(x214); + x254 = (x253)+(x239); + x255 = (((uintptr_t)((x253)<(x214)))+((uintptr_t)((x254)<(x239))))+(x215); + x256 = (x255)+(x241); + x257 = (((uintptr_t)((x255)<(x215)))+((uintptr_t)((x256)<(x241))))+(x216); + x258 = (x257)+(x243); + x259 = (((uintptr_t)((x257)<(x216)))+((uintptr_t)((x258)<(x243))))+(x217); + x260 = (x259)+(x245); + x261 = (((uintptr_t)((x259)<(x217)))+((uintptr_t)((x260)<(x245))))+(x218); + x262 = (x261)+(x247); + x263 = (((uintptr_t)((x261)<(x218)))+((uintptr_t)((x262)<(x247))))+((x219)+(x210)); + x264 = (x263)+((x248)+(x222)); + x265 = ((uintptr_t)((x263)<((x219)+(x210))))+((uintptr_t)((x264)<((x248)+(x222)))); + x266 = (x250)+(x5); + x267 = ((uintptr_t)((x266)<(x250)))+(x252); + x268 = ((uintptr_t)((x267)<(x252)))+(x254); + x269 = ((uintptr_t)((x268)<(x254)))+(x256); + x270 = ((uintptr_t)((x269)<(x256)))+(x258); + x271 = ((uintptr_t)((x270)<(x258)))+(x260); + x272 = ((uintptr_t)((x271)<(x260)))+(x262); + x273 = ((uintptr_t)((x272)<(x262)))+(x264); + x274 = (uintptr_t)((x273)<(x264)); + x275 = (x266)*((uintptr_t)(UINTMAX_C(1916078453))); + x276 = (x275)*((uintptr_t)(UINTMAX_C(4294967294))); + x277 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(4294967294)))); + x278 = (x275)*((uintptr_t)(UINTMAX_C(4294967295))); + x279 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(4294967295)))); + x280 = (x275)*((uintptr_t)(UINTMAX_C(4294967295))); + x281 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(4294967295)))); + x282 = (x275)*((uintptr_t)(UINTMAX_C(4294967295))); + x283 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(4294967295)))); + x284 = (x275)*((uintptr_t)(UINTMAX_C(1912856427))); + x285 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(1912856427)))); + x286 = (x275)*((uintptr_t)(UINTMAX_C(566625579))); + x287 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(566625579)))); + x288 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(1404826633)))); + x289 = _br2_mulhuu((x275), ((uintptr_t)(UINTMAX_C(970277155)))); + x290 = (x289)+((x275)*((uintptr_t)(UINTMAX_C(1404826633)))); + x291 = ((uintptr_t)((x290)<(x289)))+(x288); + x292 = (x291)+(x286); + x293 = (((uintptr_t)((x291)<(x288)))+((uintptr_t)((x292)<(x286))))+(x287); + x294 = (x293)+(x284); + x295 = (((uintptr_t)((x293)<(x287)))+((uintptr_t)((x294)<(x284))))+(x285); + x296 = (x295)+(x282); + x297 = (((uintptr_t)((x295)<(x285)))+((uintptr_t)((x296)<(x282))))+(x283); + x298 = (x297)+(x280); + x299 = (((uintptr_t)((x297)<(x283)))+((uintptr_t)((x298)<(x280))))+(x281); + x300 = (x299)+(x278); + x301 = (((uintptr_t)((x299)<(x281)))+((uintptr_t)((x300)<(x278))))+(x279); + x302 = (x301)+(x276); + x303 = ((uintptr_t)((x301)<(x279)))+((uintptr_t)((x302)<(x276))); + x304 = ((uintptr_t)(((x266)+((x275)*((uintptr_t)(UINTMAX_C(970277155)))))<(x266)))+(x267); + x305 = (x304)+(x290); + x306 = (((uintptr_t)((x304)<(x267)))+((uintptr_t)((x305)<(x290))))+(x268); + x307 = (x306)+(x292); + x308 = (((uintptr_t)((x306)<(x268)))+((uintptr_t)((x307)<(x292))))+(x269); + x309 = (x308)+(x294); + x310 = (((uintptr_t)((x308)<(x269)))+((uintptr_t)((x309)<(x294))))+(x270); + x311 = (x310)+(x296); + x312 = (((uintptr_t)((x310)<(x270)))+((uintptr_t)((x311)<(x296))))+(x271); + x313 = (x312)+(x298); + x314 = (((uintptr_t)((x312)<(x271)))+((uintptr_t)((x313)<(x298))))+(x272); + x315 = (x314)+(x300); + x316 = (((uintptr_t)((x314)<(x272)))+((uintptr_t)((x315)<(x300))))+(x273); + x317 = (x316)+(x302); + x318 = (((uintptr_t)((x316)<(x273)))+((uintptr_t)((x317)<(x302))))+((x274)+(x265)); + x319 = (x318)+((x303)+(x277)); + x320 = ((uintptr_t)((x318)<((x274)+(x265))))+((uintptr_t)((x319)<((x303)+(x277)))); + x321 = (x305)+(x6); + x322 = ((uintptr_t)((x321)<(x305)))+(x307); + x323 = ((uintptr_t)((x322)<(x307)))+(x309); + x324 = ((uintptr_t)((x323)<(x309)))+(x311); + x325 = ((uintptr_t)((x324)<(x311)))+(x313); + x326 = ((uintptr_t)((x325)<(x313)))+(x315); + x327 = ((uintptr_t)((x326)<(x315)))+(x317); + x328 = ((uintptr_t)((x327)<(x317)))+(x319); + x329 = (uintptr_t)((x328)<(x319)); + x330 = (x321)*((uintptr_t)(UINTMAX_C(1916078453))); + x331 = (x330)*((uintptr_t)(UINTMAX_C(4294967294))); + x332 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(4294967294)))); + x333 = (x330)*((uintptr_t)(UINTMAX_C(4294967295))); + x334 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(4294967295)))); + x335 = (x330)*((uintptr_t)(UINTMAX_C(4294967295))); + x336 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(4294967295)))); + x337 = (x330)*((uintptr_t)(UINTMAX_C(4294967295))); + x338 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(4294967295)))); + x339 = (x330)*((uintptr_t)(UINTMAX_C(1912856427))); + x340 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(1912856427)))); + x341 = (x330)*((uintptr_t)(UINTMAX_C(566625579))); + x342 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(566625579)))); + x343 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(1404826633)))); + x344 = _br2_mulhuu((x330), ((uintptr_t)(UINTMAX_C(970277155)))); + x345 = (x344)+((x330)*((uintptr_t)(UINTMAX_C(1404826633)))); + x346 = ((uintptr_t)((x345)<(x344)))+(x343); + x347 = (x346)+(x341); + x348 = (((uintptr_t)((x346)<(x343)))+((uintptr_t)((x347)<(x341))))+(x342); + x349 = (x348)+(x339); + x350 = (((uintptr_t)((x348)<(x342)))+((uintptr_t)((x349)<(x339))))+(x340); + x351 = (x350)+(x337); + x352 = (((uintptr_t)((x350)<(x340)))+((uintptr_t)((x351)<(x337))))+(x338); + x353 = (x352)+(x335); + x354 = (((uintptr_t)((x352)<(x338)))+((uintptr_t)((x353)<(x335))))+(x336); + x355 = (x354)+(x333); + x356 = (((uintptr_t)((x354)<(x336)))+((uintptr_t)((x355)<(x333))))+(x334); + x357 = (x356)+(x331); + x358 = ((uintptr_t)((x356)<(x334)))+((uintptr_t)((x357)<(x331))); + x359 = ((uintptr_t)(((x321)+((x330)*((uintptr_t)(UINTMAX_C(970277155)))))<(x321)))+(x322); + x360 = (x359)+(x345); + x361 = (((uintptr_t)((x359)<(x322)))+((uintptr_t)((x360)<(x345))))+(x323); + x362 = (x361)+(x347); + x363 = (((uintptr_t)((x361)<(x323)))+((uintptr_t)((x362)<(x347))))+(x324); + x364 = (x363)+(x349); + x365 = (((uintptr_t)((x363)<(x324)))+((uintptr_t)((x364)<(x349))))+(x325); + x366 = (x365)+(x351); + x367 = (((uintptr_t)((x365)<(x325)))+((uintptr_t)((x366)<(x351))))+(x326); + x368 = (x367)+(x353); + x369 = (((uintptr_t)((x367)<(x326)))+((uintptr_t)((x368)<(x353))))+(x327); + x370 = (x369)+(x355); + x371 = (((uintptr_t)((x369)<(x327)))+((uintptr_t)((x370)<(x355))))+(x328); + x372 = (x371)+(x357); + x373 = (((uintptr_t)((x371)<(x328)))+((uintptr_t)((x372)<(x357))))+((x329)+(x320)); + x374 = (x373)+((x358)+(x332)); + x375 = ((uintptr_t)((x373)<((x329)+(x320))))+((uintptr_t)((x374)<((x358)+(x332)))); + x376 = (x360)+(x7); + x377 = ((uintptr_t)((x376)<(x360)))+(x362); + x378 = ((uintptr_t)((x377)<(x362)))+(x364); + x379 = ((uintptr_t)((x378)<(x364)))+(x366); + x380 = ((uintptr_t)((x379)<(x366)))+(x368); + x381 = ((uintptr_t)((x380)<(x368)))+(x370); + x382 = ((uintptr_t)((x381)<(x370)))+(x372); + x383 = ((uintptr_t)((x382)<(x372)))+(x374); + x384 = (uintptr_t)((x383)<(x374)); + x385 = (x376)*((uintptr_t)(UINTMAX_C(1916078453))); + x386 = (x385)*((uintptr_t)(UINTMAX_C(4294967294))); + x387 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(4294967294)))); + x388 = (x385)*((uintptr_t)(UINTMAX_C(4294967295))); + x389 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(4294967295)))); + x390 = (x385)*((uintptr_t)(UINTMAX_C(4294967295))); + x391 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(4294967295)))); + x392 = (x385)*((uintptr_t)(UINTMAX_C(4294967295))); + x393 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(4294967295)))); + x394 = (x385)*((uintptr_t)(UINTMAX_C(1912856427))); + x395 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(1912856427)))); + x396 = (x385)*((uintptr_t)(UINTMAX_C(566625579))); + x397 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(566625579)))); + x398 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(1404826633)))); + x399 = _br2_mulhuu((x385), ((uintptr_t)(UINTMAX_C(970277155)))); + x400 = (x399)+((x385)*((uintptr_t)(UINTMAX_C(1404826633)))); + x401 = ((uintptr_t)((x400)<(x399)))+(x398); + x402 = (x401)+(x396); + x403 = (((uintptr_t)((x401)<(x398)))+((uintptr_t)((x402)<(x396))))+(x397); + x404 = (x403)+(x394); + x405 = (((uintptr_t)((x403)<(x397)))+((uintptr_t)((x404)<(x394))))+(x395); + x406 = (x405)+(x392); + x407 = (((uintptr_t)((x405)<(x395)))+((uintptr_t)((x406)<(x392))))+(x393); + x408 = (x407)+(x390); + x409 = (((uintptr_t)((x407)<(x393)))+((uintptr_t)((x408)<(x390))))+(x391); + x410 = (x409)+(x388); + x411 = (((uintptr_t)((x409)<(x391)))+((uintptr_t)((x410)<(x388))))+(x389); + x412 = (x411)+(x386); + x413 = ((uintptr_t)((x411)<(x389)))+((uintptr_t)((x412)<(x386))); + x414 = ((uintptr_t)(((x376)+((x385)*((uintptr_t)(UINTMAX_C(970277155)))))<(x376)))+(x377); + x415 = (x414)+(x400); + x416 = (((uintptr_t)((x414)<(x377)))+((uintptr_t)((x415)<(x400))))+(x378); + x417 = (x416)+(x402); + x418 = (((uintptr_t)((x416)<(x378)))+((uintptr_t)((x417)<(x402))))+(x379); + x419 = (x418)+(x404); + x420 = (((uintptr_t)((x418)<(x379)))+((uintptr_t)((x419)<(x404))))+(x380); + x421 = (x420)+(x406); + x422 = (((uintptr_t)((x420)<(x380)))+((uintptr_t)((x421)<(x406))))+(x381); + x423 = (x422)+(x408); + x424 = (((uintptr_t)((x422)<(x381)))+((uintptr_t)((x423)<(x408))))+(x382); + x425 = (x424)+(x410); + x426 = (((uintptr_t)((x424)<(x382)))+((uintptr_t)((x425)<(x410))))+(x383); + x427 = (x426)+(x412); + x428 = (((uintptr_t)((x426)<(x383)))+((uintptr_t)((x427)<(x412))))+((x384)+(x375)); + x429 = (x428)+((x413)+(x387)); + x430 = ((uintptr_t)((x428)<((x384)+(x375))))+((uintptr_t)((x429)<((x413)+(x387)))); + x431 = (x415)-((uintptr_t)(UINTMAX_C(970277155))); + x432 = (x417)-((uintptr_t)(UINTMAX_C(1404826633))); + x433 = (x432)-((uintptr_t)((x415)<(x431))); + x434 = (x419)-((uintptr_t)(UINTMAX_C(566625579))); + x435 = (x434)-(((uintptr_t)((x417)<(x432)))+((uintptr_t)((x432)<(x433)))); + x436 = (x421)-((uintptr_t)(UINTMAX_C(1912856427))); + x437 = (x436)-(((uintptr_t)((x419)<(x434)))+((uintptr_t)((x434)<(x435)))); + x438 = (x423)-((uintptr_t)(UINTMAX_C(4294967295))); + x439 = (x438)-(((uintptr_t)((x421)<(x436)))+((uintptr_t)((x436)<(x437)))); + x440 = (x425)-((uintptr_t)(UINTMAX_C(4294967295))); + x441 = (x440)-(((uintptr_t)((x423)<(x438)))+((uintptr_t)((x438)<(x439)))); + x442 = (x427)-((uintptr_t)(UINTMAX_C(4294967295))); + x443 = (x442)-(((uintptr_t)((x425)<(x440)))+((uintptr_t)((x440)<(x441)))); + x444 = (x429)-((uintptr_t)(UINTMAX_C(4294967294))); + x445 = (x444)-(((uintptr_t)((x427)<(x442)))+((uintptr_t)((x442)<(x443)))); + x446 = (uintptr_t)((x430)<((x430)-(((uintptr_t)((x429)<(x444)))+((uintptr_t)((x444)<(x445)))))); + x447 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x448 = (x447)^((uintptr_t)(UINTMAX_C(4294967295))); + x449 = ((x415)&(x447))|((x431)&(x448)); + x450 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x451 = (x450)^((uintptr_t)(UINTMAX_C(4294967295))); + x452 = ((x417)&(x450))|((x433)&(x451)); + x453 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x454 = (x453)^((uintptr_t)(UINTMAX_C(4294967295))); + x455 = ((x419)&(x453))|((x435)&(x454)); + x456 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x457 = (x456)^((uintptr_t)(UINTMAX_C(4294967295))); + x458 = ((x421)&(x456))|((x437)&(x457)); + x459 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x460 = (x459)^((uintptr_t)(UINTMAX_C(4294967295))); + x461 = ((x423)&(x459))|((x439)&(x460)); + x462 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x463 = (x462)^((uintptr_t)(UINTMAX_C(4294967295))); + x464 = ((x425)&(x462))|((x441)&(x463)); + x465 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x466 = (x465)^((uintptr_t)(UINTMAX_C(4294967295))); + x467 = ((x427)&(x465))|((x443)&(x466)); + x468 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x446)==((uintptr_t)(UINTMAX_C(0))))); + x469 = (x468)^((uintptr_t)(UINTMAX_C(4294967295))); + x470 = ((x429)&(x468))|((x445)&(x469)); + x471 = x449; + x472 = x452; + x473 = x455; + x474 = x458; + x475 = x461; + x476 = x464; + x477 = x467; + x478 = x470; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x471, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x472, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x473, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x474, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x475, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x476, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x477, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x478, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_from_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(515236882))); + x17 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(515236882)))); + x18 = (x15)*((uintptr_t)(UINTMAX_C(2720742715))); + x19 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(2720742715)))); + x20 = (x15)*((uintptr_t)(UINTMAX_C(1645201484))); + x21 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(1645201484)))); + x22 = (x15)*((uintptr_t)(UINTMAX_C(989847764))); + x23 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(989847764)))); + x24 = (x15)*((uintptr_t)(UINTMAX_C(878989386))); + x25 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(878989386)))); + x26 = (x15)*((uintptr_t)(UINTMAX_C(3731858170))); + x27 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(3731858170)))); + x28 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(2417070767)))); + x29 = (x15)*((uintptr_t)(UINTMAX_C(2081509152))); + x30 = _br2_mulhuu((x15), ((uintptr_t)(UINTMAX_C(2081509152)))); + x31 = (x30)+((x15)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(1916078453))); + x46 = (x45)*((uintptr_t)(UINTMAX_C(4294967294))); + x47 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(4294967294)))); + x48 = (x45)*((uintptr_t)(UINTMAX_C(4294967295))); + x49 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(4294967295)))); + x50 = (x45)*((uintptr_t)(UINTMAX_C(4294967295))); + x51 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(4294967295)))); + x52 = (x45)*((uintptr_t)(UINTMAX_C(4294967295))); + x53 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(4294967295)))); + x54 = (x45)*((uintptr_t)(UINTMAX_C(1912856427))); + x55 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(1912856427)))); + x56 = (x45)*((uintptr_t)(UINTMAX_C(566625579))); + x57 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(566625579)))); + x58 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(1404826633)))); + x59 = _br2_mulhuu((x45), ((uintptr_t)(UINTMAX_C(970277155)))); + x60 = (x59)+((x45)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x92 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(515236882)))); + x93 = (x8)*((uintptr_t)(UINTMAX_C(2720742715))); + x94 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(2720742715)))); + x95 = (x8)*((uintptr_t)(UINTMAX_C(1645201484))); + x96 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(1645201484)))); + x97 = (x8)*((uintptr_t)(UINTMAX_C(989847764))); + x98 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(989847764)))); + x99 = (x8)*((uintptr_t)(UINTMAX_C(878989386))); + x100 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(878989386)))); + x101 = (x8)*((uintptr_t)(UINTMAX_C(3731858170))); + x102 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(3731858170)))); + x103 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(2417070767)))); + x104 = _br2_mulhuu((x8), ((uintptr_t)(UINTMAX_C(2081509152)))); + x105 = (x104)+((x8)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x136 = (x135)*((uintptr_t)(UINTMAX_C(4294967294))); + x137 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(4294967294)))); + x138 = (x135)*((uintptr_t)(UINTMAX_C(4294967295))); + x139 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(4294967295)))); + x140 = (x135)*((uintptr_t)(UINTMAX_C(4294967295))); + x141 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(4294967295)))); + x142 = (x135)*((uintptr_t)(UINTMAX_C(4294967295))); + x143 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(4294967295)))); + x144 = (x135)*((uintptr_t)(UINTMAX_C(1912856427))); + x145 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(1912856427)))); + x146 = (x135)*((uintptr_t)(UINTMAX_C(566625579))); + x147 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(566625579)))); + x148 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(1404826633)))); + x149 = _br2_mulhuu((x135), ((uintptr_t)(UINTMAX_C(970277155)))); + x150 = (x149)+((x135)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x182 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(515236882)))); + x183 = (x9)*((uintptr_t)(UINTMAX_C(2720742715))); + x184 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(2720742715)))); + x185 = (x9)*((uintptr_t)(UINTMAX_C(1645201484))); + x186 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(1645201484)))); + x187 = (x9)*((uintptr_t)(UINTMAX_C(989847764))); + x188 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(989847764)))); + x189 = (x9)*((uintptr_t)(UINTMAX_C(878989386))); + x190 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(878989386)))); + x191 = (x9)*((uintptr_t)(UINTMAX_C(3731858170))); + x192 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(3731858170)))); + x193 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(2417070767)))); + x194 = _br2_mulhuu((x9), ((uintptr_t)(UINTMAX_C(2081509152)))); + x195 = (x194)+((x9)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x226 = (x225)*((uintptr_t)(UINTMAX_C(4294967294))); + x227 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(4294967294)))); + x228 = (x225)*((uintptr_t)(UINTMAX_C(4294967295))); + x229 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(4294967295)))); + x230 = (x225)*((uintptr_t)(UINTMAX_C(4294967295))); + x231 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(4294967295)))); + x232 = (x225)*((uintptr_t)(UINTMAX_C(4294967295))); + x233 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(4294967295)))); + x234 = (x225)*((uintptr_t)(UINTMAX_C(1912856427))); + x235 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(1912856427)))); + x236 = (x225)*((uintptr_t)(UINTMAX_C(566625579))); + x237 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(566625579)))); + x238 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(1404826633)))); + x239 = _br2_mulhuu((x225), ((uintptr_t)(UINTMAX_C(970277155)))); + x240 = (x239)+((x225)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x272 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(515236882)))); + x273 = (x10)*((uintptr_t)(UINTMAX_C(2720742715))); + x274 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(2720742715)))); + x275 = (x10)*((uintptr_t)(UINTMAX_C(1645201484))); + x276 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(1645201484)))); + x277 = (x10)*((uintptr_t)(UINTMAX_C(989847764))); + x278 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(989847764)))); + x279 = (x10)*((uintptr_t)(UINTMAX_C(878989386))); + x280 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(878989386)))); + x281 = (x10)*((uintptr_t)(UINTMAX_C(3731858170))); + x282 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(3731858170)))); + x283 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(2417070767)))); + x284 = _br2_mulhuu((x10), ((uintptr_t)(UINTMAX_C(2081509152)))); + x285 = (x284)+((x10)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x316 = (x315)*((uintptr_t)(UINTMAX_C(4294967294))); + x317 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(4294967294)))); + x318 = (x315)*((uintptr_t)(UINTMAX_C(4294967295))); + x319 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(4294967295)))); + x320 = (x315)*((uintptr_t)(UINTMAX_C(4294967295))); + x321 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(4294967295)))); + x322 = (x315)*((uintptr_t)(UINTMAX_C(4294967295))); + x323 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(4294967295)))); + x324 = (x315)*((uintptr_t)(UINTMAX_C(1912856427))); + x325 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(1912856427)))); + x326 = (x315)*((uintptr_t)(UINTMAX_C(566625579))); + x327 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(566625579)))); + x328 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(1404826633)))); + x329 = _br2_mulhuu((x315), ((uintptr_t)(UINTMAX_C(970277155)))); + x330 = (x329)+((x315)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x362 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(515236882)))); + x363 = (x11)*((uintptr_t)(UINTMAX_C(2720742715))); + x364 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(2720742715)))); + x365 = (x11)*((uintptr_t)(UINTMAX_C(1645201484))); + x366 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(1645201484)))); + x367 = (x11)*((uintptr_t)(UINTMAX_C(989847764))); + x368 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(989847764)))); + x369 = (x11)*((uintptr_t)(UINTMAX_C(878989386))); + x370 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(878989386)))); + x371 = (x11)*((uintptr_t)(UINTMAX_C(3731858170))); + x372 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(3731858170)))); + x373 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(2417070767)))); + x374 = _br2_mulhuu((x11), ((uintptr_t)(UINTMAX_C(2081509152)))); + x375 = (x374)+((x11)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x406 = (x405)*((uintptr_t)(UINTMAX_C(4294967294))); + x407 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(4294967294)))); + x408 = (x405)*((uintptr_t)(UINTMAX_C(4294967295))); + x409 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(4294967295)))); + x410 = (x405)*((uintptr_t)(UINTMAX_C(4294967295))); + x411 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(4294967295)))); + x412 = (x405)*((uintptr_t)(UINTMAX_C(4294967295))); + x413 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(4294967295)))); + x414 = (x405)*((uintptr_t)(UINTMAX_C(1912856427))); + x415 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(1912856427)))); + x416 = (x405)*((uintptr_t)(UINTMAX_C(566625579))); + x417 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(566625579)))); + x418 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(1404826633)))); + x419 = _br2_mulhuu((x405), ((uintptr_t)(UINTMAX_C(970277155)))); + x420 = (x419)+((x405)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x452 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(515236882)))); + x453 = (x12)*((uintptr_t)(UINTMAX_C(2720742715))); + x454 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(2720742715)))); + x455 = (x12)*((uintptr_t)(UINTMAX_C(1645201484))); + x456 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(1645201484)))); + x457 = (x12)*((uintptr_t)(UINTMAX_C(989847764))); + x458 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(989847764)))); + x459 = (x12)*((uintptr_t)(UINTMAX_C(878989386))); + x460 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(878989386)))); + x461 = (x12)*((uintptr_t)(UINTMAX_C(3731858170))); + x462 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(3731858170)))); + x463 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(2417070767)))); + x464 = _br2_mulhuu((x12), ((uintptr_t)(UINTMAX_C(2081509152)))); + x465 = (x464)+((x12)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x496 = (x495)*((uintptr_t)(UINTMAX_C(4294967294))); + x497 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(4294967294)))); + x498 = (x495)*((uintptr_t)(UINTMAX_C(4294967295))); + x499 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(4294967295)))); + x500 = (x495)*((uintptr_t)(UINTMAX_C(4294967295))); + x501 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(4294967295)))); + x502 = (x495)*((uintptr_t)(UINTMAX_C(4294967295))); + x503 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(4294967295)))); + x504 = (x495)*((uintptr_t)(UINTMAX_C(1912856427))); + x505 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(1912856427)))); + x506 = (x495)*((uintptr_t)(UINTMAX_C(566625579))); + x507 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(566625579)))); + x508 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(1404826633)))); + x509 = _br2_mulhuu((x495), ((uintptr_t)(UINTMAX_C(970277155)))); + x510 = (x509)+((x495)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x542 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(515236882)))); + x543 = (x13)*((uintptr_t)(UINTMAX_C(2720742715))); + x544 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(2720742715)))); + x545 = (x13)*((uintptr_t)(UINTMAX_C(1645201484))); + x546 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(1645201484)))); + x547 = (x13)*((uintptr_t)(UINTMAX_C(989847764))); + x548 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(989847764)))); + x549 = (x13)*((uintptr_t)(UINTMAX_C(878989386))); + x550 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(878989386)))); + x551 = (x13)*((uintptr_t)(UINTMAX_C(3731858170))); + x552 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(3731858170)))); + x553 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(2417070767)))); + x554 = _br2_mulhuu((x13), ((uintptr_t)(UINTMAX_C(2081509152)))); + x555 = (x554)+((x13)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x586 = (x585)*((uintptr_t)(UINTMAX_C(4294967294))); + x587 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(4294967294)))); + x588 = (x585)*((uintptr_t)(UINTMAX_C(4294967295))); + x589 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(4294967295)))); + x590 = (x585)*((uintptr_t)(UINTMAX_C(4294967295))); + x591 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(4294967295)))); + x592 = (x585)*((uintptr_t)(UINTMAX_C(4294967295))); + x593 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(4294967295)))); + x594 = (x585)*((uintptr_t)(UINTMAX_C(1912856427))); + x595 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(1912856427)))); + x596 = (x585)*((uintptr_t)(UINTMAX_C(566625579))); + x597 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(566625579)))); + x598 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(1404826633)))); + x599 = _br2_mulhuu((x585), ((uintptr_t)(UINTMAX_C(970277155)))); + x600 = (x599)+((x585)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(515236882))); + x632 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(515236882)))); + x633 = (x14)*((uintptr_t)(UINTMAX_C(2720742715))); + x634 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(2720742715)))); + x635 = (x14)*((uintptr_t)(UINTMAX_C(1645201484))); + x636 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(1645201484)))); + x637 = (x14)*((uintptr_t)(UINTMAX_C(989847764))); + x638 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(989847764)))); + x639 = (x14)*((uintptr_t)(UINTMAX_C(878989386))); + x640 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(878989386)))); + x641 = (x14)*((uintptr_t)(UINTMAX_C(3731858170))); + x642 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(3731858170)))); + x643 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(2417070767)))); + x644 = _br2_mulhuu((x14), ((uintptr_t)(UINTMAX_C(2081509152)))); + x645 = (x644)+((x14)*((uintptr_t)(UINTMAX_C(2417070767)))); + 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)(UINTMAX_C(2081509152)))); + 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)(UINTMAX_C(1916078453))); + x676 = (x675)*((uintptr_t)(UINTMAX_C(4294967294))); + x677 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(4294967294)))); + x678 = (x675)*((uintptr_t)(UINTMAX_C(4294967295))); + x679 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(4294967295)))); + x680 = (x675)*((uintptr_t)(UINTMAX_C(4294967295))); + x681 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(4294967295)))); + x682 = (x675)*((uintptr_t)(UINTMAX_C(4294967295))); + x683 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(4294967295)))); + x684 = (x675)*((uintptr_t)(UINTMAX_C(1912856427))); + x685 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(1912856427)))); + x686 = (x675)*((uintptr_t)(UINTMAX_C(566625579))); + x687 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(566625579)))); + x688 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(1404826633)))); + x689 = _br2_mulhuu((x675), ((uintptr_t)(UINTMAX_C(970277155)))); + x690 = (x689)+((x675)*((uintptr_t)(UINTMAX_C(1404826633)))); + 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)(UINTMAX_C(970277155)))))<(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)(UINTMAX_C(970277155))); + x722 = (x707)-((uintptr_t)(UINTMAX_C(1404826633))); + x723 = (x722)-((uintptr_t)((x705)<(x721))); + x724 = (x709)-((uintptr_t)(UINTMAX_C(566625579))); + x725 = (x724)-(((uintptr_t)((x707)<(x722)))+((uintptr_t)((x722)<(x723)))); + x726 = (x711)-((uintptr_t)(UINTMAX_C(1912856427))); + x727 = (x726)-(((uintptr_t)((x709)<(x724)))+((uintptr_t)((x724)<(x725)))); + x728 = (x713)-((uintptr_t)(UINTMAX_C(4294967295))); + x729 = (x728)-(((uintptr_t)((x711)<(x726)))+((uintptr_t)((x726)<(x727)))); + x730 = (x715)-((uintptr_t)(UINTMAX_C(4294967295))); + x731 = (x730)-(((uintptr_t)((x713)<(x728)))+((uintptr_t)((x728)<(x729)))); + x732 = (x717)-((uintptr_t)(UINTMAX_C(4294967295))); + x733 = (x732)-(((uintptr_t)((x715)<(x730)))+((uintptr_t)((x730)<(x731)))); + x734 = (x719)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x738 = (x737)^((uintptr_t)(UINTMAX_C(4294967295))); + x739 = ((x705)&(x737))|((x721)&(x738)); + x740 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x741 = (x740)^((uintptr_t)(UINTMAX_C(4294967295))); + x742 = ((x707)&(x740))|((x723)&(x741)); + x743 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x744 = (x743)^((uintptr_t)(UINTMAX_C(4294967295))); + x745 = ((x709)&(x743))|((x725)&(x744)); + x746 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x747 = (x746)^((uintptr_t)(UINTMAX_C(4294967295))); + x748 = ((x711)&(x746))|((x727)&(x747)); + x749 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x750 = (x749)^((uintptr_t)(UINTMAX_C(4294967295))); + x751 = ((x713)&(x749))|((x729)&(x750)); + x752 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x753 = (x752)^((uintptr_t)(UINTMAX_C(4294967295))); + x754 = ((x715)&(x752))|((x731)&(x753)); + x755 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x756 = (x755)^((uintptr_t)(UINTMAX_C(4294967295))); + x757 = ((x717)&(x755))|((x733)&(x756)); + x758 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x736)==((uintptr_t)(UINTMAX_C(0))))); + x759 = (x758)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x761, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x762, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x763, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x764, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x765, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x766, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x767, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x768, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_to_montgomery(uint32_t out1[8], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, out0, x9; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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_sm2_scalar_nonzero(uint32_t* out1, const uint32_t arg1[8]) { + *out1 = (uint32_t)internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x8 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x16 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x17 = (x16)^((uintptr_t)(UINTMAX_C(4294967295))); + x18 = ((x8)&(x16))|((x0)&(x17)); + x19 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x20 = (x19)^((uintptr_t)(UINTMAX_C(4294967295))); + x21 = ((x9)&(x19))|((x1)&(x20)); + x22 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x23 = (x22)^((uintptr_t)(UINTMAX_C(4294967295))); + x24 = ((x10)&(x22))|((x2)&(x23)); + x25 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x26 = (x25)^((uintptr_t)(UINTMAX_C(4294967295))); + x27 = ((x11)&(x25))|((x3)&(x26)); + x28 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x29 = (x28)^((uintptr_t)(UINTMAX_C(4294967295))); + x30 = ((x12)&(x28))|((x4)&(x29)); + x31 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x32 = (x31)^((uintptr_t)(UINTMAX_C(4294967295))); + x33 = ((x13)&(x31))|((x5)&(x32)); + x34 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x35 = (x34)^((uintptr_t)(UINTMAX_C(4294967295))); + x36 = ((x14)&(x34))|((x6)&(x35)); + x37 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x38 = (x37)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x40, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x41, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x42, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x43, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x44, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x45, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x46, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x47, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_selectznz(uint32_t out1[8], uint8_t arg1, const uint32_t arg2[8], const uint32_t arg3[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 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)(UINTMAX_C(255))); + x17 = (x15)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x18 = (x17)&((uintptr_t)(UINTMAX_C(255))); + x19 = (x17)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x20 = (x19)&((uintptr_t)(UINTMAX_C(255))); + x21 = (x19)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x22 = (x14)&((uintptr_t)(UINTMAX_C(255))); + x23 = (x14)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x24 = (x23)&((uintptr_t)(UINTMAX_C(255))); + x25 = (x23)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x26 = (x25)&((uintptr_t)(UINTMAX_C(255))); + x27 = (x25)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x28 = (x13)&((uintptr_t)(UINTMAX_C(255))); + x29 = (x13)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x30 = (x29)&((uintptr_t)(UINTMAX_C(255))); + x31 = (x29)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x32 = (x31)&((uintptr_t)(UINTMAX_C(255))); + x33 = (x31)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x34 = (x12)&((uintptr_t)(UINTMAX_C(255))); + x35 = (x12)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x36 = (x35)&((uintptr_t)(UINTMAX_C(255))); + x37 = (x35)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x38 = (x37)&((uintptr_t)(UINTMAX_C(255))); + x39 = (x37)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x40 = (x11)&((uintptr_t)(UINTMAX_C(255))); + x41 = (x11)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x42 = (x41)&((uintptr_t)(UINTMAX_C(255))); + x43 = (x41)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x44 = (x43)&((uintptr_t)(UINTMAX_C(255))); + x45 = (x43)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x46 = (x10)&((uintptr_t)(UINTMAX_C(255))); + x47 = (x10)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x48 = (x47)&((uintptr_t)(UINTMAX_C(255))); + x49 = (x47)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x50 = (x49)&((uintptr_t)(UINTMAX_C(255))); + x51 = (x49)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x52 = (x9)&((uintptr_t)(UINTMAX_C(255))); + x53 = (x9)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x54 = (x53)&((uintptr_t)(UINTMAX_C(255))); + x55 = (x53)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x56 = (x55)&((uintptr_t)(UINTMAX_C(255))); + x57 = (x55)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x58 = (x8)&((uintptr_t)(UINTMAX_C(255))); + x59 = (x8)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x60 = (x59)&((uintptr_t)(UINTMAX_C(255))); + x61 = (x59)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x62 = (x61)&((uintptr_t)(UINTMAX_C(255))); + x63 = (x61)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x64, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(1))), x65, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(2))), x66, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(3))), x67, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x68, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(5))), x69, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(6))), x70, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(7))), x71, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x72, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(9))), x73, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(10))), x74, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(11))), x75, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x76, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(13))), x77, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(14))), x78, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(15))), x79, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x80, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(17))), x81, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(18))), x82, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(19))), x83, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x84, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(21))), x85, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(22))), x86, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(23))), x87, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x88, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(25))), x89, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(26))), x90, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(27))), x91, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x92, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(29))), x93, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(30))), x94, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(31))), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_to_bytes(uint8_t out1[32], const uint32_t arg1[8]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), 1); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(1))), 1); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(2))), 1); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(3))), 1); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), 1); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(5))), 1); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(6))), 1); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(7))), 1); + x8 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), 1); + x9 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(9))), 1); + x10 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(10))), 1); + x11 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(11))), 1); + x12 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), 1); + x13 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(13))), 1); + x14 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(14))), 1); + x15 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(15))), 1); + x16 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), 1); + x17 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(17))), 1); + x18 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(18))), 1); + x19 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(19))), 1); + x20 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), 1); + x21 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(21))), 1); + x22 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(22))), 1); + x23 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(23))), 1); + x24 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), 1); + x25 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(25))), 1); + x26 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(26))), 1); + x27 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(27))), 1); + x28 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 1); + x29 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(29))), 1); + x30 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(30))), 1); + x31 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(31))), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x33 = (x30)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x34 = (x29)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x35 = x28; + x36 = (x27)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x37 = (x26)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x38 = (x25)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x39 = x24; + x40 = (x23)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x41 = (x22)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x42 = (x21)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x43 = x20; + x44 = (x19)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x45 = (x18)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x46 = (x17)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x47 = x16; + x48 = (x15)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x49 = (x14)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x50 = (x13)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x51 = x12; + x52 = (x11)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x53 = (x10)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x54 = (x9)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x55 = x8; + x56 = (x7)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x57 = (x6)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x58 = (x5)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x59 = x4; + x60 = (x3)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x61 = (x2)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x62 = (x1)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x88, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x89, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x90, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x91, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_from_bytes(uint32_t out1[8], const uint8_t arg1[32]) { + internal_fiat_sm2_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_sm2_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(3324690141)); + x1 = (uintptr_t)(UINTMAX_C(2890140662)); + x2 = (uintptr_t)(UINTMAX_C(3728341716)); + x3 = (uintptr_t)(UINTMAX_C(2382110868)); + x4 = (uintptr_t)(UINTMAX_C(0)); + x5 = (uintptr_t)(UINTMAX_C(0)); + x6 = (uintptr_t)(UINTMAX_C(0)); + x7 = (uintptr_t)(UINTMAX_C(1)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_set_one(uint32_t out1[8]) { + internal_fiat_sm2_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_sm2_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(970277155)); + x1 = (uintptr_t)(UINTMAX_C(1404826633)); + x2 = (uintptr_t)(UINTMAX_C(566625579)); + x3 = (uintptr_t)(UINTMAX_C(1912856427)); + x4 = (uintptr_t)(UINTMAX_C(4294967295)); + x5 = (uintptr_t)(UINTMAX_C(4294967295)); + x6 = (uintptr_t)(UINTMAX_C(4294967295)); + x7 = (uintptr_t)(UINTMAX_C(4294967294)); + x8 = (uintptr_t)(UINTMAX_C(0)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x7, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(32))), x8, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_msat(uint32_t out1[9]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + x8 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x9 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x10 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x11 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x12 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x13 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x14 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x15 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x16 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + x17 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x18 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x19 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x20 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x21 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x22 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x23 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x24 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x25 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + x26 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x27 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(4))), sizeof(uintptr_t)); + x28 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x29 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(12))), sizeof(uintptr_t)); + x30 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x31 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(20))), sizeof(uintptr_t)); + x32 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x33 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(28))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x34 = ((in0)^((uintptr_t)(UINTMAX_C(4294967295))))+((uintptr_t)(UINTMAX_C(1))); + x35 = ((x34)>>_br2_shamt((uintptr_t)(UINTMAX_C(31))))&((x9)&((uintptr_t)(UINTMAX_C(1)))); + x36 = ((in0)^((uintptr_t)(UINTMAX_C(4294967295))))+((uintptr_t)(UINTMAX_C(1))); + x37 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x38 = (x37)^((uintptr_t)(UINTMAX_C(4294967295))); + x39 = ((x36)&(x37))|((in0)&(x38)); + x40 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x41 = (x40)^((uintptr_t)(UINTMAX_C(4294967295))); + x42 = ((x9)&(x40))|((x0)&(x41)); + x43 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x44 = (x43)^((uintptr_t)(UINTMAX_C(4294967295))); + x45 = ((x10)&(x43))|((x1)&(x44)); + x46 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x47 = (x46)^((uintptr_t)(UINTMAX_C(4294967295))); + x48 = ((x11)&(x46))|((x2)&(x47)); + x49 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x50 = (x49)^((uintptr_t)(UINTMAX_C(4294967295))); + x51 = ((x12)&(x49))|((x3)&(x50)); + x52 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x53 = (x52)^((uintptr_t)(UINTMAX_C(4294967295))); + x54 = ((x13)&(x52))|((x4)&(x53)); + x55 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x56 = (x55)^((uintptr_t)(UINTMAX_C(4294967295))); + x57 = ((x14)&(x55))|((x5)&(x56)); + x58 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x59 = (x58)^((uintptr_t)(UINTMAX_C(4294967295))); + x60 = ((x15)&(x58))|((x6)&(x59)); + x61 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x62 = (x61)^((uintptr_t)(UINTMAX_C(4294967295))); + x63 = ((x16)&(x61))|((x7)&(x62)); + x64 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x65 = (x64)^((uintptr_t)(UINTMAX_C(4294967295))); + x66 = ((x17)&(x64))|((x8)&(x65)); + x67 = ((uintptr_t)(UINTMAX_C(1)))+((x0)^((uintptr_t)(UINTMAX_C(4294967295)))); + x68 = (uintptr_t)((x67)<((uintptr_t)(UINTMAX_C(1)))); + x69 = (x68)+((x1)^((uintptr_t)(UINTMAX_C(4294967295)))); + x70 = (uintptr_t)((x69)<((x1)^((uintptr_t)(UINTMAX_C(4294967295))))); + x71 = (x70)+((x2)^((uintptr_t)(UINTMAX_C(4294967295)))); + x72 = (uintptr_t)((x71)<((x2)^((uintptr_t)(UINTMAX_C(4294967295))))); + x73 = (x72)+((x3)^((uintptr_t)(UINTMAX_C(4294967295)))); + x74 = (uintptr_t)((x73)<((x3)^((uintptr_t)(UINTMAX_C(4294967295))))); + x75 = (x74)+((x4)^((uintptr_t)(UINTMAX_C(4294967295)))); + x76 = (uintptr_t)((x75)<((x4)^((uintptr_t)(UINTMAX_C(4294967295))))); + x77 = (x76)+((x5)^((uintptr_t)(UINTMAX_C(4294967295)))); + x78 = (uintptr_t)((x77)<((x5)^((uintptr_t)(UINTMAX_C(4294967295))))); + x79 = (x78)+((x6)^((uintptr_t)(UINTMAX_C(4294967295)))); + x80 = (uintptr_t)((x79)<((x6)^((uintptr_t)(UINTMAX_C(4294967295))))); + x81 = (x80)+((x7)^((uintptr_t)(UINTMAX_C(4294967295)))); + x82 = (uintptr_t)((x81)<((x7)^((uintptr_t)(UINTMAX_C(4294967295))))); + x83 = (x82)+((x8)^((uintptr_t)(UINTMAX_C(4294967295)))); + x84 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x85 = (x84)^((uintptr_t)(UINTMAX_C(4294967295))); + x86 = ((x67)&(x84))|((x9)&(x85)); + x87 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x88 = (x87)^((uintptr_t)(UINTMAX_C(4294967295))); + x89 = ((x69)&(x87))|((x10)&(x88)); + x90 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x91 = (x90)^((uintptr_t)(UINTMAX_C(4294967295))); + x92 = ((x71)&(x90))|((x11)&(x91)); + x93 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x94 = (x93)^((uintptr_t)(UINTMAX_C(4294967295))); + x95 = ((x73)&(x93))|((x12)&(x94)); + x96 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x97 = (x96)^((uintptr_t)(UINTMAX_C(4294967295))); + x98 = ((x75)&(x96))|((x13)&(x97)); + x99 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x100 = (x99)^((uintptr_t)(UINTMAX_C(4294967295))); + x101 = ((x77)&(x99))|((x14)&(x100)); + x102 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x103 = (x102)^((uintptr_t)(UINTMAX_C(4294967295))); + x104 = ((x79)&(x102))|((x15)&(x103)); + x105 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x106 = (x105)^((uintptr_t)(UINTMAX_C(4294967295))); + x107 = ((x81)&(x105))|((x16)&(x106)); + x108 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x109 = (x108)^((uintptr_t)(UINTMAX_C(4294967295))); + x110 = ((x83)&(x108))|((x17)&(x109)); + x111 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x112 = (x111)^((uintptr_t)(UINTMAX_C(4294967295))); + x113 = ((x26)&(x111))|((x18)&(x112)); + x114 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x115 = (x114)^((uintptr_t)(UINTMAX_C(4294967295))); + x116 = ((x27)&(x114))|((x19)&(x115)); + x117 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x118 = (x117)^((uintptr_t)(UINTMAX_C(4294967295))); + x119 = ((x28)&(x117))|((x20)&(x118)); + x120 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x121 = (x120)^((uintptr_t)(UINTMAX_C(4294967295))); + x122 = ((x29)&(x120))|((x21)&(x121)); + x123 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x124 = (x123)^((uintptr_t)(UINTMAX_C(4294967295))); + x125 = ((x30)&(x123))|((x22)&(x124)); + x126 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x127 = (x126)^((uintptr_t)(UINTMAX_C(4294967295))); + x128 = ((x31)&(x126))|((x23)&(x127)); + x129 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x130 = (x129)^((uintptr_t)(UINTMAX_C(4294967295))); + x131 = ((x32)&(x129))|((x24)&(x130)); + x132 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x133 = (x132)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(970277155))); + x173 = (uintptr_t)((x135)<(x172)); + x174 = (x139)-((uintptr_t)(UINTMAX_C(1404826633))); + x175 = (uintptr_t)((x139)<(x174)); + x176 = (x174)-(x173); + x177 = (uintptr_t)((x174)<(x176)); + x178 = (x175)+(x177); + x179 = (x144)-((uintptr_t)(UINTMAX_C(566625579))); + x180 = (uintptr_t)((x144)<(x179)); + x181 = (x179)-(x178); + x182 = (uintptr_t)((x179)<(x181)); + x183 = (x180)+(x182); + x184 = (x149)-((uintptr_t)(UINTMAX_C(1912856427))); + x185 = (uintptr_t)((x149)<(x184)); + x186 = (x184)-(x183); + x187 = (uintptr_t)((x184)<(x186)); + x188 = (x185)+(x187); + x189 = (x154)-((uintptr_t)(UINTMAX_C(4294967295))); + x190 = (uintptr_t)((x154)<(x189)); + x191 = (x189)-(x188); + x192 = (uintptr_t)((x189)<(x191)); + x193 = (x190)+(x192); + x194 = (x159)-((uintptr_t)(UINTMAX_C(4294967295))); + x195 = (uintptr_t)((x159)<(x194)); + x196 = (x194)-(x193); + x197 = (uintptr_t)((x194)<(x196)); + x198 = (x195)+(x197); + x199 = (x164)-((uintptr_t)(UINTMAX_C(4294967295))); + x200 = (uintptr_t)((x164)<(x199)); + x201 = (x199)-(x198); + x202 = (uintptr_t)((x199)<(x201)); + x203 = (x200)+(x202); + x204 = (x169)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x218))); + x220 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x217))); + x221 = (((uintptr_t)(UINTMAX_C(0)))-(x217))-(x219); + x222 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x217))<(x221)); + x223 = (x220)+(x222); + x224 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x216))); + x225 = (((uintptr_t)(UINTMAX_C(0)))-(x216))-(x223); + x226 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x216))<(x225)); + x227 = (x224)+(x226); + x228 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x215))); + x229 = (((uintptr_t)(UINTMAX_C(0)))-(x215))-(x227); + x230 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x215))<(x229)); + x231 = (x228)+(x230); + x232 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x214))); + x233 = (((uintptr_t)(UINTMAX_C(0)))-(x214))-(x231); + x234 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x214))<(x233)); + x235 = (x232)+(x234); + x236 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x213))); + x237 = (((uintptr_t)(UINTMAX_C(0)))-(x213))-(x235); + x238 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x213))<(x237)); + x239 = (x236)+(x238); + x240 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x212))); + x241 = (((uintptr_t)(UINTMAX_C(0)))-(x212))-(x239); + x242 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x212))<(x241)); + x243 = (x240)+(x242); + x244 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x211))); + x245 = (((uintptr_t)(UINTMAX_C(0)))-(x211))-(x243); + x246 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x211))<(x245)); + x247 = (x244)+(x246); + x248 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x247)==((uintptr_t)(UINTMAX_C(0))))); + x249 = (((uintptr_t)(UINTMAX_C(0)))-(x218))+((x248)&((uintptr_t)(UINTMAX_C(970277155)))); + x250 = (uintptr_t)((x249)<(((uintptr_t)(UINTMAX_C(0)))-(x218))); + x251 = (x250)+(x221); + x252 = (uintptr_t)((x251)<(x221)); + x253 = (x251)+((x248)&((uintptr_t)(UINTMAX_C(1404826633)))); + x254 = (uintptr_t)((x253)<((x248)&((uintptr_t)(UINTMAX_C(1404826633))))); + x255 = (x252)+(x254); + x256 = (x255)+(x225); + x257 = (uintptr_t)((x256)<(x225)); + x258 = (x256)+((x248)&((uintptr_t)(UINTMAX_C(566625579)))); + x259 = (uintptr_t)((x258)<((x248)&((uintptr_t)(UINTMAX_C(566625579))))); + x260 = (x257)+(x259); + x261 = (x260)+(x229); + x262 = (uintptr_t)((x261)<(x229)); + x263 = (x261)+((x248)&((uintptr_t)(UINTMAX_C(1912856427)))); + x264 = (uintptr_t)((x263)<((x248)&((uintptr_t)(UINTMAX_C(1912856427))))); + x265 = (x262)+(x264); + x266 = (x265)+(x233); + x267 = (uintptr_t)((x266)<(x233)); + x268 = (x266)+(x248); + x269 = (uintptr_t)((x268)<(x248)); + 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)&((uintptr_t)(UINTMAX_C(4294967294)))); + x283 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x284 = (x283)^((uintptr_t)(UINTMAX_C(4294967295))); + x285 = ((x249)&(x283))|((x26)&(x284)); + x286 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x287 = (x286)^((uintptr_t)(UINTMAX_C(4294967295))); + x288 = ((x253)&(x286))|((x27)&(x287)); + x289 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x290 = (x289)^((uintptr_t)(UINTMAX_C(4294967295))); + x291 = ((x258)&(x289))|((x28)&(x290)); + x292 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x293 = (x292)^((uintptr_t)(UINTMAX_C(4294967295))); + x294 = ((x263)&(x292))|((x29)&(x293)); + x295 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x296 = (x295)^((uintptr_t)(UINTMAX_C(4294967295))); + x297 = ((x268)&(x295))|((x30)&(x296)); + x298 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x299 = (x298)^((uintptr_t)(UINTMAX_C(4294967295))); + x300 = ((x273)&(x298))|((x31)&(x299)); + x301 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x302 = (x301)^((uintptr_t)(UINTMAX_C(4294967295))); + x303 = ((x278)&(x301))|((x32)&(x302)); + x304 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x35)==((uintptr_t)(UINTMAX_C(0))))); + x305 = (x304)^((uintptr_t)(UINTMAX_C(4294967295))); + x306 = ((x282)&(x304))|((x33)&(x305)); + x307 = (x86)&((uintptr_t)(UINTMAX_C(1))); + x308 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x309 = (x308)^((uintptr_t)(UINTMAX_C(4294967295))); + x310 = ((x42)&(x308))|(((uintptr_t)(UINTMAX_C(0)))&(x309)); + x311 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x312 = (x311)^((uintptr_t)(UINTMAX_C(4294967295))); + x313 = ((x45)&(x311))|(((uintptr_t)(UINTMAX_C(0)))&(x312)); + x314 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x315 = (x314)^((uintptr_t)(UINTMAX_C(4294967295))); + x316 = ((x48)&(x314))|(((uintptr_t)(UINTMAX_C(0)))&(x315)); + x317 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x318 = (x317)^((uintptr_t)(UINTMAX_C(4294967295))); + x319 = ((x51)&(x317))|(((uintptr_t)(UINTMAX_C(0)))&(x318)); + x320 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x321 = (x320)^((uintptr_t)(UINTMAX_C(4294967295))); + x322 = ((x54)&(x320))|(((uintptr_t)(UINTMAX_C(0)))&(x321)); + x323 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x324 = (x323)^((uintptr_t)(UINTMAX_C(4294967295))); + x325 = ((x57)&(x323))|(((uintptr_t)(UINTMAX_C(0)))&(x324)); + x326 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x327 = (x326)^((uintptr_t)(UINTMAX_C(4294967295))); + x328 = ((x60)&(x326))|(((uintptr_t)(UINTMAX_C(0)))&(x327)); + x329 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x330 = (x329)^((uintptr_t)(UINTMAX_C(4294967295))); + x331 = ((x63)&(x329))|(((uintptr_t)(UINTMAX_C(0)))&(x330)); + x332 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x333 = (x332)^((uintptr_t)(UINTMAX_C(4294967295))); + x334 = ((x66)&(x332))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x375 = (x374)^((uintptr_t)(UINTMAX_C(4294967295))); + x376 = ((x113)&(x374))|(((uintptr_t)(UINTMAX_C(0)))&(x375)); + x377 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x378 = (x377)^((uintptr_t)(UINTMAX_C(4294967295))); + x379 = ((x116)&(x377))|(((uintptr_t)(UINTMAX_C(0)))&(x378)); + x380 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x381 = (x380)^((uintptr_t)(UINTMAX_C(4294967295))); + x382 = ((x119)&(x380))|(((uintptr_t)(UINTMAX_C(0)))&(x381)); + x383 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x384 = (x383)^((uintptr_t)(UINTMAX_C(4294967295))); + x385 = ((x122)&(x383))|(((uintptr_t)(UINTMAX_C(0)))&(x384)); + x386 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x387 = (x386)^((uintptr_t)(UINTMAX_C(4294967295))); + x388 = ((x125)&(x386))|(((uintptr_t)(UINTMAX_C(0)))&(x387)); + x389 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x390 = (x389)^((uintptr_t)(UINTMAX_C(4294967295))); + x391 = ((x128)&(x389))|(((uintptr_t)(UINTMAX_C(0)))&(x390)); + x392 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x393 = (x392)^((uintptr_t)(UINTMAX_C(4294967295))); + x394 = ((x131)&(x392))|(((uintptr_t)(UINTMAX_C(0)))&(x393)); + x395 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x307)==((uintptr_t)(UINTMAX_C(0))))); + x396 = (x395)^((uintptr_t)(UINTMAX_C(4294967295))); + x397 = ((x134)&(x395))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(970277155))); + x436 = (uintptr_t)((x398)<(x435)); + x437 = (x402)-((uintptr_t)(UINTMAX_C(1404826633))); + x438 = (uintptr_t)((x402)<(x437)); + x439 = (x437)-(x436); + x440 = (uintptr_t)((x437)<(x439)); + x441 = (x438)+(x440); + x442 = (x407)-((uintptr_t)(UINTMAX_C(566625579))); + x443 = (uintptr_t)((x407)<(x442)); + x444 = (x442)-(x441); + x445 = (uintptr_t)((x442)<(x444)); + x446 = (x443)+(x445); + x447 = (x412)-((uintptr_t)(UINTMAX_C(1912856427))); + x448 = (uintptr_t)((x412)<(x447)); + x449 = (x447)-(x446); + x450 = (uintptr_t)((x447)<(x449)); + x451 = (x448)+(x450); + x452 = (x417)-((uintptr_t)(UINTMAX_C(4294967295))); + x453 = (uintptr_t)((x417)<(x452)); + x454 = (x452)-(x451); + x455 = (uintptr_t)((x452)<(x454)); + x456 = (x453)+(x455); + x457 = (x422)-((uintptr_t)(UINTMAX_C(4294967295))); + x458 = (uintptr_t)((x422)<(x457)); + x459 = (x457)-(x456); + x460 = (uintptr_t)((x457)<(x459)); + x461 = (x458)+(x460); + x462 = (x427)-((uintptr_t)(UINTMAX_C(4294967295))); + x463 = (uintptr_t)((x427)<(x462)); + x464 = (x462)-(x461); + x465 = (uintptr_t)((x462)<(x464)); + x466 = (x463)+(x465); + x467 = (x432)-((uintptr_t)(UINTMAX_C(4294967294))); + 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)(UINTMAX_C(1))); + x475 = ((x335)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x339)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x476 = ((x339)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x344)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x477 = ((x344)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x349)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x478 = ((x349)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x354)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x479 = ((x354)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x359)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x480 = ((x359)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x364)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x481 = ((x364)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x369)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x482 = ((x369)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x373)<<_br2_shamt((uintptr_t)(UINTMAX_C(31)))); + x483 = ((x373)&((uintptr_t)(UINTMAX_C(2147483648))))|((x373)>>_br2_shamt((uintptr_t)(UINTMAX_C(1)))); + x484 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x485 = (x484)^((uintptr_t)(UINTMAX_C(4294967295))); + x486 = ((x135)&(x484))|((x172)&(x485)); + x487 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x488 = (x487)^((uintptr_t)(UINTMAX_C(4294967295))); + x489 = ((x139)&(x487))|((x176)&(x488)); + x490 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x491 = (x490)^((uintptr_t)(UINTMAX_C(4294967295))); + x492 = ((x144)&(x490))|((x181)&(x491)); + x493 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x494 = (x493)^((uintptr_t)(UINTMAX_C(4294967295))); + x495 = ((x149)&(x493))|((x186)&(x494)); + x496 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x497 = (x496)^((uintptr_t)(UINTMAX_C(4294967295))); + x498 = ((x154)&(x496))|((x191)&(x497)); + x499 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x500 = (x499)^((uintptr_t)(UINTMAX_C(4294967295))); + x501 = ((x159)&(x499))|((x196)&(x500)); + x502 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x503 = (x502)^((uintptr_t)(UINTMAX_C(4294967295))); + x504 = ((x164)&(x502))|((x201)&(x503)); + x505 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x210)==((uintptr_t)(UINTMAX_C(0))))); + x506 = (x505)^((uintptr_t)(UINTMAX_C(4294967295))); + x507 = ((x169)&(x505))|((x206)&(x506)); + x508 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x509 = (x508)^((uintptr_t)(UINTMAX_C(4294967295))); + x510 = ((x398)&(x508))|((x435)&(x509)); + x511 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x512 = (x511)^((uintptr_t)(UINTMAX_C(4294967295))); + x513 = ((x402)&(x511))|((x439)&(x512)); + x514 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x515 = (x514)^((uintptr_t)(UINTMAX_C(4294967295))); + x516 = ((x407)&(x514))|((x444)&(x515)); + x517 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x518 = (x517)^((uintptr_t)(UINTMAX_C(4294967295))); + x519 = ((x412)&(x517))|((x449)&(x518)); + x520 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x521 = (x520)^((uintptr_t)(UINTMAX_C(4294967295))); + x522 = ((x417)&(x520))|((x454)&(x521)); + x523 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x524 = (x523)^((uintptr_t)(UINTMAX_C(4294967295))); + x525 = ((x422)&(x523))|((x459)&(x524)); + x526 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x527 = (x526)^((uintptr_t)(UINTMAX_C(4294967295))); + x528 = ((x427)&(x526))|((x464)&(x527)); + x529 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x473)==((uintptr_t)(UINTMAX_C(0))))); + x530 = (x529)^((uintptr_t)(UINTMAX_C(4294967295))); + 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)(UINTMAX_C(0))), x533, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(4))), x534, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(8))), x535, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(12))), x536, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(16))), x537, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(20))), x538, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(24))), x539, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(28))), x540, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(32))), x541, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)(UINTMAX_C(0))), x542, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(4))), x543, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(8))), x544, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(12))), x545, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(16))), x546, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(20))), x547, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(24))), x548, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(28))), x549, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(32))), x550, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)(UINTMAX_C(0))), x551, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(4))), x552, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(8))), x553, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(12))), x554, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(16))), x555, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(20))), x556, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(24))), x557, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(28))), x558, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)(UINTMAX_C(0))), x559, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(4))), x560, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(8))), x561, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(12))), x562, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(16))), x563, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(20))), x564, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(24))), x565, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(28))), x566, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_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_sm2_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_sm2_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4, x5, x6, x7; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(3008460141)); + x1 = (uintptr_t)(UINTMAX_C(446899975)); + x2 = (uintptr_t)(UINTMAX_C(506094330)); + x3 = (uintptr_t)(UINTMAX_C(11263335)); + x4 = (uintptr_t)(UINTMAX_C(3556809345)); + x5 = (uintptr_t)(UINTMAX_C(1227361661)); + x6 = (uintptr_t)(UINTMAX_C(3871049448)); + x7 = (uintptr_t)(UINTMAX_C(3610260334)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x4, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x5, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x6, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x7, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_divstep_precomp(uint32_t out1[8]) { + internal_fiat_sm2_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-bedrock2/src/sm2_scalar_64.c b/fiat-bedrock2/src/sm2_scalar_64.c new file mode 100644 index 00000000000..b7486291c47 --- /dev/null +++ b/fiat-bedrock2/src/sm2_scalar_64.c @@ -0,0 +1,2201 @@ +/* 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 sm2_scalar 64 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") */ +/* */ +/* 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 +#include + +static __attribute__((constructor)) void _br2_preconditions(void) { + static_assert(~(intptr_t)0 == -(intptr_t)1, "two's complement"); + assert(((void)"two's complement", ~(intptr_t)0 == -(intptr_t)1)); + uintptr_t u = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&u)); + intptr_t i = 1; + assert(((void)"little-endian", 1 == *(unsigned char *)&i)); +} + +// 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 inline __attribute__((always_inline, unused)) +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 inline __attribute__((always_inline, unused)) +void _br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) { + memcpy((void*)a, &v, sz); +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_mulhuu(uintptr_t a, uintptr_t b) { + #if (UINTPTR_MAX == (UINTMAX_C(1)<<31) - 1 + (UINTMAX_C(1)<<31)) + return ((uint64_t)a * b) >> 32; + #elif (UINTPTR_MAX == (UINTMAX_C(1)<<63) - 1 + (UINTMAX_C(1)<<63)) + return ((unsigned __int128)a * b) >> 64; + #else + #error "32-bit or 64-bit uintptr_t required" + #endif +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_divu(uintptr_t a, uintptr_t b) { + if (!b) return -1; + return a/b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_remu(uintptr_t a, uintptr_t b) { + if (!b) return a; + return a%b; +} + +static inline __attribute__((always_inline, unused)) +uintptr_t _br2_shamt(uintptr_t a) { + return a&(sizeof(uintptr_t)*8-1); +} + + +/* + * 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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = x1; + x9 = x2; + x10 = x3; + x11 = x0; + x12 = (x11)*(x7); + x13 = _br2_mulhuu((x11), (x7)); + x14 = (x11)*(x6); + x15 = _br2_mulhuu((x11), (x6)); + x16 = (x11)*(x5); + x17 = _br2_mulhuu((x11), (x5)); + x18 = (x11)*(x4); + x19 = _br2_mulhuu((x11), (x4)); + 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)(UINTMAX_C(3638801332807469429))); + x34 = (x33)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x35 = _br2_mulhuu((x33), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x36 = (x33)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x37 = _br2_mulhuu((x33), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x38 = (x33)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x39 = _br2_mulhuu((x33), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x40 = (x33)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x41 = _br2_mulhuu((x33), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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 = _br2_mulhuu((x8), (x7)); + x79 = (x8)*(x6); + x80 = _br2_mulhuu((x8), (x6)); + x81 = (x8)*(x5); + x82 = _br2_mulhuu((x8), (x5)); + x83 = (x8)*(x4); + x84 = _br2_mulhuu((x8), (x4)); + 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)(UINTMAX_C(3638801332807469429))); + x121 = (x120)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x122 = _br2_mulhuu((x120), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x123 = (x120)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x124 = _br2_mulhuu((x120), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x125 = (x120)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x126 = _br2_mulhuu((x120), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x127 = (x120)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x128 = _br2_mulhuu((x120), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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 = _br2_mulhuu((x9), (x7)); + x167 = (x9)*(x6); + x168 = _br2_mulhuu((x9), (x6)); + x169 = (x9)*(x5); + x170 = _br2_mulhuu((x9), (x5)); + x171 = (x9)*(x4); + x172 = _br2_mulhuu((x9), (x4)); + 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)(UINTMAX_C(3638801332807469429))); + x209 = (x208)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x210 = _br2_mulhuu((x208), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x211 = (x208)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x212 = _br2_mulhuu((x208), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x213 = (x208)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x214 = _br2_mulhuu((x208), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x215 = (x208)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x216 = _br2_mulhuu((x208), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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 = _br2_mulhuu((x10), (x7)); + x255 = (x10)*(x6); + x256 = _br2_mulhuu((x10), (x6)); + x257 = (x10)*(x5); + x258 = _br2_mulhuu((x10), (x5)); + x259 = (x10)*(x4); + x260 = _br2_mulhuu((x10), (x4)); + 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)(UINTMAX_C(3638801332807469429))); + x297 = (x296)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x298 = _br2_mulhuu((x296), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x299 = (x296)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x300 = _br2_mulhuu((x296), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x301 = (x296)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x302 = _br2_mulhuu((x296), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x303 = (x296)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x304 = _br2_mulhuu((x296), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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)(UINTMAX_C(6033684446255071523))); + x342 = (uintptr_t)((x322)<(x341)); + x343 = (x327)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x344 = (uintptr_t)((x327)<(x343)); + x345 = (x343)-(x342); + x346 = (uintptr_t)((x343)<(x345)); + x347 = (x344)+(x346); + x348 = (x332)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x349 = (uintptr_t)((x332)<(x348)); + x350 = (x348)-(x347); + x351 = (uintptr_t)((x348)<(x350)); + x352 = (x349)+(x351); + x353 = (x337)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x359)==((uintptr_t)(UINTMAX_C(0))))); + x361 = (x360)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x362 = ((x322)&(x360))|((x341)&(x361)); + x363 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x359)==((uintptr_t)(UINTMAX_C(0))))); + x364 = (x363)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x365 = ((x327)&(x363))|((x345)&(x364)); + x366 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x359)==((uintptr_t)(UINTMAX_C(0))))); + x367 = (x366)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x368 = ((x332)&(x366))|((x350)&(x367)); + x369 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x359)==((uintptr_t)(UINTMAX_C(0))))); + x370 = (x369)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x371 = ((x337)&(x369))|((x355)&(x370)); + x372 = x362; + x373 = x365; + x374 = x368; + x375 = x371; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x372, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x373, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x374, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x375, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_mul(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*(x3); + x9 = _br2_mulhuu((x7), (x3)); + x10 = (x7)*(x2); + x11 = _br2_mulhuu((x7), (x2)); + x12 = (x7)*(x1); + x13 = _br2_mulhuu((x7), (x1)); + x14 = (x7)*(x0); + x15 = _br2_mulhuu((x7), (x0)); + 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)(UINTMAX_C(3638801332807469429))); + x30 = (x29)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x31 = _br2_mulhuu((x29), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x32 = (x29)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x33 = _br2_mulhuu((x29), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x34 = (x29)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x35 = _br2_mulhuu((x29), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x36 = (x29)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x37 = _br2_mulhuu((x29), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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 = _br2_mulhuu((x4), (x3)); + x75 = (x4)*(x2); + x76 = _br2_mulhuu((x4), (x2)); + x77 = (x4)*(x1); + x78 = _br2_mulhuu((x4), (x1)); + x79 = (x4)*(x0); + x80 = _br2_mulhuu((x4), (x0)); + 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)(UINTMAX_C(3638801332807469429))); + x117 = (x116)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x118 = _br2_mulhuu((x116), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x119 = (x116)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x120 = _br2_mulhuu((x116), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x121 = (x116)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x122 = _br2_mulhuu((x116), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x123 = (x116)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x124 = _br2_mulhuu((x116), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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 = _br2_mulhuu((x5), (x3)); + x163 = (x5)*(x2); + x164 = _br2_mulhuu((x5), (x2)); + x165 = (x5)*(x1); + x166 = _br2_mulhuu((x5), (x1)); + x167 = (x5)*(x0); + x168 = _br2_mulhuu((x5), (x0)); + 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)(UINTMAX_C(3638801332807469429))); + x205 = (x204)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x206 = _br2_mulhuu((x204), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x207 = (x204)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x208 = _br2_mulhuu((x204), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x209 = (x204)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x210 = _br2_mulhuu((x204), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x211 = (x204)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x212 = _br2_mulhuu((x204), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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 = _br2_mulhuu((x6), (x3)); + x251 = (x6)*(x2); + x252 = _br2_mulhuu((x6), (x2)); + x253 = (x6)*(x1); + x254 = _br2_mulhuu((x6), (x1)); + x255 = (x6)*(x0); + x256 = _br2_mulhuu((x6), (x0)); + 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)(UINTMAX_C(3638801332807469429))); + x293 = (x292)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x294 = _br2_mulhuu((x292), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x295 = (x292)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x296 = _br2_mulhuu((x292), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x297 = (x292)*((uintptr_t)(UINTMAX_C(8215655796475036971))); + x298 = _br2_mulhuu((x292), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x299 = (x292)*((uintptr_t)(UINTMAX_C(6033684446255071523))); + x300 = _br2_mulhuu((x292), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + 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)(UINTMAX_C(6033684446255071523))); + x338 = (uintptr_t)((x318)<(x337)); + x339 = (x323)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x340 = (uintptr_t)((x323)<(x339)); + x341 = (x339)-(x338); + x342 = (uintptr_t)((x339)<(x341)); + x343 = (x340)+(x342); + x344 = (x328)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x345 = (uintptr_t)((x328)<(x344)); + x346 = (x344)-(x343); + x347 = (uintptr_t)((x344)<(x346)); + x348 = (x345)+(x347); + x349 = (x333)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x357 = (x356)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x358 = ((x318)&(x356))|((x337)&(x357)); + x359 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x360 = (x359)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x361 = ((x323)&(x359))|((x341)&(x360)); + x362 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x363 = (x362)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x364 = ((x328)&(x362))|((x346)&(x363)); + x365 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x355)==((uintptr_t)(UINTMAX_C(0))))); + x366 = (x365)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x367 = ((x333)&(x365))|((x351)&(x366)); + x368 = x358; + x369 = x361; + x370 = x364; + x371 = x367; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x368, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x369, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x370, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x371, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_square(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), 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)(UINTMAX_C(6033684446255071523))); + x17 = (x10)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x18 = (x17)-((uintptr_t)((x8)<(x16))); + x19 = (x12)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x20 = (x19)-(((uintptr_t)((x10)<(x17)))+((uintptr_t)((x17)<(x18)))); + x21 = (x14)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x25 = (x24)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x26 = ((x8)&(x24))|((x16)&(x25)); + x27 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x28 = (x27)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x29 = ((x10)&(x27))|((x18)&(x28)); + x30 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x31 = (x30)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x32 = ((x12)&(x30))|((x20)&(x31)); + x33 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x23)==((uintptr_t)(UINTMAX_C(0))))); + x34 = (x33)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x35 = ((x14)&(x33))|((x22)&(x34)); + x36 = x26; + x37 = x29; + x38 = x32; + x39 = x35; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x36, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x37, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x38, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x39, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_add(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), 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)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)((x3)<(x13)))+((uintptr_t)((x13)<(x14))))==((uintptr_t)(UINTMAX_C(0))))); + x16 = (x8)+((x15)&((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x17 = ((uintptr_t)((x16)<(x8)))+(x10); + x18 = (x17)+((x15)&((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x19 = (((uintptr_t)((x17)<(x10)))+((uintptr_t)((x18)<((x15)&((uintptr_t)(UINTMAX_C(8215655796475036971)))))))+(x12); + x20 = (x19)+(x15); + x21 = ((((uintptr_t)((x19)<(x12)))+((uintptr_t)((x20)<(x15))))+(x14))+((x15)&((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x22 = x16; + x23 = x18; + x24 = x20; + x25 = x21; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x23, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x24, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x25, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_sub(uint64_t out1[4], const uint64_t arg1[4], const uint64_t arg2[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = ((uintptr_t)(UINTMAX_C(0)))-(x0); + x5 = ((uintptr_t)(UINTMAX_C(0)))-(x1); + x6 = (x5)-((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x4))); + x7 = ((uintptr_t)(UINTMAX_C(0)))-(x2); + x8 = (x7)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x5)))+((uintptr_t)((x5)<(x6)))); + x9 = ((uintptr_t)(UINTMAX_C(0)))-(x3); + x10 = (x9)-(((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x7)))+((uintptr_t)((x7)<(x8)))); + x11 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((((uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(x9)))+((uintptr_t)((x9)<(x10))))==((uintptr_t)(UINTMAX_C(0))))); + x12 = (x4)+((x11)&((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x13 = ((uintptr_t)((x12)<(x4)))+(x6); + x14 = (x13)+((x11)&((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x15 = (((uintptr_t)((x13)<(x6)))+((uintptr_t)((x14)<((x11)&((uintptr_t)(UINTMAX_C(8215655796475036971)))))))+(x8); + x16 = (x15)+(x11); + x17 = ((((uintptr_t)((x15)<(x8)))+((uintptr_t)((x16)<(x11))))+(x10))+((x11)&((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x18 = x12; + x19 = x14; + x20 = x16; + x21 = x17; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x18, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x19, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x21, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_opp(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x0; + x5 = (x4)*((uintptr_t)(UINTMAX_C(3638801332807469429))); + x6 = (x5)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x7 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x8 = (x5)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x9 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x10 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x11 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x12 = (x11)+((x5)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(3638801332807469429))); + x27 = (x26)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x28 = _br2_mulhuu((x26), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x29 = (x26)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x30 = _br2_mulhuu((x26), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x31 = _br2_mulhuu((x26), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x32 = _br2_mulhuu((x26), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x33 = (x32)+((x26)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(3638801332807469429))); + x51 = (x50)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x52 = _br2_mulhuu((x50), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x53 = (x50)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x54 = _br2_mulhuu((x50), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x55 = _br2_mulhuu((x50), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x56 = _br2_mulhuu((x50), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x57 = (x56)+((x50)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(3638801332807469429))); + x75 = (x74)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x76 = (x74)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x77 = _br2_mulhuu((x74), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x78 = _br2_mulhuu((x74), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x79 = _br2_mulhuu((x74), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x80 = (x79)+((x74)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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))))+(_br2_mulhuu((x74), ((uintptr_t)(UINTMAX_C(18446744069414584319)))))); + x92 = (x86)-((uintptr_t)(UINTMAX_C(6033684446255071523))); + x93 = (x88)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x94 = (x93)-((uintptr_t)((x86)<(x92))); + x95 = (x90)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x96 = (x95)-(((uintptr_t)((x88)<(x93)))+((uintptr_t)((x93)<(x94)))); + x97 = (x91)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + x98 = (x97)-(((uintptr_t)((x90)<(x95)))+((uintptr_t)((x95)<(x96)))); + x99 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(((uintptr_t)((x91)<(x97)))+((uintptr_t)((x97)<(x98)))))); + x100 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x99)==((uintptr_t)(UINTMAX_C(0))))); + x101 = (x100)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x102 = ((x86)&(x100))|((x92)&(x101)); + x103 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x99)==((uintptr_t)(UINTMAX_C(0))))); + x104 = (x103)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x105 = ((x88)&(x103))|((x94)&(x104)); + x106 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x99)==((uintptr_t)(UINTMAX_C(0))))); + x107 = (x106)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x108 = ((x90)&(x106))|((x96)&(x107)); + x109 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x99)==((uintptr_t)(UINTMAX_C(0))))); + x110 = (x109)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x111 = ((x91)&(x109))|((x98)&(x110)); + x112 = x102; + x113 = x105; + x114 = x108; + x115 = x111; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x112, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x113, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x114, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x115, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_from_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x1; + x5 = x2; + x6 = x3; + x7 = x0; + x8 = (x7)*((uintptr_t)(UINTMAX_C(2212925560603753787))); + x9 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(2212925560603753787)))); + x10 = (x7)*((uintptr_t)(UINTMAX_C(7066086570100515028))); + x11 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(7066086570100515028)))); + x12 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(3775230670132978426)))); + x13 = (x7)*((uintptr_t)(UINTMAX_C(10381239898464145184))); + x14 = _br2_mulhuu((x7), ((uintptr_t)(UINTMAX_C(10381239898464145184)))); + x15 = (x14)+((x7)*((uintptr_t)(UINTMAX_C(3775230670132978426)))); + 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)(UINTMAX_C(3638801332807469429))); + x22 = (x21)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x23 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x24 = (x21)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x25 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x26 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x27 = _br2_mulhuu((x21), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x28 = (x27)+((x21)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(2212925560603753787))); + x44 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(2212925560603753787)))); + x45 = (x4)*((uintptr_t)(UINTMAX_C(7066086570100515028))); + x46 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(7066086570100515028)))); + x47 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(3775230670132978426)))); + x48 = _br2_mulhuu((x4), ((uintptr_t)(UINTMAX_C(10381239898464145184)))); + x49 = (x48)+((x4)*((uintptr_t)(UINTMAX_C(3775230670132978426)))); + 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)(UINTMAX_C(10381239898464145184)))); + 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)(UINTMAX_C(3638801332807469429))); + x64 = (x63)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x65 = _br2_mulhuu((x63), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x66 = (x63)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x67 = _br2_mulhuu((x63), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x68 = _br2_mulhuu((x63), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x69 = _br2_mulhuu((x63), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x70 = (x69)+((x63)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(2212925560603753787))); + x86 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(2212925560603753787)))); + x87 = (x5)*((uintptr_t)(UINTMAX_C(7066086570100515028))); + x88 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(7066086570100515028)))); + x89 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(3775230670132978426)))); + x90 = _br2_mulhuu((x5), ((uintptr_t)(UINTMAX_C(10381239898464145184)))); + x91 = (x90)+((x5)*((uintptr_t)(UINTMAX_C(3775230670132978426)))); + 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)(UINTMAX_C(10381239898464145184)))); + 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)(UINTMAX_C(3638801332807469429))); + x106 = (x105)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x107 = _br2_mulhuu((x105), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x108 = (x105)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x109 = _br2_mulhuu((x105), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x110 = _br2_mulhuu((x105), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x111 = _br2_mulhuu((x105), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x112 = (x111)+((x105)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(2212925560603753787))); + x128 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(2212925560603753787)))); + x129 = (x6)*((uintptr_t)(UINTMAX_C(7066086570100515028))); + x130 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(7066086570100515028)))); + x131 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(3775230670132978426)))); + x132 = _br2_mulhuu((x6), ((uintptr_t)(UINTMAX_C(10381239898464145184)))); + x133 = (x132)+((x6)*((uintptr_t)(UINTMAX_C(3775230670132978426)))); + 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)(UINTMAX_C(10381239898464145184)))); + 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)(UINTMAX_C(3638801332807469429))); + x148 = (x147)*((uintptr_t)(UINTMAX_C(18446744069414584319))); + x149 = _br2_mulhuu((x147), ((uintptr_t)(UINTMAX_C(18446744069414584319)))); + x150 = (x147)*((uintptr_t)(UINTMAX_C(18446744073709551615))); + x151 = _br2_mulhuu((x147), ((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x152 = _br2_mulhuu((x147), ((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x153 = _br2_mulhuu((x147), ((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x154 = (x153)+((x147)*((uintptr_t)(UINTMAX_C(8215655796475036971)))); + 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)(UINTMAX_C(6033684446255071523)))))<(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)(UINTMAX_C(6033684446255071523))); + x170 = (x163)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x171 = (x170)-((uintptr_t)((x161)<(x169))); + x172 = (x165)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x173 = (x172)-(((uintptr_t)((x163)<(x170)))+((uintptr_t)((x170)<(x171)))); + x174 = (x167)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(-1)))+((uintptr_t)((x176)==((uintptr_t)(UINTMAX_C(0))))); + x178 = (x177)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x179 = ((x161)&(x177))|((x169)&(x178)); + x180 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x176)==((uintptr_t)(UINTMAX_C(0))))); + x181 = (x180)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x182 = ((x163)&(x180))|((x171)&(x181)); + x183 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x176)==((uintptr_t)(UINTMAX_C(0))))); + x184 = (x183)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x185 = ((x165)&(x183))|((x173)&(x184)); + x186 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x176)==((uintptr_t)(UINTMAX_C(0))))); + x187 = (x186)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x188 = ((x167)&(x186))|((x175)&(x187)); + x189 = x179; + x190 = x182; + x191 = x185; + x192 = x188; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x189, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x190, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x191, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x192, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_to_montgomery(uint64_t out1[4], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_scalar_nonzero(uintptr_t in0) { + uintptr_t x0, x1, x2, x3, x4, out0, x5; + x0 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), 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_sm2_scalar_nonzero(uint64_t* out1, const uint64_t arg1[4]) { + *out1 = (uint64_t)internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x4 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x5 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x8 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x9 = (x8)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x10 = ((x4)&(x8))|((x0)&(x9)); + x11 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x12 = (x11)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x13 = ((x5)&(x11))|((x1)&(x12)); + x14 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x15 = (x14)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x16 = ((x6)&(x14))|((x2)&(x15)); + x17 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((in0)==((uintptr_t)(UINTMAX_C(0))))); + x18 = (x17)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x19 = ((x7)&(x17))|((x3)&(x18)); + x20 = x10; + x21 = x13; + x22 = x16; + x23 = x19; + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x20, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x21, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x22, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x23, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_selectznz(uint64_t out1[4], uint8_t arg1, const uint64_t arg2[4], const uint64_t arg3[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x4 = x3; + x5 = x2; + x6 = x1; + x7 = x0; + x8 = (x7)&((uintptr_t)(UINTMAX_C(255))); + x9 = (x7)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x10 = (x9)&((uintptr_t)(UINTMAX_C(255))); + x11 = (x9)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x12 = (x11)&((uintptr_t)(UINTMAX_C(255))); + x13 = (x11)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x14 = (x13)&((uintptr_t)(UINTMAX_C(255))); + x15 = (x13)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x16 = (x15)&((uintptr_t)(UINTMAX_C(255))); + x17 = (x15)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x18 = (x17)&((uintptr_t)(UINTMAX_C(255))); + x19 = (x17)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x20 = (x19)&((uintptr_t)(UINTMAX_C(255))); + x21 = (x19)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x22 = (x6)&((uintptr_t)(UINTMAX_C(255))); + x23 = (x6)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x24 = (x23)&((uintptr_t)(UINTMAX_C(255))); + x25 = (x23)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x26 = (x25)&((uintptr_t)(UINTMAX_C(255))); + x27 = (x25)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x28 = (x27)&((uintptr_t)(UINTMAX_C(255))); + x29 = (x27)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x30 = (x29)&((uintptr_t)(UINTMAX_C(255))); + x31 = (x29)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x32 = (x31)&((uintptr_t)(UINTMAX_C(255))); + x33 = (x31)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x34 = (x33)&((uintptr_t)(UINTMAX_C(255))); + x35 = (x33)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x36 = (x5)&((uintptr_t)(UINTMAX_C(255))); + x37 = (x5)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x38 = (x37)&((uintptr_t)(UINTMAX_C(255))); + x39 = (x37)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x40 = (x39)&((uintptr_t)(UINTMAX_C(255))); + x41 = (x39)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x42 = (x41)&((uintptr_t)(UINTMAX_C(255))); + x43 = (x41)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x44 = (x43)&((uintptr_t)(UINTMAX_C(255))); + x45 = (x43)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x46 = (x45)&((uintptr_t)(UINTMAX_C(255))); + x47 = (x45)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x48 = (x47)&((uintptr_t)(UINTMAX_C(255))); + x49 = (x47)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x50 = (x4)&((uintptr_t)(UINTMAX_C(255))); + x51 = (x4)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x52 = (x51)&((uintptr_t)(UINTMAX_C(255))); + x53 = (x51)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x54 = (x53)&((uintptr_t)(UINTMAX_C(255))); + x55 = (x53)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x56 = (x55)&((uintptr_t)(UINTMAX_C(255))); + x57 = (x55)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x58 = (x57)&((uintptr_t)(UINTMAX_C(255))); + x59 = (x57)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x60 = (x59)&((uintptr_t)(UINTMAX_C(255))); + x61 = (x59)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x62 = (x61)&((uintptr_t)(UINTMAX_C(255))); + x63 = (x61)>>_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x64, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(1))), x65, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(2))), x66, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(3))), x67, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(4))), x68, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(5))), x69, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(6))), x70, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(7))), x71, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x72, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(9))), x73, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(10))), x74, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(11))), x75, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(12))), x76, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(13))), x77, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(14))), x78, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(15))), x79, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x80, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(17))), x81, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(18))), x82, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(19))), x83, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(20))), x84, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(21))), x85, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(22))), x86, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(23))), x87, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x88, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(25))), x89, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(26))), x90, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(27))), x91, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(28))), x92, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(29))), x93, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(30))), x94, 1); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(31))), x95, 1); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_to_bytes(uint8_t out1[32], const uint64_t arg1[4]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), 1); + x1 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(1))), 1); + x2 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(2))), 1); + x3 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(3))), 1); + x4 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(4))), 1); + x5 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(5))), 1); + x6 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(6))), 1); + x7 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(7))), 1); + x8 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(8))), 1); + x9 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(9))), 1); + x10 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(10))), 1); + x11 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(11))), 1); + x12 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(12))), 1); + x13 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(13))), 1); + x14 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(14))), 1); + x15 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(15))), 1); + x16 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(16))), 1); + x17 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(17))), 1); + x18 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(18))), 1); + x19 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(19))), 1); + x20 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(20))), 1); + x21 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(21))), 1); + x22 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(22))), 1); + x23 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(23))), 1); + x24 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(24))), 1); + x25 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(25))), 1); + x26 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(26))), 1); + x27 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(27))), 1); + x28 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(28))), 1); + x29 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(29))), 1); + x30 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(30))), 1); + x31 = _br2_load((in0)+((uintptr_t)(UINTMAX_C(31))), 1); + /*skip*/ + /*skip*/ + x32 = (x31)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x33 = (x30)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x34 = (x29)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x35 = (x28)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x36 = (x27)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x37 = (x26)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x38 = (x25)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x39 = x24; + x40 = (x23)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x41 = (x22)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x42 = (x21)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x43 = (x20)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x44 = (x19)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x45 = (x18)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x46 = (x17)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x47 = x16; + x48 = (x15)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x49 = (x14)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x50 = (x13)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x51 = (x12)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x52 = (x11)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x53 = (x10)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x54 = (x9)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + x55 = x8; + x56 = (x7)<<_br2_shamt((uintptr_t)(UINTMAX_C(56))); + x57 = (x6)<<_br2_shamt((uintptr_t)(UINTMAX_C(48))); + x58 = (x5)<<_br2_shamt((uintptr_t)(UINTMAX_C(40))); + x59 = (x4)<<_br2_shamt((uintptr_t)(UINTMAX_C(32))); + x60 = (x3)<<_br2_shamt((uintptr_t)(UINTMAX_C(24))); + x61 = (x2)<<_br2_shamt((uintptr_t)(UINTMAX_C(16))); + x62 = (x1)<<_br2_shamt((uintptr_t)(UINTMAX_C(8))); + 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)(UINTMAX_C(0))), x92, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x93, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x94, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x95, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_from_bytes(uint64_t out1[4], const uint8_t arg1[32]) { + internal_fiat_sm2_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_sm2_scalar_set_one(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(12413059627454480093)); + x1 = (uintptr_t)(UINTMAX_C(10231088277234514644)); + x2 = (uintptr_t)(UINTMAX_C(0)); + x3 = (uintptr_t)(UINTMAX_C(4294967296)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_set_one(uint64_t out1[4]) { + internal_fiat_sm2_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_sm2_scalar_msat(uintptr_t out0) { + uintptr_t x0, x1, x2, x3, x4; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(6033684446255071523)); + x1 = (uintptr_t)(UINTMAX_C(8215655796475036971)); + x2 = (uintptr_t)(UINTMAX_C(18446744073709551615)); + x3 = (uintptr_t)(UINTMAX_C(18446744069414584319)); + x4 = (uintptr_t)(UINTMAX_C(0)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x3, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(32))), x4, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_msat(uint64_t out1[5]) { + internal_fiat_sm2_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_sm2_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)(UINTMAX_C(0))), sizeof(uintptr_t)); + x1 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x2 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x3 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x4 = _br2_load((in1)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x5 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x6 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x7 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x8 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + x9 = _br2_load((in2)+((uintptr_t)(UINTMAX_C(32))), sizeof(uintptr_t)); + /*skip*/ + x10 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x11 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x12 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x13 = _br2_load((in3)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + x14 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(0))), sizeof(uintptr_t)); + x15 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(8))), sizeof(uintptr_t)); + x16 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(16))), sizeof(uintptr_t)); + x17 = _br2_load((in4)+((uintptr_t)(UINTMAX_C(24))), sizeof(uintptr_t)); + /*skip*/ + /*skip*/ + x18 = ((in0)^((uintptr_t)(UINTMAX_C(18446744073709551615))))+((uintptr_t)(UINTMAX_C(1))); + x19 = ((x18)>>_br2_shamt((uintptr_t)(UINTMAX_C(63))))&((x5)&((uintptr_t)(UINTMAX_C(1)))); + x20 = ((in0)^((uintptr_t)(UINTMAX_C(18446744073709551615))))+((uintptr_t)(UINTMAX_C(1))); + x21 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x22 = (x21)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x23 = ((x20)&(x21))|((in0)&(x22)); + x24 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x25 = (x24)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x26 = ((x5)&(x24))|((x0)&(x25)); + x27 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x28 = (x27)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x29 = ((x6)&(x27))|((x1)&(x28)); + x30 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x31 = (x30)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x32 = ((x7)&(x30))|((x2)&(x31)); + x33 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x34 = (x33)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x35 = ((x8)&(x33))|((x3)&(x34)); + x36 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x37 = (x36)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x38 = ((x9)&(x36))|((x4)&(x37)); + x39 = ((uintptr_t)(UINTMAX_C(1)))+((x0)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x40 = (uintptr_t)((x39)<((uintptr_t)(UINTMAX_C(1)))); + x41 = (x40)+((x1)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x42 = (uintptr_t)((x41)<((x1)^((uintptr_t)(UINTMAX_C(18446744073709551615))))); + x43 = (x42)+((x2)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x44 = (uintptr_t)((x43)<((x2)^((uintptr_t)(UINTMAX_C(18446744073709551615))))); + x45 = (x44)+((x3)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x46 = (uintptr_t)((x45)<((x3)^((uintptr_t)(UINTMAX_C(18446744073709551615))))); + x47 = (x46)+((x4)^((uintptr_t)(UINTMAX_C(18446744073709551615)))); + x48 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x49 = (x48)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x50 = ((x39)&(x48))|((x5)&(x49)); + x51 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x52 = (x51)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x53 = ((x41)&(x51))|((x6)&(x52)); + x54 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x55 = (x54)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x56 = ((x43)&(x54))|((x7)&(x55)); + x57 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x58 = (x57)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x59 = ((x45)&(x57))|((x8)&(x58)); + x60 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x61 = (x60)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x62 = ((x47)&(x60))|((x9)&(x61)); + x63 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x64 = (x63)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x65 = ((x14)&(x63))|((x10)&(x64)); + x66 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x67 = (x66)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x68 = ((x15)&(x66))|((x11)&(x67)); + x69 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x70 = (x69)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x71 = ((x16)&(x69))|((x12)&(x70)); + x72 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x73 = (x72)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + 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)(UINTMAX_C(6033684446255071523))); + x93 = (uintptr_t)((x75)<(x92)); + x94 = (x79)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x95 = (uintptr_t)((x79)<(x94)); + x96 = (x94)-(x93); + x97 = (uintptr_t)((x94)<(x96)); + x98 = (x95)+(x97); + x99 = (x84)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x100 = (uintptr_t)((x84)<(x99)); + x101 = (x99)-(x98); + x102 = (uintptr_t)((x99)<(x101)); + x103 = (x100)+(x102); + x104 = (x89)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x114))); + x116 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x113))); + x117 = (((uintptr_t)(UINTMAX_C(0)))-(x113))-(x115); + x118 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x113))<(x117)); + x119 = (x116)+(x118); + x120 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x112))); + x121 = (((uintptr_t)(UINTMAX_C(0)))-(x112))-(x119); + x122 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x112))<(x121)); + x123 = (x120)+(x122); + x124 = (uintptr_t)(((uintptr_t)(UINTMAX_C(0)))<(((uintptr_t)(UINTMAX_C(0)))-(x111))); + x125 = (((uintptr_t)(UINTMAX_C(0)))-(x111))-(x123); + x126 = (uintptr_t)((((uintptr_t)(UINTMAX_C(0)))-(x111))<(x125)); + x127 = (x124)+(x126); + x128 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x127)==((uintptr_t)(UINTMAX_C(0))))); + x129 = (((uintptr_t)(UINTMAX_C(0)))-(x114))+((x128)&((uintptr_t)(UINTMAX_C(6033684446255071523)))); + x130 = (uintptr_t)((x129)<(((uintptr_t)(UINTMAX_C(0)))-(x114))); + x131 = (x130)+(x117); + x132 = (uintptr_t)((x131)<(x117)); + x133 = (x131)+((x128)&((uintptr_t)(UINTMAX_C(8215655796475036971)))); + x134 = (uintptr_t)((x133)<((x128)&((uintptr_t)(UINTMAX_C(8215655796475036971))))); + 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)(UINTMAX_C(18446744069414584319)))); + x143 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x144 = (x143)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x145 = ((x129)&(x143))|((x14)&(x144)); + x146 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x147 = (x146)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x148 = ((x133)&(x146))|((x15)&(x147)); + x149 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x150 = (x149)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x151 = ((x138)&(x149))|((x16)&(x150)); + x152 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x19)==((uintptr_t)(UINTMAX_C(0))))); + x153 = (x152)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x154 = ((x142)&(x152))|((x17)&(x153)); + x155 = (x50)&((uintptr_t)(UINTMAX_C(1))); + x156 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x157 = (x156)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x158 = ((x26)&(x156))|(((uintptr_t)(UINTMAX_C(0)))&(x157)); + x159 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x160 = (x159)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x161 = ((x29)&(x159))|(((uintptr_t)(UINTMAX_C(0)))&(x160)); + x162 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x163 = (x162)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x164 = ((x32)&(x162))|(((uintptr_t)(UINTMAX_C(0)))&(x163)); + x165 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x166 = (x165)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x167 = ((x35)&(x165))|(((uintptr_t)(UINTMAX_C(0)))&(x166)); + x168 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x169 = (x168)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x170 = ((x38)&(x168))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x191 = (x190)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x192 = ((x65)&(x190))|(((uintptr_t)(UINTMAX_C(0)))&(x191)); + x193 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x194 = (x193)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x195 = ((x68)&(x193))|(((uintptr_t)(UINTMAX_C(0)))&(x194)); + x196 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x197 = (x196)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x198 = ((x71)&(x196))|(((uintptr_t)(UINTMAX_C(0)))&(x197)); + x199 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x155)==((uintptr_t)(UINTMAX_C(0))))); + x200 = (x199)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x201 = ((x74)&(x199))|(((uintptr_t)(UINTMAX_C(0)))&(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)(UINTMAX_C(6033684446255071523))); + x220 = (uintptr_t)((x202)<(x219)); + x221 = (x206)-((uintptr_t)(UINTMAX_C(8215655796475036971))); + x222 = (uintptr_t)((x206)<(x221)); + x223 = (x221)-(x220); + x224 = (uintptr_t)((x221)<(x223)); + x225 = (x222)+(x224); + x226 = (x211)-((uintptr_t)(UINTMAX_C(18446744073709551615))); + x227 = (uintptr_t)((x211)<(x226)); + x228 = (x226)-(x225); + x229 = (uintptr_t)((x226)<(x228)); + x230 = (x227)+(x229); + x231 = (x216)-((uintptr_t)(UINTMAX_C(18446744069414584319))); + 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)(UINTMAX_C(1))); + x239 = ((x171)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x175)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x240 = ((x175)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x180)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x241 = ((x180)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x185)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x242 = ((x185)>>_br2_shamt((uintptr_t)(UINTMAX_C(1))))|((x189)<<_br2_shamt((uintptr_t)(UINTMAX_C(63)))); + x243 = ((x189)&((uintptr_t)(UINTMAX_C(9223372036854775808))))|((x189)>>_br2_shamt((uintptr_t)(UINTMAX_C(1)))); + x244 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x245 = (x244)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x246 = ((x75)&(x244))|((x92)&(x245)); + x247 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x248 = (x247)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x249 = ((x79)&(x247))|((x96)&(x248)); + x250 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x251 = (x250)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x252 = ((x84)&(x250))|((x101)&(x251)); + x253 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x110)==((uintptr_t)(UINTMAX_C(0))))); + x254 = (x253)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x255 = ((x89)&(x253))|((x106)&(x254)); + x256 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x257 = (x256)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x258 = ((x202)&(x256))|((x219)&(x257)); + x259 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x260 = (x259)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x261 = ((x206)&(x259))|((x223)&(x260)); + x262 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x263 = (x262)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + x264 = ((x211)&(x262))|((x228)&(x263)); + x265 = ((uintptr_t)(UINTMAX_C(-1)))+((uintptr_t)((x237)==((uintptr_t)(UINTMAX_C(0))))); + x266 = (x265)^((uintptr_t)(UINTMAX_C(18446744073709551615))); + 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)(UINTMAX_C(0))), x269, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(8))), x270, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(16))), x271, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(24))), x272, sizeof(uintptr_t)); + _br2_store((out1)+((uintptr_t)(UINTMAX_C(32))), x273, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out2)+((uintptr_t)(UINTMAX_C(0))), x274, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(8))), x275, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(16))), x276, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(24))), x277, sizeof(uintptr_t)); + _br2_store((out2)+((uintptr_t)(UINTMAX_C(32))), x278, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out3)+((uintptr_t)(UINTMAX_C(0))), x279, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(8))), x280, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(16))), x281, sizeof(uintptr_t)); + _br2_store((out3)+((uintptr_t)(UINTMAX_C(24))), x282, sizeof(uintptr_t)); + /*skip*/ + _br2_store((out4)+((uintptr_t)(UINTMAX_C(0))), x283, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(8))), x284, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(16))), x285, sizeof(uintptr_t)); + _br2_store((out4)+((uintptr_t)(UINTMAX_C(24))), x286, sizeof(uintptr_t)); + /*skip*/ + return out0; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_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_sm2_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_sm2_scalar_divstep_precomp(uintptr_t out0) { + uintptr_t x0, x1, x2, x3; + /*skip*/ + x0 = (uintptr_t)(UINTMAX_C(1919420780216677741)); + x1 = (uintptr_t)(UINTMAX_C(48375655974986490)); + x2 = (uintptr_t)(UINTMAX_C(5271478197916048001)); + x3 = (uintptr_t)(UINTMAX_C(15505950068447086312)); + /*skip*/ + _br2_store((out0)+((uintptr_t)(UINTMAX_C(0))), x0, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(8))), x1, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(16))), x2, sizeof(uintptr_t)); + _br2_store((out0)+((uintptr_t)(UINTMAX_C(24))), x3, sizeof(uintptr_t)); + /*skip*/ + return; +} + +/* NOTE: The following wrapper function is not covered by Coq proofs */ +static void fiat_sm2_scalar_divstep_precomp(uint64_t out1[4]) { + internal_fiat_sm2_scalar_divstep_precomp((uintptr_t)out1); +} diff --git a/fiat-c/src/sm2_32.c b/fiat-c/src/sm2_32.c new file mode 100644 index 00000000000..d06a428e969 --- /dev/null +++ b/fiat-c/src/sm2_32.c @@ -0,0 +1,5446 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier sm2 32 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2 */ +/* 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") */ +/* */ +/* 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_sm2_uint1; +typedef signed char fiat_sm2_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_SM2_FIAT_INLINE __inline__ +#else +# define FIAT_SM2_FIAT_INLINE +#endif + +/* The type fiat_sm2_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_sm2_montgomery_domain_field_element[8]; + +/* The type fiat_sm2_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_sm2_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_SM2_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint32_t fiat_sm2_value_barrier_u32(uint32_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_sm2_value_barrier_u32(x) (x) +#endif + + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_addcarryx_u32(uint32_t* out1, fiat_sm2_uint1* out2, fiat_sm2_uint1 arg1, uint32_t arg2, uint32_t arg3) { + uint64_t x1; + uint32_t x2; + fiat_sm2_uint1 x3; + x1 = ((arg1 + (uint64_t)arg2) + arg3); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (fiat_sm2_uint1)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_subborrowx_u32(uint32_t* out1, fiat_sm2_uint1* out2, fiat_sm2_uint1 arg1, uint32_t arg2, uint32_t arg3) { + int64_t x1; + fiat_sm2_int1 x2; + uint32_t x3; + x1 = ((arg2 - (int64_t)arg1) - arg3); + x2 = (fiat_sm2_int1)(x1 >> 32); + x3 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + *out1 = x3; + *out2 = (fiat_sm2_uint1)(0x0 - x2); +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_cmovznz_u32(uint32_t* out1, fiat_sm2_uint1 arg1, uint32_t arg2, uint32_t arg3) { + fiat_sm2_uint1 x1; + uint32_t x2; + uint32_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_sm2_int1)(0x0 - x1) & UINT32_C(0xffffffff)); + x3 = ((fiat_sm2_value_barrier_u32(x2) & arg3) | (fiat_sm2_value_barrier_u32((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_mul(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1, const fiat_sm2_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_sm2_uint1 x26; + uint32_t x27; + fiat_sm2_uint1 x28; + uint32_t x29; + fiat_sm2_uint1 x30; + uint32_t x31; + fiat_sm2_uint1 x32; + uint32_t x33; + fiat_sm2_uint1 x34; + uint32_t x35; + fiat_sm2_uint1 x36; + uint32_t x37; + fiat_sm2_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; + fiat_sm2_uint1 x55; + uint32_t x56; + uint32_t x57; + fiat_sm2_uint1 x58; + uint32_t x59; + fiat_sm2_uint1 x60; + uint32_t x61; + fiat_sm2_uint1 x62; + uint32_t x63; + fiat_sm2_uint1 x64; + uint32_t x65; + uint32_t x66; + fiat_sm2_uint1 x67; + uint32_t x68; + fiat_sm2_uint1 x69; + uint32_t x70; + fiat_sm2_uint1 x71; + uint32_t x72; + fiat_sm2_uint1 x73; + uint32_t x74; + fiat_sm2_uint1 x75; + uint32_t x76; + fiat_sm2_uint1 x77; + uint32_t x78; + fiat_sm2_uint1 x79; + uint32_t x80; + fiat_sm2_uint1 x81; + uint32_t x82; + fiat_sm2_uint1 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; + uint32_t x100; + fiat_sm2_uint1 x101; + uint32_t x102; + fiat_sm2_uint1 x103; + uint32_t x104; + fiat_sm2_uint1 x105; + uint32_t x106; + fiat_sm2_uint1 x107; + uint32_t x108; + fiat_sm2_uint1 x109; + uint32_t x110; + fiat_sm2_uint1 x111; + uint32_t x112; + fiat_sm2_uint1 x113; + uint32_t x114; + uint32_t x115; + fiat_sm2_uint1 x116; + uint32_t x117; + fiat_sm2_uint1 x118; + uint32_t x119; + fiat_sm2_uint1 x120; + uint32_t x121; + fiat_sm2_uint1 x122; + uint32_t x123; + fiat_sm2_uint1 x124; + uint32_t x125; + fiat_sm2_uint1 x126; + uint32_t x127; + fiat_sm2_uint1 x128; + uint32_t x129; + fiat_sm2_uint1 x130; + uint32_t x131; + fiat_sm2_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; + fiat_sm2_uint1 x148; + uint32_t x149; + uint32_t x150; + fiat_sm2_uint1 x151; + uint32_t x152; + fiat_sm2_uint1 x153; + uint32_t x154; + fiat_sm2_uint1 x155; + uint32_t x156; + fiat_sm2_uint1 x157; + uint32_t x158; + uint32_t x159; + fiat_sm2_uint1 x160; + uint32_t x161; + fiat_sm2_uint1 x162; + uint32_t x163; + fiat_sm2_uint1 x164; + uint32_t x165; + fiat_sm2_uint1 x166; + uint32_t x167; + fiat_sm2_uint1 x168; + uint32_t x169; + fiat_sm2_uint1 x170; + uint32_t x171; + fiat_sm2_uint1 x172; + uint32_t x173; + fiat_sm2_uint1 x174; + uint32_t x175; + fiat_sm2_uint1 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; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + fiat_sm2_uint1 x195; + uint32_t x196; + fiat_sm2_uint1 x197; + uint32_t x198; + fiat_sm2_uint1 x199; + uint32_t x200; + fiat_sm2_uint1 x201; + uint32_t x202; + fiat_sm2_uint1 x203; + uint32_t x204; + fiat_sm2_uint1 x205; + uint32_t x206; + fiat_sm2_uint1 x207; + uint32_t x208; + uint32_t x209; + fiat_sm2_uint1 x210; + uint32_t x211; + fiat_sm2_uint1 x212; + uint32_t x213; + fiat_sm2_uint1 x214; + uint32_t x215; + fiat_sm2_uint1 x216; + uint32_t x217; + fiat_sm2_uint1 x218; + uint32_t x219; + fiat_sm2_uint1 x220; + uint32_t x221; + fiat_sm2_uint1 x222; + uint32_t x223; + fiat_sm2_uint1 x224; + uint32_t x225; + fiat_sm2_uint1 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; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + fiat_sm2_uint1 x242; + uint32_t x243; + uint32_t x244; + fiat_sm2_uint1 x245; + uint32_t x246; + fiat_sm2_uint1 x247; + uint32_t x248; + fiat_sm2_uint1 x249; + uint32_t x250; + fiat_sm2_uint1 x251; + uint32_t x252; + uint32_t x253; + fiat_sm2_uint1 x254; + uint32_t x255; + fiat_sm2_uint1 x256; + uint32_t x257; + fiat_sm2_uint1 x258; + uint32_t x259; + fiat_sm2_uint1 x260; + uint32_t x261; + fiat_sm2_uint1 x262; + uint32_t x263; + fiat_sm2_uint1 x264; + uint32_t x265; + fiat_sm2_uint1 x266; + uint32_t x267; + fiat_sm2_uint1 x268; + uint32_t x269; + fiat_sm2_uint1 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; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + fiat_sm2_uint1 x289; + uint32_t x290; + fiat_sm2_uint1 x291; + uint32_t x292; + fiat_sm2_uint1 x293; + uint32_t x294; + fiat_sm2_uint1 x295; + uint32_t x296; + fiat_sm2_uint1 x297; + uint32_t x298; + fiat_sm2_uint1 x299; + uint32_t x300; + fiat_sm2_uint1 x301; + uint32_t x302; + uint32_t x303; + fiat_sm2_uint1 x304; + uint32_t x305; + fiat_sm2_uint1 x306; + uint32_t x307; + fiat_sm2_uint1 x308; + uint32_t x309; + fiat_sm2_uint1 x310; + uint32_t x311; + fiat_sm2_uint1 x312; + uint32_t x313; + fiat_sm2_uint1 x314; + uint32_t x315; + fiat_sm2_uint1 x316; + uint32_t x317; + fiat_sm2_uint1 x318; + uint32_t x319; + fiat_sm2_uint1 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; + uint32_t x335; + fiat_sm2_uint1 x336; + uint32_t x337; + uint32_t x338; + fiat_sm2_uint1 x339; + uint32_t x340; + fiat_sm2_uint1 x341; + uint32_t x342; + fiat_sm2_uint1 x343; + uint32_t x344; + fiat_sm2_uint1 x345; + uint32_t x346; + uint32_t x347; + fiat_sm2_uint1 x348; + uint32_t x349; + fiat_sm2_uint1 x350; + uint32_t x351; + fiat_sm2_uint1 x352; + uint32_t x353; + fiat_sm2_uint1 x354; + uint32_t x355; + fiat_sm2_uint1 x356; + uint32_t x357; + fiat_sm2_uint1 x358; + uint32_t x359; + fiat_sm2_uint1 x360; + uint32_t x361; + fiat_sm2_uint1 x362; + uint32_t x363; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x383; + uint32_t x384; + fiat_sm2_uint1 x385; + uint32_t x386; + fiat_sm2_uint1 x387; + uint32_t x388; + fiat_sm2_uint1 x389; + uint32_t x390; + fiat_sm2_uint1 x391; + uint32_t x392; + fiat_sm2_uint1 x393; + uint32_t x394; + fiat_sm2_uint1 x395; + uint32_t x396; + uint32_t x397; + fiat_sm2_uint1 x398; + uint32_t x399; + fiat_sm2_uint1 x400; + uint32_t x401; + fiat_sm2_uint1 x402; + uint32_t x403; + fiat_sm2_uint1 x404; + uint32_t x405; + fiat_sm2_uint1 x406; + uint32_t x407; + fiat_sm2_uint1 x408; + uint32_t x409; + fiat_sm2_uint1 x410; + uint32_t x411; + fiat_sm2_uint1 x412; + uint32_t x413; + fiat_sm2_uint1 x414; + uint32_t x415; + uint32_t x416; + uint32_t x417; + uint32_t 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; + fiat_sm2_uint1 x430; + uint32_t x431; + uint32_t x432; + fiat_sm2_uint1 x433; + uint32_t x434; + fiat_sm2_uint1 x435; + uint32_t x436; + fiat_sm2_uint1 x437; + uint32_t x438; + fiat_sm2_uint1 x439; + uint32_t x440; + uint32_t x441; + fiat_sm2_uint1 x442; + uint32_t x443; + fiat_sm2_uint1 x444; + uint32_t x445; + fiat_sm2_uint1 x446; + uint32_t x447; + fiat_sm2_uint1 x448; + uint32_t x449; + fiat_sm2_uint1 x450; + uint32_t x451; + fiat_sm2_uint1 x452; + uint32_t x453; + fiat_sm2_uint1 x454; + uint32_t x455; + fiat_sm2_uint1 x456; + uint32_t x457; + fiat_sm2_uint1 x458; + uint32_t x459; + uint32_t x460; + uint32_t x461; + uint32_t x462; + uint32_t 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; + fiat_sm2_uint1 x477; + uint32_t x478; + fiat_sm2_uint1 x479; + uint32_t x480; + fiat_sm2_uint1 x481; + uint32_t x482; + fiat_sm2_uint1 x483; + uint32_t x484; + fiat_sm2_uint1 x485; + uint32_t x486; + fiat_sm2_uint1 x487; + uint32_t x488; + fiat_sm2_uint1 x489; + uint32_t x490; + uint32_t x491; + fiat_sm2_uint1 x492; + uint32_t x493; + fiat_sm2_uint1 x494; + uint32_t x495; + fiat_sm2_uint1 x496; + uint32_t x497; + fiat_sm2_uint1 x498; + uint32_t x499; + fiat_sm2_uint1 x500; + uint32_t x501; + fiat_sm2_uint1 x502; + uint32_t x503; + fiat_sm2_uint1 x504; + uint32_t x505; + fiat_sm2_uint1 x506; + uint32_t x507; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x524; + uint32_t x525; + uint32_t x526; + fiat_sm2_uint1 x527; + uint32_t x528; + fiat_sm2_uint1 x529; + uint32_t x530; + fiat_sm2_uint1 x531; + uint32_t x532; + fiat_sm2_uint1 x533; + uint32_t x534; + uint32_t x535; + fiat_sm2_uint1 x536; + uint32_t x537; + fiat_sm2_uint1 x538; + uint32_t x539; + fiat_sm2_uint1 x540; + uint32_t x541; + fiat_sm2_uint1 x542; + uint32_t x543; + fiat_sm2_uint1 x544; + uint32_t x545; + fiat_sm2_uint1 x546; + uint32_t x547; + fiat_sm2_uint1 x548; + uint32_t x549; + fiat_sm2_uint1 x550; + uint32_t x551; + fiat_sm2_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; + uint32_t x570; + fiat_sm2_uint1 x571; + uint32_t x572; + fiat_sm2_uint1 x573; + uint32_t x574; + fiat_sm2_uint1 x575; + uint32_t x576; + fiat_sm2_uint1 x577; + uint32_t x578; + fiat_sm2_uint1 x579; + uint32_t x580; + fiat_sm2_uint1 x581; + uint32_t x582; + fiat_sm2_uint1 x583; + uint32_t x584; + uint32_t x585; + fiat_sm2_uint1 x586; + uint32_t x587; + fiat_sm2_uint1 x588; + uint32_t x589; + fiat_sm2_uint1 x590; + uint32_t x591; + fiat_sm2_uint1 x592; + uint32_t x593; + fiat_sm2_uint1 x594; + uint32_t x595; + fiat_sm2_uint1 x596; + uint32_t x597; + fiat_sm2_uint1 x598; + uint32_t x599; + fiat_sm2_uint1 x600; + uint32_t x601; + fiat_sm2_uint1 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; + uint32_t x617; + fiat_sm2_uint1 x618; + uint32_t x619; + uint32_t x620; + fiat_sm2_uint1 x621; + uint32_t x622; + fiat_sm2_uint1 x623; + uint32_t x624; + fiat_sm2_uint1 x625; + uint32_t x626; + fiat_sm2_uint1 x627; + uint32_t x628; + uint32_t x629; + fiat_sm2_uint1 x630; + uint32_t x631; + fiat_sm2_uint1 x632; + uint32_t x633; + fiat_sm2_uint1 x634; + uint32_t x635; + fiat_sm2_uint1 x636; + uint32_t x637; + fiat_sm2_uint1 x638; + uint32_t x639; + fiat_sm2_uint1 x640; + uint32_t x641; + fiat_sm2_uint1 x642; + uint32_t x643; + fiat_sm2_uint1 x644; + uint32_t x645; + fiat_sm2_uint1 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; + uint32_t x664; + fiat_sm2_uint1 x665; + uint32_t x666; + fiat_sm2_uint1 x667; + uint32_t x668; + fiat_sm2_uint1 x669; + uint32_t x670; + fiat_sm2_uint1 x671; + uint32_t x672; + fiat_sm2_uint1 x673; + uint32_t x674; + fiat_sm2_uint1 x675; + uint32_t x676; + fiat_sm2_uint1 x677; + uint32_t x678; + uint32_t x679; + fiat_sm2_uint1 x680; + uint32_t x681; + fiat_sm2_uint1 x682; + uint32_t x683; + fiat_sm2_uint1 x684; + uint32_t x685; + fiat_sm2_uint1 x686; + uint32_t x687; + fiat_sm2_uint1 x688; + uint32_t x689; + fiat_sm2_uint1 x690; + uint32_t x691; + fiat_sm2_uint1 x692; + uint32_t x693; + fiat_sm2_uint1 x694; + uint32_t x695; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x712; + uint32_t x713; + uint32_t x714; + fiat_sm2_uint1 x715; + uint32_t x716; + fiat_sm2_uint1 x717; + uint32_t x718; + fiat_sm2_uint1 x719; + uint32_t x720; + fiat_sm2_uint1 x721; + uint32_t x722; + uint32_t x723; + fiat_sm2_uint1 x724; + uint32_t x725; + fiat_sm2_uint1 x726; + uint32_t x727; + fiat_sm2_uint1 x728; + uint32_t x729; + fiat_sm2_uint1 x730; + uint32_t x731; + fiat_sm2_uint1 x732; + uint32_t x733; + fiat_sm2_uint1 x734; + uint32_t x735; + fiat_sm2_uint1 x736; + uint32_t x737; + fiat_sm2_uint1 x738; + uint32_t x739; + fiat_sm2_uint1 x740; + uint32_t x741; + uint32_t x742; + fiat_sm2_uint1 x743; + uint32_t x744; + fiat_sm2_uint1 x745; + uint32_t x746; + fiat_sm2_uint1 x747; + uint32_t x748; + fiat_sm2_uint1 x749; + uint32_t x750; + fiat_sm2_uint1 x751; + uint32_t x752; + fiat_sm2_uint1 x753; + uint32_t x754; + fiat_sm2_uint1 x755; + uint32_t x756; + fiat_sm2_uint1 x757; + uint32_t x758; + fiat_sm2_uint1 x759; + uint32_t x760; + uint32_t x761; + uint32_t x762; + uint32_t x763; + uint32_t x764; + uint32_t x765; + uint32_t x766; + uint32_t x767; + 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_sm2_mulx_u32(&x9, &x10, x8, (arg2[7])); + fiat_sm2_mulx_u32(&x11, &x12, x8, (arg2[6])); + fiat_sm2_mulx_u32(&x13, &x14, x8, (arg2[5])); + fiat_sm2_mulx_u32(&x15, &x16, x8, (arg2[4])); + fiat_sm2_mulx_u32(&x17, &x18, x8, (arg2[3])); + fiat_sm2_mulx_u32(&x19, &x20, x8, (arg2[2])); + fiat_sm2_mulx_u32(&x21, &x22, x8, (arg2[1])); + fiat_sm2_mulx_u32(&x23, &x24, x8, (arg2[0])); + fiat_sm2_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_sm2_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_sm2_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_sm2_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_sm2_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_sm2_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_sm2_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_sm2_mulx_u32(&x40, &x41, x23, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x42, &x43, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x44, &x45, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x46, &x47, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x48, &x49, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x50, &x51, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x52, &x53, x23, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x54, &x55, 0x0, x53, x50); + x56 = (x55 + x51); + fiat_sm2_addcarryx_u32(&x57, &x58, 0x0, x49, x46); + fiat_sm2_addcarryx_u32(&x59, &x60, x58, x47, x44); + fiat_sm2_addcarryx_u32(&x61, &x62, x60, x45, x42); + fiat_sm2_addcarryx_u32(&x63, &x64, x62, x43, x40); + x65 = (x64 + x41); + fiat_sm2_addcarryx_u32(&x66, &x67, 0x0, x23, x52); + fiat_sm2_addcarryx_u32(&x68, &x69, x67, x25, x54); + fiat_sm2_addcarryx_u32(&x70, &x71, x69, x27, x56); + fiat_sm2_addcarryx_u32(&x72, &x73, x71, x29, x48); + fiat_sm2_addcarryx_u32(&x74, &x75, x73, x31, x57); + fiat_sm2_addcarryx_u32(&x76, &x77, x75, x33, x59); + fiat_sm2_addcarryx_u32(&x78, &x79, x77, x35, x61); + fiat_sm2_addcarryx_u32(&x80, &x81, x79, x37, x63); + fiat_sm2_addcarryx_u32(&x82, &x83, x81, x39, x65); + fiat_sm2_mulx_u32(&x84, &x85, x1, (arg2[7])); + fiat_sm2_mulx_u32(&x86, &x87, x1, (arg2[6])); + fiat_sm2_mulx_u32(&x88, &x89, x1, (arg2[5])); + fiat_sm2_mulx_u32(&x90, &x91, x1, (arg2[4])); + fiat_sm2_mulx_u32(&x92, &x93, x1, (arg2[3])); + fiat_sm2_mulx_u32(&x94, &x95, x1, (arg2[2])); + fiat_sm2_mulx_u32(&x96, &x97, x1, (arg2[1])); + fiat_sm2_mulx_u32(&x98, &x99, x1, (arg2[0])); + fiat_sm2_addcarryx_u32(&x100, &x101, 0x0, x99, x96); + fiat_sm2_addcarryx_u32(&x102, &x103, x101, x97, x94); + fiat_sm2_addcarryx_u32(&x104, &x105, x103, x95, x92); + fiat_sm2_addcarryx_u32(&x106, &x107, x105, x93, x90); + fiat_sm2_addcarryx_u32(&x108, &x109, x107, x91, x88); + fiat_sm2_addcarryx_u32(&x110, &x111, x109, x89, x86); + fiat_sm2_addcarryx_u32(&x112, &x113, x111, x87, x84); + x114 = (x113 + x85); + fiat_sm2_addcarryx_u32(&x115, &x116, 0x0, x68, x98); + fiat_sm2_addcarryx_u32(&x117, &x118, x116, x70, x100); + fiat_sm2_addcarryx_u32(&x119, &x120, x118, x72, x102); + fiat_sm2_addcarryx_u32(&x121, &x122, x120, x74, x104); + fiat_sm2_addcarryx_u32(&x123, &x124, x122, x76, x106); + fiat_sm2_addcarryx_u32(&x125, &x126, x124, x78, x108); + fiat_sm2_addcarryx_u32(&x127, &x128, x126, x80, x110); + fiat_sm2_addcarryx_u32(&x129, &x130, x128, x82, x112); + fiat_sm2_addcarryx_u32(&x131, &x132, x130, x83, x114); + fiat_sm2_mulx_u32(&x133, &x134, x115, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x135, &x136, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x137, &x138, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x139, &x140, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x141, &x142, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x143, &x144, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x145, &x146, x115, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x147, &x148, 0x0, x146, x143); + x149 = (x148 + x144); + fiat_sm2_addcarryx_u32(&x150, &x151, 0x0, x142, x139); + fiat_sm2_addcarryx_u32(&x152, &x153, x151, x140, x137); + fiat_sm2_addcarryx_u32(&x154, &x155, x153, x138, x135); + fiat_sm2_addcarryx_u32(&x156, &x157, x155, x136, x133); + x158 = (x157 + x134); + fiat_sm2_addcarryx_u32(&x159, &x160, 0x0, x115, x145); + fiat_sm2_addcarryx_u32(&x161, &x162, x160, x117, x147); + fiat_sm2_addcarryx_u32(&x163, &x164, x162, x119, x149); + fiat_sm2_addcarryx_u32(&x165, &x166, x164, x121, x141); + fiat_sm2_addcarryx_u32(&x167, &x168, x166, x123, x150); + fiat_sm2_addcarryx_u32(&x169, &x170, x168, x125, x152); + fiat_sm2_addcarryx_u32(&x171, &x172, x170, x127, x154); + fiat_sm2_addcarryx_u32(&x173, &x174, x172, x129, x156); + fiat_sm2_addcarryx_u32(&x175, &x176, x174, x131, x158); + x177 = ((uint32_t)x176 + x132); + fiat_sm2_mulx_u32(&x178, &x179, x2, (arg2[7])); + fiat_sm2_mulx_u32(&x180, &x181, x2, (arg2[6])); + fiat_sm2_mulx_u32(&x182, &x183, x2, (arg2[5])); + fiat_sm2_mulx_u32(&x184, &x185, x2, (arg2[4])); + fiat_sm2_mulx_u32(&x186, &x187, x2, (arg2[3])); + fiat_sm2_mulx_u32(&x188, &x189, x2, (arg2[2])); + fiat_sm2_mulx_u32(&x190, &x191, x2, (arg2[1])); + fiat_sm2_mulx_u32(&x192, &x193, x2, (arg2[0])); + fiat_sm2_addcarryx_u32(&x194, &x195, 0x0, x193, x190); + fiat_sm2_addcarryx_u32(&x196, &x197, x195, x191, x188); + fiat_sm2_addcarryx_u32(&x198, &x199, x197, x189, x186); + fiat_sm2_addcarryx_u32(&x200, &x201, x199, x187, x184); + fiat_sm2_addcarryx_u32(&x202, &x203, x201, x185, x182); + fiat_sm2_addcarryx_u32(&x204, &x205, x203, x183, x180); + fiat_sm2_addcarryx_u32(&x206, &x207, x205, x181, x178); + x208 = (x207 + x179); + fiat_sm2_addcarryx_u32(&x209, &x210, 0x0, x161, x192); + fiat_sm2_addcarryx_u32(&x211, &x212, x210, x163, x194); + fiat_sm2_addcarryx_u32(&x213, &x214, x212, x165, x196); + fiat_sm2_addcarryx_u32(&x215, &x216, x214, x167, x198); + fiat_sm2_addcarryx_u32(&x217, &x218, x216, x169, x200); + fiat_sm2_addcarryx_u32(&x219, &x220, x218, x171, x202); + fiat_sm2_addcarryx_u32(&x221, &x222, x220, x173, x204); + fiat_sm2_addcarryx_u32(&x223, &x224, x222, x175, x206); + fiat_sm2_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_sm2_mulx_u32(&x227, &x228, x209, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x229, &x230, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x231, &x232, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x233, &x234, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x235, &x236, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x237, &x238, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x239, &x240, x209, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x241, &x242, 0x0, x240, x237); + x243 = (x242 + x238); + fiat_sm2_addcarryx_u32(&x244, &x245, 0x0, x236, x233); + fiat_sm2_addcarryx_u32(&x246, &x247, x245, x234, x231); + fiat_sm2_addcarryx_u32(&x248, &x249, x247, x232, x229); + fiat_sm2_addcarryx_u32(&x250, &x251, x249, x230, x227); + x252 = (x251 + x228); + fiat_sm2_addcarryx_u32(&x253, &x254, 0x0, x209, x239); + fiat_sm2_addcarryx_u32(&x255, &x256, x254, x211, x241); + fiat_sm2_addcarryx_u32(&x257, &x258, x256, x213, x243); + fiat_sm2_addcarryx_u32(&x259, &x260, x258, x215, x235); + fiat_sm2_addcarryx_u32(&x261, &x262, x260, x217, x244); + fiat_sm2_addcarryx_u32(&x263, &x264, x262, x219, x246); + fiat_sm2_addcarryx_u32(&x265, &x266, x264, x221, x248); + fiat_sm2_addcarryx_u32(&x267, &x268, x266, x223, x250); + fiat_sm2_addcarryx_u32(&x269, &x270, x268, x225, x252); + x271 = ((uint32_t)x270 + x226); + fiat_sm2_mulx_u32(&x272, &x273, x3, (arg2[7])); + fiat_sm2_mulx_u32(&x274, &x275, x3, (arg2[6])); + fiat_sm2_mulx_u32(&x276, &x277, x3, (arg2[5])); + fiat_sm2_mulx_u32(&x278, &x279, x3, (arg2[4])); + fiat_sm2_mulx_u32(&x280, &x281, x3, (arg2[3])); + fiat_sm2_mulx_u32(&x282, &x283, x3, (arg2[2])); + fiat_sm2_mulx_u32(&x284, &x285, x3, (arg2[1])); + fiat_sm2_mulx_u32(&x286, &x287, x3, (arg2[0])); + fiat_sm2_addcarryx_u32(&x288, &x289, 0x0, x287, x284); + fiat_sm2_addcarryx_u32(&x290, &x291, x289, x285, x282); + fiat_sm2_addcarryx_u32(&x292, &x293, x291, x283, x280); + fiat_sm2_addcarryx_u32(&x294, &x295, x293, x281, x278); + fiat_sm2_addcarryx_u32(&x296, &x297, x295, x279, x276); + fiat_sm2_addcarryx_u32(&x298, &x299, x297, x277, x274); + fiat_sm2_addcarryx_u32(&x300, &x301, x299, x275, x272); + x302 = (x301 + x273); + fiat_sm2_addcarryx_u32(&x303, &x304, 0x0, x255, x286); + fiat_sm2_addcarryx_u32(&x305, &x306, x304, x257, x288); + fiat_sm2_addcarryx_u32(&x307, &x308, x306, x259, x290); + fiat_sm2_addcarryx_u32(&x309, &x310, x308, x261, x292); + fiat_sm2_addcarryx_u32(&x311, &x312, x310, x263, x294); + fiat_sm2_addcarryx_u32(&x313, &x314, x312, x265, x296); + fiat_sm2_addcarryx_u32(&x315, &x316, x314, x267, x298); + fiat_sm2_addcarryx_u32(&x317, &x318, x316, x269, x300); + fiat_sm2_addcarryx_u32(&x319, &x320, x318, x271, x302); + fiat_sm2_mulx_u32(&x321, &x322, x303, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x323, &x324, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x325, &x326, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x327, &x328, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x329, &x330, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x331, &x332, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x333, &x334, x303, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x335, &x336, 0x0, x334, x331); + x337 = (x336 + x332); + fiat_sm2_addcarryx_u32(&x338, &x339, 0x0, x330, x327); + fiat_sm2_addcarryx_u32(&x340, &x341, x339, x328, x325); + fiat_sm2_addcarryx_u32(&x342, &x343, x341, x326, x323); + fiat_sm2_addcarryx_u32(&x344, &x345, x343, x324, x321); + x346 = (x345 + x322); + fiat_sm2_addcarryx_u32(&x347, &x348, 0x0, x303, x333); + fiat_sm2_addcarryx_u32(&x349, &x350, x348, x305, x335); + fiat_sm2_addcarryx_u32(&x351, &x352, x350, x307, x337); + fiat_sm2_addcarryx_u32(&x353, &x354, x352, x309, x329); + fiat_sm2_addcarryx_u32(&x355, &x356, x354, x311, x338); + fiat_sm2_addcarryx_u32(&x357, &x358, x356, x313, x340); + fiat_sm2_addcarryx_u32(&x359, &x360, x358, x315, x342); + fiat_sm2_addcarryx_u32(&x361, &x362, x360, x317, x344); + fiat_sm2_addcarryx_u32(&x363, &x364, x362, x319, x346); + x365 = ((uint32_t)x364 + x320); + fiat_sm2_mulx_u32(&x366, &x367, x4, (arg2[7])); + fiat_sm2_mulx_u32(&x368, &x369, x4, (arg2[6])); + fiat_sm2_mulx_u32(&x370, &x371, x4, (arg2[5])); + fiat_sm2_mulx_u32(&x372, &x373, x4, (arg2[4])); + fiat_sm2_mulx_u32(&x374, &x375, x4, (arg2[3])); + fiat_sm2_mulx_u32(&x376, &x377, x4, (arg2[2])); + fiat_sm2_mulx_u32(&x378, &x379, x4, (arg2[1])); + fiat_sm2_mulx_u32(&x380, &x381, x4, (arg2[0])); + fiat_sm2_addcarryx_u32(&x382, &x383, 0x0, x381, x378); + fiat_sm2_addcarryx_u32(&x384, &x385, x383, x379, x376); + fiat_sm2_addcarryx_u32(&x386, &x387, x385, x377, x374); + fiat_sm2_addcarryx_u32(&x388, &x389, x387, x375, x372); + fiat_sm2_addcarryx_u32(&x390, &x391, x389, x373, x370); + fiat_sm2_addcarryx_u32(&x392, &x393, x391, x371, x368); + fiat_sm2_addcarryx_u32(&x394, &x395, x393, x369, x366); + x396 = (x395 + x367); + fiat_sm2_addcarryx_u32(&x397, &x398, 0x0, x349, x380); + fiat_sm2_addcarryx_u32(&x399, &x400, x398, x351, x382); + fiat_sm2_addcarryx_u32(&x401, &x402, x400, x353, x384); + fiat_sm2_addcarryx_u32(&x403, &x404, x402, x355, x386); + fiat_sm2_addcarryx_u32(&x405, &x406, x404, x357, x388); + fiat_sm2_addcarryx_u32(&x407, &x408, x406, x359, x390); + fiat_sm2_addcarryx_u32(&x409, &x410, x408, x361, x392); + fiat_sm2_addcarryx_u32(&x411, &x412, x410, x363, x394); + fiat_sm2_addcarryx_u32(&x413, &x414, x412, x365, x396); + fiat_sm2_mulx_u32(&x415, &x416, x397, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x417, &x418, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x419, &x420, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x421, &x422, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x423, &x424, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x425, &x426, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x427, &x428, x397, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x429, &x430, 0x0, x428, x425); + x431 = (x430 + x426); + fiat_sm2_addcarryx_u32(&x432, &x433, 0x0, x424, x421); + fiat_sm2_addcarryx_u32(&x434, &x435, x433, x422, x419); + fiat_sm2_addcarryx_u32(&x436, &x437, x435, x420, x417); + fiat_sm2_addcarryx_u32(&x438, &x439, x437, x418, x415); + x440 = (x439 + x416); + fiat_sm2_addcarryx_u32(&x441, &x442, 0x0, x397, x427); + fiat_sm2_addcarryx_u32(&x443, &x444, x442, x399, x429); + fiat_sm2_addcarryx_u32(&x445, &x446, x444, x401, x431); + fiat_sm2_addcarryx_u32(&x447, &x448, x446, x403, x423); + fiat_sm2_addcarryx_u32(&x449, &x450, x448, x405, x432); + fiat_sm2_addcarryx_u32(&x451, &x452, x450, x407, x434); + fiat_sm2_addcarryx_u32(&x453, &x454, x452, x409, x436); + fiat_sm2_addcarryx_u32(&x455, &x456, x454, x411, x438); + fiat_sm2_addcarryx_u32(&x457, &x458, x456, x413, x440); + x459 = ((uint32_t)x458 + x414); + fiat_sm2_mulx_u32(&x460, &x461, x5, (arg2[7])); + fiat_sm2_mulx_u32(&x462, &x463, x5, (arg2[6])); + fiat_sm2_mulx_u32(&x464, &x465, x5, (arg2[5])); + fiat_sm2_mulx_u32(&x466, &x467, x5, (arg2[4])); + fiat_sm2_mulx_u32(&x468, &x469, x5, (arg2[3])); + fiat_sm2_mulx_u32(&x470, &x471, x5, (arg2[2])); + fiat_sm2_mulx_u32(&x472, &x473, x5, (arg2[1])); + fiat_sm2_mulx_u32(&x474, &x475, x5, (arg2[0])); + fiat_sm2_addcarryx_u32(&x476, &x477, 0x0, x475, x472); + fiat_sm2_addcarryx_u32(&x478, &x479, x477, x473, x470); + fiat_sm2_addcarryx_u32(&x480, &x481, x479, x471, x468); + fiat_sm2_addcarryx_u32(&x482, &x483, x481, x469, x466); + fiat_sm2_addcarryx_u32(&x484, &x485, x483, x467, x464); + fiat_sm2_addcarryx_u32(&x486, &x487, x485, x465, x462); + fiat_sm2_addcarryx_u32(&x488, &x489, x487, x463, x460); + x490 = (x489 + x461); + fiat_sm2_addcarryx_u32(&x491, &x492, 0x0, x443, x474); + fiat_sm2_addcarryx_u32(&x493, &x494, x492, x445, x476); + fiat_sm2_addcarryx_u32(&x495, &x496, x494, x447, x478); + fiat_sm2_addcarryx_u32(&x497, &x498, x496, x449, x480); + fiat_sm2_addcarryx_u32(&x499, &x500, x498, x451, x482); + fiat_sm2_addcarryx_u32(&x501, &x502, x500, x453, x484); + fiat_sm2_addcarryx_u32(&x503, &x504, x502, x455, x486); + fiat_sm2_addcarryx_u32(&x505, &x506, x504, x457, x488); + fiat_sm2_addcarryx_u32(&x507, &x508, x506, x459, x490); + fiat_sm2_mulx_u32(&x509, &x510, x491, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x511, &x512, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x513, &x514, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x515, &x516, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x517, &x518, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x519, &x520, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x521, &x522, x491, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x523, &x524, 0x0, x522, x519); + x525 = (x524 + x520); + fiat_sm2_addcarryx_u32(&x526, &x527, 0x0, x518, x515); + fiat_sm2_addcarryx_u32(&x528, &x529, x527, x516, x513); + fiat_sm2_addcarryx_u32(&x530, &x531, x529, x514, x511); + fiat_sm2_addcarryx_u32(&x532, &x533, x531, x512, x509); + x534 = (x533 + x510); + fiat_sm2_addcarryx_u32(&x535, &x536, 0x0, x491, x521); + fiat_sm2_addcarryx_u32(&x537, &x538, x536, x493, x523); + fiat_sm2_addcarryx_u32(&x539, &x540, x538, x495, x525); + fiat_sm2_addcarryx_u32(&x541, &x542, x540, x497, x517); + fiat_sm2_addcarryx_u32(&x543, &x544, x542, x499, x526); + fiat_sm2_addcarryx_u32(&x545, &x546, x544, x501, x528); + fiat_sm2_addcarryx_u32(&x547, &x548, x546, x503, x530); + fiat_sm2_addcarryx_u32(&x549, &x550, x548, x505, x532); + fiat_sm2_addcarryx_u32(&x551, &x552, x550, x507, x534); + x553 = ((uint32_t)x552 + x508); + fiat_sm2_mulx_u32(&x554, &x555, x6, (arg2[7])); + fiat_sm2_mulx_u32(&x556, &x557, x6, (arg2[6])); + fiat_sm2_mulx_u32(&x558, &x559, x6, (arg2[5])); + fiat_sm2_mulx_u32(&x560, &x561, x6, (arg2[4])); + fiat_sm2_mulx_u32(&x562, &x563, x6, (arg2[3])); + fiat_sm2_mulx_u32(&x564, &x565, x6, (arg2[2])); + fiat_sm2_mulx_u32(&x566, &x567, x6, (arg2[1])); + fiat_sm2_mulx_u32(&x568, &x569, x6, (arg2[0])); + fiat_sm2_addcarryx_u32(&x570, &x571, 0x0, x569, x566); + fiat_sm2_addcarryx_u32(&x572, &x573, x571, x567, x564); + fiat_sm2_addcarryx_u32(&x574, &x575, x573, x565, x562); + fiat_sm2_addcarryx_u32(&x576, &x577, x575, x563, x560); + fiat_sm2_addcarryx_u32(&x578, &x579, x577, x561, x558); + fiat_sm2_addcarryx_u32(&x580, &x581, x579, x559, x556); + fiat_sm2_addcarryx_u32(&x582, &x583, x581, x557, x554); + x584 = (x583 + x555); + fiat_sm2_addcarryx_u32(&x585, &x586, 0x0, x537, x568); + fiat_sm2_addcarryx_u32(&x587, &x588, x586, x539, x570); + fiat_sm2_addcarryx_u32(&x589, &x590, x588, x541, x572); + fiat_sm2_addcarryx_u32(&x591, &x592, x590, x543, x574); + fiat_sm2_addcarryx_u32(&x593, &x594, x592, x545, x576); + fiat_sm2_addcarryx_u32(&x595, &x596, x594, x547, x578); + fiat_sm2_addcarryx_u32(&x597, &x598, x596, x549, x580); + fiat_sm2_addcarryx_u32(&x599, &x600, x598, x551, x582); + fiat_sm2_addcarryx_u32(&x601, &x602, x600, x553, x584); + fiat_sm2_mulx_u32(&x603, &x604, x585, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x605, &x606, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x607, &x608, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x609, &x610, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x611, &x612, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x613, &x614, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x615, &x616, x585, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x617, &x618, 0x0, x616, x613); + x619 = (x618 + x614); + fiat_sm2_addcarryx_u32(&x620, &x621, 0x0, x612, x609); + fiat_sm2_addcarryx_u32(&x622, &x623, x621, x610, x607); + fiat_sm2_addcarryx_u32(&x624, &x625, x623, x608, x605); + fiat_sm2_addcarryx_u32(&x626, &x627, x625, x606, x603); + x628 = (x627 + x604); + fiat_sm2_addcarryx_u32(&x629, &x630, 0x0, x585, x615); + fiat_sm2_addcarryx_u32(&x631, &x632, x630, x587, x617); + fiat_sm2_addcarryx_u32(&x633, &x634, x632, x589, x619); + fiat_sm2_addcarryx_u32(&x635, &x636, x634, x591, x611); + fiat_sm2_addcarryx_u32(&x637, &x638, x636, x593, x620); + fiat_sm2_addcarryx_u32(&x639, &x640, x638, x595, x622); + fiat_sm2_addcarryx_u32(&x641, &x642, x640, x597, x624); + fiat_sm2_addcarryx_u32(&x643, &x644, x642, x599, x626); + fiat_sm2_addcarryx_u32(&x645, &x646, x644, x601, x628); + x647 = ((uint32_t)x646 + x602); + fiat_sm2_mulx_u32(&x648, &x649, x7, (arg2[7])); + fiat_sm2_mulx_u32(&x650, &x651, x7, (arg2[6])); + fiat_sm2_mulx_u32(&x652, &x653, x7, (arg2[5])); + fiat_sm2_mulx_u32(&x654, &x655, x7, (arg2[4])); + fiat_sm2_mulx_u32(&x656, &x657, x7, (arg2[3])); + fiat_sm2_mulx_u32(&x658, &x659, x7, (arg2[2])); + fiat_sm2_mulx_u32(&x660, &x661, x7, (arg2[1])); + fiat_sm2_mulx_u32(&x662, &x663, x7, (arg2[0])); + fiat_sm2_addcarryx_u32(&x664, &x665, 0x0, x663, x660); + fiat_sm2_addcarryx_u32(&x666, &x667, x665, x661, x658); + fiat_sm2_addcarryx_u32(&x668, &x669, x667, x659, x656); + fiat_sm2_addcarryx_u32(&x670, &x671, x669, x657, x654); + fiat_sm2_addcarryx_u32(&x672, &x673, x671, x655, x652); + fiat_sm2_addcarryx_u32(&x674, &x675, x673, x653, x650); + fiat_sm2_addcarryx_u32(&x676, &x677, x675, x651, x648); + x678 = (x677 + x649); + fiat_sm2_addcarryx_u32(&x679, &x680, 0x0, x631, x662); + fiat_sm2_addcarryx_u32(&x681, &x682, x680, x633, x664); + fiat_sm2_addcarryx_u32(&x683, &x684, x682, x635, x666); + fiat_sm2_addcarryx_u32(&x685, &x686, x684, x637, x668); + fiat_sm2_addcarryx_u32(&x687, &x688, x686, x639, x670); + fiat_sm2_addcarryx_u32(&x689, &x690, x688, x641, x672); + fiat_sm2_addcarryx_u32(&x691, &x692, x690, x643, x674); + fiat_sm2_addcarryx_u32(&x693, &x694, x692, x645, x676); + fiat_sm2_addcarryx_u32(&x695, &x696, x694, x647, x678); + fiat_sm2_mulx_u32(&x697, &x698, x679, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x699, &x700, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x701, &x702, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x703, &x704, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x705, &x706, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x707, &x708, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x709, &x710, x679, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x711, &x712, 0x0, x710, x707); + x713 = (x712 + x708); + fiat_sm2_addcarryx_u32(&x714, &x715, 0x0, x706, x703); + fiat_sm2_addcarryx_u32(&x716, &x717, x715, x704, x701); + fiat_sm2_addcarryx_u32(&x718, &x719, x717, x702, x699); + fiat_sm2_addcarryx_u32(&x720, &x721, x719, x700, x697); + x722 = (x721 + x698); + fiat_sm2_addcarryx_u32(&x723, &x724, 0x0, x679, x709); + fiat_sm2_addcarryx_u32(&x725, &x726, x724, x681, x711); + fiat_sm2_addcarryx_u32(&x727, &x728, x726, x683, x713); + fiat_sm2_addcarryx_u32(&x729, &x730, x728, x685, x705); + fiat_sm2_addcarryx_u32(&x731, &x732, x730, x687, x714); + fiat_sm2_addcarryx_u32(&x733, &x734, x732, x689, x716); + fiat_sm2_addcarryx_u32(&x735, &x736, x734, x691, x718); + fiat_sm2_addcarryx_u32(&x737, &x738, x736, x693, x720); + fiat_sm2_addcarryx_u32(&x739, &x740, x738, x695, x722); + x741 = ((uint32_t)x740 + x696); + fiat_sm2_subborrowx_u32(&x742, &x743, 0x0, x725, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x744, &x745, x743, x727, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x746, &x747, x745, x729, 0x0); + fiat_sm2_subborrowx_u32(&x748, &x749, x747, x731, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x750, &x751, x749, x733, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x752, &x753, x751, x735, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x754, &x755, x753, x737, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x756, &x757, x755, x739, UINT32_C(0xfffffffe)); + fiat_sm2_subborrowx_u32(&x758, &x759, x757, x741, 0x0); + fiat_sm2_cmovznz_u32(&x760, x759, x742, x725); + fiat_sm2_cmovznz_u32(&x761, x759, x744, x727); + fiat_sm2_cmovznz_u32(&x762, x759, x746, x729); + fiat_sm2_cmovznz_u32(&x763, x759, x748, x731); + fiat_sm2_cmovznz_u32(&x764, x759, x750, x733); + fiat_sm2_cmovznz_u32(&x765, x759, x752, x735); + fiat_sm2_cmovznz_u32(&x766, x759, x754, x737); + fiat_sm2_cmovznz_u32(&x767, x759, x756, x739); + out1[0] = x760; + out1[1] = x761; + out1[2] = x762; + out1[3] = x763; + out1[4] = x764; + out1[5] = x765; + out1[6] = x766; + out1[7] = x767; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_square(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_uint1 x26; + uint32_t x27; + fiat_sm2_uint1 x28; + uint32_t x29; + fiat_sm2_uint1 x30; + uint32_t x31; + fiat_sm2_uint1 x32; + uint32_t x33; + fiat_sm2_uint1 x34; + uint32_t x35; + fiat_sm2_uint1 x36; + uint32_t x37; + fiat_sm2_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; + fiat_sm2_uint1 x55; + uint32_t x56; + uint32_t x57; + fiat_sm2_uint1 x58; + uint32_t x59; + fiat_sm2_uint1 x60; + uint32_t x61; + fiat_sm2_uint1 x62; + uint32_t x63; + fiat_sm2_uint1 x64; + uint32_t x65; + uint32_t x66; + fiat_sm2_uint1 x67; + uint32_t x68; + fiat_sm2_uint1 x69; + uint32_t x70; + fiat_sm2_uint1 x71; + uint32_t x72; + fiat_sm2_uint1 x73; + uint32_t x74; + fiat_sm2_uint1 x75; + uint32_t x76; + fiat_sm2_uint1 x77; + uint32_t x78; + fiat_sm2_uint1 x79; + uint32_t x80; + fiat_sm2_uint1 x81; + uint32_t x82; + fiat_sm2_uint1 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; + uint32_t x100; + fiat_sm2_uint1 x101; + uint32_t x102; + fiat_sm2_uint1 x103; + uint32_t x104; + fiat_sm2_uint1 x105; + uint32_t x106; + fiat_sm2_uint1 x107; + uint32_t x108; + fiat_sm2_uint1 x109; + uint32_t x110; + fiat_sm2_uint1 x111; + uint32_t x112; + fiat_sm2_uint1 x113; + uint32_t x114; + uint32_t x115; + fiat_sm2_uint1 x116; + uint32_t x117; + fiat_sm2_uint1 x118; + uint32_t x119; + fiat_sm2_uint1 x120; + uint32_t x121; + fiat_sm2_uint1 x122; + uint32_t x123; + fiat_sm2_uint1 x124; + uint32_t x125; + fiat_sm2_uint1 x126; + uint32_t x127; + fiat_sm2_uint1 x128; + uint32_t x129; + fiat_sm2_uint1 x130; + uint32_t x131; + fiat_sm2_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; + fiat_sm2_uint1 x148; + uint32_t x149; + uint32_t x150; + fiat_sm2_uint1 x151; + uint32_t x152; + fiat_sm2_uint1 x153; + uint32_t x154; + fiat_sm2_uint1 x155; + uint32_t x156; + fiat_sm2_uint1 x157; + uint32_t x158; + uint32_t x159; + fiat_sm2_uint1 x160; + uint32_t x161; + fiat_sm2_uint1 x162; + uint32_t x163; + fiat_sm2_uint1 x164; + uint32_t x165; + fiat_sm2_uint1 x166; + uint32_t x167; + fiat_sm2_uint1 x168; + uint32_t x169; + fiat_sm2_uint1 x170; + uint32_t x171; + fiat_sm2_uint1 x172; + uint32_t x173; + fiat_sm2_uint1 x174; + uint32_t x175; + fiat_sm2_uint1 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; + uint32_t x190; + uint32_t x191; + uint32_t x192; + uint32_t x193; + uint32_t x194; + fiat_sm2_uint1 x195; + uint32_t x196; + fiat_sm2_uint1 x197; + uint32_t x198; + fiat_sm2_uint1 x199; + uint32_t x200; + fiat_sm2_uint1 x201; + uint32_t x202; + fiat_sm2_uint1 x203; + uint32_t x204; + fiat_sm2_uint1 x205; + uint32_t x206; + fiat_sm2_uint1 x207; + uint32_t x208; + uint32_t x209; + fiat_sm2_uint1 x210; + uint32_t x211; + fiat_sm2_uint1 x212; + uint32_t x213; + fiat_sm2_uint1 x214; + uint32_t x215; + fiat_sm2_uint1 x216; + uint32_t x217; + fiat_sm2_uint1 x218; + uint32_t x219; + fiat_sm2_uint1 x220; + uint32_t x221; + fiat_sm2_uint1 x222; + uint32_t x223; + fiat_sm2_uint1 x224; + uint32_t x225; + fiat_sm2_uint1 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; + uint32_t x236; + uint32_t x237; + uint32_t x238; + uint32_t x239; + uint32_t x240; + uint32_t x241; + fiat_sm2_uint1 x242; + uint32_t x243; + uint32_t x244; + fiat_sm2_uint1 x245; + uint32_t x246; + fiat_sm2_uint1 x247; + uint32_t x248; + fiat_sm2_uint1 x249; + uint32_t x250; + fiat_sm2_uint1 x251; + uint32_t x252; + uint32_t x253; + fiat_sm2_uint1 x254; + uint32_t x255; + fiat_sm2_uint1 x256; + uint32_t x257; + fiat_sm2_uint1 x258; + uint32_t x259; + fiat_sm2_uint1 x260; + uint32_t x261; + fiat_sm2_uint1 x262; + uint32_t x263; + fiat_sm2_uint1 x264; + uint32_t x265; + fiat_sm2_uint1 x266; + uint32_t x267; + fiat_sm2_uint1 x268; + uint32_t x269; + fiat_sm2_uint1 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; + uint32_t x285; + uint32_t x286; + uint32_t x287; + uint32_t x288; + fiat_sm2_uint1 x289; + uint32_t x290; + fiat_sm2_uint1 x291; + uint32_t x292; + fiat_sm2_uint1 x293; + uint32_t x294; + fiat_sm2_uint1 x295; + uint32_t x296; + fiat_sm2_uint1 x297; + uint32_t x298; + fiat_sm2_uint1 x299; + uint32_t x300; + fiat_sm2_uint1 x301; + uint32_t x302; + uint32_t x303; + fiat_sm2_uint1 x304; + uint32_t x305; + fiat_sm2_uint1 x306; + uint32_t x307; + fiat_sm2_uint1 x308; + uint32_t x309; + fiat_sm2_uint1 x310; + uint32_t x311; + fiat_sm2_uint1 x312; + uint32_t x313; + fiat_sm2_uint1 x314; + uint32_t x315; + fiat_sm2_uint1 x316; + uint32_t x317; + fiat_sm2_uint1 x318; + uint32_t x319; + fiat_sm2_uint1 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; + uint32_t x335; + fiat_sm2_uint1 x336; + uint32_t x337; + uint32_t x338; + fiat_sm2_uint1 x339; + uint32_t x340; + fiat_sm2_uint1 x341; + uint32_t x342; + fiat_sm2_uint1 x343; + uint32_t x344; + fiat_sm2_uint1 x345; + uint32_t x346; + uint32_t x347; + fiat_sm2_uint1 x348; + uint32_t x349; + fiat_sm2_uint1 x350; + uint32_t x351; + fiat_sm2_uint1 x352; + uint32_t x353; + fiat_sm2_uint1 x354; + uint32_t x355; + fiat_sm2_uint1 x356; + uint32_t x357; + fiat_sm2_uint1 x358; + uint32_t x359; + fiat_sm2_uint1 x360; + uint32_t x361; + fiat_sm2_uint1 x362; + uint32_t x363; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x383; + uint32_t x384; + fiat_sm2_uint1 x385; + uint32_t x386; + fiat_sm2_uint1 x387; + uint32_t x388; + fiat_sm2_uint1 x389; + uint32_t x390; + fiat_sm2_uint1 x391; + uint32_t x392; + fiat_sm2_uint1 x393; + uint32_t x394; + fiat_sm2_uint1 x395; + uint32_t x396; + uint32_t x397; + fiat_sm2_uint1 x398; + uint32_t x399; + fiat_sm2_uint1 x400; + uint32_t x401; + fiat_sm2_uint1 x402; + uint32_t x403; + fiat_sm2_uint1 x404; + uint32_t x405; + fiat_sm2_uint1 x406; + uint32_t x407; + fiat_sm2_uint1 x408; + uint32_t x409; + fiat_sm2_uint1 x410; + uint32_t x411; + fiat_sm2_uint1 x412; + uint32_t x413; + fiat_sm2_uint1 x414; + uint32_t x415; + uint32_t x416; + uint32_t x417; + uint32_t 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; + fiat_sm2_uint1 x430; + uint32_t x431; + uint32_t x432; + fiat_sm2_uint1 x433; + uint32_t x434; + fiat_sm2_uint1 x435; + uint32_t x436; + fiat_sm2_uint1 x437; + uint32_t x438; + fiat_sm2_uint1 x439; + uint32_t x440; + uint32_t x441; + fiat_sm2_uint1 x442; + uint32_t x443; + fiat_sm2_uint1 x444; + uint32_t x445; + fiat_sm2_uint1 x446; + uint32_t x447; + fiat_sm2_uint1 x448; + uint32_t x449; + fiat_sm2_uint1 x450; + uint32_t x451; + fiat_sm2_uint1 x452; + uint32_t x453; + fiat_sm2_uint1 x454; + uint32_t x455; + fiat_sm2_uint1 x456; + uint32_t x457; + fiat_sm2_uint1 x458; + uint32_t x459; + uint32_t x460; + uint32_t x461; + uint32_t x462; + uint32_t 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; + fiat_sm2_uint1 x477; + uint32_t x478; + fiat_sm2_uint1 x479; + uint32_t x480; + fiat_sm2_uint1 x481; + uint32_t x482; + fiat_sm2_uint1 x483; + uint32_t x484; + fiat_sm2_uint1 x485; + uint32_t x486; + fiat_sm2_uint1 x487; + uint32_t x488; + fiat_sm2_uint1 x489; + uint32_t x490; + uint32_t x491; + fiat_sm2_uint1 x492; + uint32_t x493; + fiat_sm2_uint1 x494; + uint32_t x495; + fiat_sm2_uint1 x496; + uint32_t x497; + fiat_sm2_uint1 x498; + uint32_t x499; + fiat_sm2_uint1 x500; + uint32_t x501; + fiat_sm2_uint1 x502; + uint32_t x503; + fiat_sm2_uint1 x504; + uint32_t x505; + fiat_sm2_uint1 x506; + uint32_t x507; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x524; + uint32_t x525; + uint32_t x526; + fiat_sm2_uint1 x527; + uint32_t x528; + fiat_sm2_uint1 x529; + uint32_t x530; + fiat_sm2_uint1 x531; + uint32_t x532; + fiat_sm2_uint1 x533; + uint32_t x534; + uint32_t x535; + fiat_sm2_uint1 x536; + uint32_t x537; + fiat_sm2_uint1 x538; + uint32_t x539; + fiat_sm2_uint1 x540; + uint32_t x541; + fiat_sm2_uint1 x542; + uint32_t x543; + fiat_sm2_uint1 x544; + uint32_t x545; + fiat_sm2_uint1 x546; + uint32_t x547; + fiat_sm2_uint1 x548; + uint32_t x549; + fiat_sm2_uint1 x550; + uint32_t x551; + fiat_sm2_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; + uint32_t x570; + fiat_sm2_uint1 x571; + uint32_t x572; + fiat_sm2_uint1 x573; + uint32_t x574; + fiat_sm2_uint1 x575; + uint32_t x576; + fiat_sm2_uint1 x577; + uint32_t x578; + fiat_sm2_uint1 x579; + uint32_t x580; + fiat_sm2_uint1 x581; + uint32_t x582; + fiat_sm2_uint1 x583; + uint32_t x584; + uint32_t x585; + fiat_sm2_uint1 x586; + uint32_t x587; + fiat_sm2_uint1 x588; + uint32_t x589; + fiat_sm2_uint1 x590; + uint32_t x591; + fiat_sm2_uint1 x592; + uint32_t x593; + fiat_sm2_uint1 x594; + uint32_t x595; + fiat_sm2_uint1 x596; + uint32_t x597; + fiat_sm2_uint1 x598; + uint32_t x599; + fiat_sm2_uint1 x600; + uint32_t x601; + fiat_sm2_uint1 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; + uint32_t x617; + fiat_sm2_uint1 x618; + uint32_t x619; + uint32_t x620; + fiat_sm2_uint1 x621; + uint32_t x622; + fiat_sm2_uint1 x623; + uint32_t x624; + fiat_sm2_uint1 x625; + uint32_t x626; + fiat_sm2_uint1 x627; + uint32_t x628; + uint32_t x629; + fiat_sm2_uint1 x630; + uint32_t x631; + fiat_sm2_uint1 x632; + uint32_t x633; + fiat_sm2_uint1 x634; + uint32_t x635; + fiat_sm2_uint1 x636; + uint32_t x637; + fiat_sm2_uint1 x638; + uint32_t x639; + fiat_sm2_uint1 x640; + uint32_t x641; + fiat_sm2_uint1 x642; + uint32_t x643; + fiat_sm2_uint1 x644; + uint32_t x645; + fiat_sm2_uint1 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; + uint32_t x664; + fiat_sm2_uint1 x665; + uint32_t x666; + fiat_sm2_uint1 x667; + uint32_t x668; + fiat_sm2_uint1 x669; + uint32_t x670; + fiat_sm2_uint1 x671; + uint32_t x672; + fiat_sm2_uint1 x673; + uint32_t x674; + fiat_sm2_uint1 x675; + uint32_t x676; + fiat_sm2_uint1 x677; + uint32_t x678; + uint32_t x679; + fiat_sm2_uint1 x680; + uint32_t x681; + fiat_sm2_uint1 x682; + uint32_t x683; + fiat_sm2_uint1 x684; + uint32_t x685; + fiat_sm2_uint1 x686; + uint32_t x687; + fiat_sm2_uint1 x688; + uint32_t x689; + fiat_sm2_uint1 x690; + uint32_t x691; + fiat_sm2_uint1 x692; + uint32_t x693; + fiat_sm2_uint1 x694; + uint32_t x695; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x712; + uint32_t x713; + uint32_t x714; + fiat_sm2_uint1 x715; + uint32_t x716; + fiat_sm2_uint1 x717; + uint32_t x718; + fiat_sm2_uint1 x719; + uint32_t x720; + fiat_sm2_uint1 x721; + uint32_t x722; + uint32_t x723; + fiat_sm2_uint1 x724; + uint32_t x725; + fiat_sm2_uint1 x726; + uint32_t x727; + fiat_sm2_uint1 x728; + uint32_t x729; + fiat_sm2_uint1 x730; + uint32_t x731; + fiat_sm2_uint1 x732; + uint32_t x733; + fiat_sm2_uint1 x734; + uint32_t x735; + fiat_sm2_uint1 x736; + uint32_t x737; + fiat_sm2_uint1 x738; + uint32_t x739; + fiat_sm2_uint1 x740; + uint32_t x741; + uint32_t x742; + fiat_sm2_uint1 x743; + uint32_t x744; + fiat_sm2_uint1 x745; + uint32_t x746; + fiat_sm2_uint1 x747; + uint32_t x748; + fiat_sm2_uint1 x749; + uint32_t x750; + fiat_sm2_uint1 x751; + uint32_t x752; + fiat_sm2_uint1 x753; + uint32_t x754; + fiat_sm2_uint1 x755; + uint32_t x756; + fiat_sm2_uint1 x757; + uint32_t x758; + fiat_sm2_uint1 x759; + uint32_t x760; + uint32_t x761; + uint32_t x762; + uint32_t x763; + uint32_t x764; + uint32_t x765; + uint32_t x766; + uint32_t x767; + 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_sm2_mulx_u32(&x9, &x10, x8, (arg1[7])); + fiat_sm2_mulx_u32(&x11, &x12, x8, (arg1[6])); + fiat_sm2_mulx_u32(&x13, &x14, x8, (arg1[5])); + fiat_sm2_mulx_u32(&x15, &x16, x8, (arg1[4])); + fiat_sm2_mulx_u32(&x17, &x18, x8, (arg1[3])); + fiat_sm2_mulx_u32(&x19, &x20, x8, (arg1[2])); + fiat_sm2_mulx_u32(&x21, &x22, x8, (arg1[1])); + fiat_sm2_mulx_u32(&x23, &x24, x8, (arg1[0])); + fiat_sm2_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_sm2_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_sm2_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_sm2_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_sm2_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_sm2_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_sm2_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_sm2_mulx_u32(&x40, &x41, x23, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x42, &x43, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x44, &x45, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x46, &x47, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x48, &x49, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x50, &x51, x23, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x52, &x53, x23, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x54, &x55, 0x0, x53, x50); + x56 = (x55 + x51); + fiat_sm2_addcarryx_u32(&x57, &x58, 0x0, x49, x46); + fiat_sm2_addcarryx_u32(&x59, &x60, x58, x47, x44); + fiat_sm2_addcarryx_u32(&x61, &x62, x60, x45, x42); + fiat_sm2_addcarryx_u32(&x63, &x64, x62, x43, x40); + x65 = (x64 + x41); + fiat_sm2_addcarryx_u32(&x66, &x67, 0x0, x23, x52); + fiat_sm2_addcarryx_u32(&x68, &x69, x67, x25, x54); + fiat_sm2_addcarryx_u32(&x70, &x71, x69, x27, x56); + fiat_sm2_addcarryx_u32(&x72, &x73, x71, x29, x48); + fiat_sm2_addcarryx_u32(&x74, &x75, x73, x31, x57); + fiat_sm2_addcarryx_u32(&x76, &x77, x75, x33, x59); + fiat_sm2_addcarryx_u32(&x78, &x79, x77, x35, x61); + fiat_sm2_addcarryx_u32(&x80, &x81, x79, x37, x63); + fiat_sm2_addcarryx_u32(&x82, &x83, x81, x39, x65); + fiat_sm2_mulx_u32(&x84, &x85, x1, (arg1[7])); + fiat_sm2_mulx_u32(&x86, &x87, x1, (arg1[6])); + fiat_sm2_mulx_u32(&x88, &x89, x1, (arg1[5])); + fiat_sm2_mulx_u32(&x90, &x91, x1, (arg1[4])); + fiat_sm2_mulx_u32(&x92, &x93, x1, (arg1[3])); + fiat_sm2_mulx_u32(&x94, &x95, x1, (arg1[2])); + fiat_sm2_mulx_u32(&x96, &x97, x1, (arg1[1])); + fiat_sm2_mulx_u32(&x98, &x99, x1, (arg1[0])); + fiat_sm2_addcarryx_u32(&x100, &x101, 0x0, x99, x96); + fiat_sm2_addcarryx_u32(&x102, &x103, x101, x97, x94); + fiat_sm2_addcarryx_u32(&x104, &x105, x103, x95, x92); + fiat_sm2_addcarryx_u32(&x106, &x107, x105, x93, x90); + fiat_sm2_addcarryx_u32(&x108, &x109, x107, x91, x88); + fiat_sm2_addcarryx_u32(&x110, &x111, x109, x89, x86); + fiat_sm2_addcarryx_u32(&x112, &x113, x111, x87, x84); + x114 = (x113 + x85); + fiat_sm2_addcarryx_u32(&x115, &x116, 0x0, x68, x98); + fiat_sm2_addcarryx_u32(&x117, &x118, x116, x70, x100); + fiat_sm2_addcarryx_u32(&x119, &x120, x118, x72, x102); + fiat_sm2_addcarryx_u32(&x121, &x122, x120, x74, x104); + fiat_sm2_addcarryx_u32(&x123, &x124, x122, x76, x106); + fiat_sm2_addcarryx_u32(&x125, &x126, x124, x78, x108); + fiat_sm2_addcarryx_u32(&x127, &x128, x126, x80, x110); + fiat_sm2_addcarryx_u32(&x129, &x130, x128, x82, x112); + fiat_sm2_addcarryx_u32(&x131, &x132, x130, x83, x114); + fiat_sm2_mulx_u32(&x133, &x134, x115, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x135, &x136, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x137, &x138, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x139, &x140, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x141, &x142, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x143, &x144, x115, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x145, &x146, x115, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x147, &x148, 0x0, x146, x143); + x149 = (x148 + x144); + fiat_sm2_addcarryx_u32(&x150, &x151, 0x0, x142, x139); + fiat_sm2_addcarryx_u32(&x152, &x153, x151, x140, x137); + fiat_sm2_addcarryx_u32(&x154, &x155, x153, x138, x135); + fiat_sm2_addcarryx_u32(&x156, &x157, x155, x136, x133); + x158 = (x157 + x134); + fiat_sm2_addcarryx_u32(&x159, &x160, 0x0, x115, x145); + fiat_sm2_addcarryx_u32(&x161, &x162, x160, x117, x147); + fiat_sm2_addcarryx_u32(&x163, &x164, x162, x119, x149); + fiat_sm2_addcarryx_u32(&x165, &x166, x164, x121, x141); + fiat_sm2_addcarryx_u32(&x167, &x168, x166, x123, x150); + fiat_sm2_addcarryx_u32(&x169, &x170, x168, x125, x152); + fiat_sm2_addcarryx_u32(&x171, &x172, x170, x127, x154); + fiat_sm2_addcarryx_u32(&x173, &x174, x172, x129, x156); + fiat_sm2_addcarryx_u32(&x175, &x176, x174, x131, x158); + x177 = ((uint32_t)x176 + x132); + fiat_sm2_mulx_u32(&x178, &x179, x2, (arg1[7])); + fiat_sm2_mulx_u32(&x180, &x181, x2, (arg1[6])); + fiat_sm2_mulx_u32(&x182, &x183, x2, (arg1[5])); + fiat_sm2_mulx_u32(&x184, &x185, x2, (arg1[4])); + fiat_sm2_mulx_u32(&x186, &x187, x2, (arg1[3])); + fiat_sm2_mulx_u32(&x188, &x189, x2, (arg1[2])); + fiat_sm2_mulx_u32(&x190, &x191, x2, (arg1[1])); + fiat_sm2_mulx_u32(&x192, &x193, x2, (arg1[0])); + fiat_sm2_addcarryx_u32(&x194, &x195, 0x0, x193, x190); + fiat_sm2_addcarryx_u32(&x196, &x197, x195, x191, x188); + fiat_sm2_addcarryx_u32(&x198, &x199, x197, x189, x186); + fiat_sm2_addcarryx_u32(&x200, &x201, x199, x187, x184); + fiat_sm2_addcarryx_u32(&x202, &x203, x201, x185, x182); + fiat_sm2_addcarryx_u32(&x204, &x205, x203, x183, x180); + fiat_sm2_addcarryx_u32(&x206, &x207, x205, x181, x178); + x208 = (x207 + x179); + fiat_sm2_addcarryx_u32(&x209, &x210, 0x0, x161, x192); + fiat_sm2_addcarryx_u32(&x211, &x212, x210, x163, x194); + fiat_sm2_addcarryx_u32(&x213, &x214, x212, x165, x196); + fiat_sm2_addcarryx_u32(&x215, &x216, x214, x167, x198); + fiat_sm2_addcarryx_u32(&x217, &x218, x216, x169, x200); + fiat_sm2_addcarryx_u32(&x219, &x220, x218, x171, x202); + fiat_sm2_addcarryx_u32(&x221, &x222, x220, x173, x204); + fiat_sm2_addcarryx_u32(&x223, &x224, x222, x175, x206); + fiat_sm2_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_sm2_mulx_u32(&x227, &x228, x209, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x229, &x230, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x231, &x232, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x233, &x234, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x235, &x236, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x237, &x238, x209, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x239, &x240, x209, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x241, &x242, 0x0, x240, x237); + x243 = (x242 + x238); + fiat_sm2_addcarryx_u32(&x244, &x245, 0x0, x236, x233); + fiat_sm2_addcarryx_u32(&x246, &x247, x245, x234, x231); + fiat_sm2_addcarryx_u32(&x248, &x249, x247, x232, x229); + fiat_sm2_addcarryx_u32(&x250, &x251, x249, x230, x227); + x252 = (x251 + x228); + fiat_sm2_addcarryx_u32(&x253, &x254, 0x0, x209, x239); + fiat_sm2_addcarryx_u32(&x255, &x256, x254, x211, x241); + fiat_sm2_addcarryx_u32(&x257, &x258, x256, x213, x243); + fiat_sm2_addcarryx_u32(&x259, &x260, x258, x215, x235); + fiat_sm2_addcarryx_u32(&x261, &x262, x260, x217, x244); + fiat_sm2_addcarryx_u32(&x263, &x264, x262, x219, x246); + fiat_sm2_addcarryx_u32(&x265, &x266, x264, x221, x248); + fiat_sm2_addcarryx_u32(&x267, &x268, x266, x223, x250); + fiat_sm2_addcarryx_u32(&x269, &x270, x268, x225, x252); + x271 = ((uint32_t)x270 + x226); + fiat_sm2_mulx_u32(&x272, &x273, x3, (arg1[7])); + fiat_sm2_mulx_u32(&x274, &x275, x3, (arg1[6])); + fiat_sm2_mulx_u32(&x276, &x277, x3, (arg1[5])); + fiat_sm2_mulx_u32(&x278, &x279, x3, (arg1[4])); + fiat_sm2_mulx_u32(&x280, &x281, x3, (arg1[3])); + fiat_sm2_mulx_u32(&x282, &x283, x3, (arg1[2])); + fiat_sm2_mulx_u32(&x284, &x285, x3, (arg1[1])); + fiat_sm2_mulx_u32(&x286, &x287, x3, (arg1[0])); + fiat_sm2_addcarryx_u32(&x288, &x289, 0x0, x287, x284); + fiat_sm2_addcarryx_u32(&x290, &x291, x289, x285, x282); + fiat_sm2_addcarryx_u32(&x292, &x293, x291, x283, x280); + fiat_sm2_addcarryx_u32(&x294, &x295, x293, x281, x278); + fiat_sm2_addcarryx_u32(&x296, &x297, x295, x279, x276); + fiat_sm2_addcarryx_u32(&x298, &x299, x297, x277, x274); + fiat_sm2_addcarryx_u32(&x300, &x301, x299, x275, x272); + x302 = (x301 + x273); + fiat_sm2_addcarryx_u32(&x303, &x304, 0x0, x255, x286); + fiat_sm2_addcarryx_u32(&x305, &x306, x304, x257, x288); + fiat_sm2_addcarryx_u32(&x307, &x308, x306, x259, x290); + fiat_sm2_addcarryx_u32(&x309, &x310, x308, x261, x292); + fiat_sm2_addcarryx_u32(&x311, &x312, x310, x263, x294); + fiat_sm2_addcarryx_u32(&x313, &x314, x312, x265, x296); + fiat_sm2_addcarryx_u32(&x315, &x316, x314, x267, x298); + fiat_sm2_addcarryx_u32(&x317, &x318, x316, x269, x300); + fiat_sm2_addcarryx_u32(&x319, &x320, x318, x271, x302); + fiat_sm2_mulx_u32(&x321, &x322, x303, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x323, &x324, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x325, &x326, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x327, &x328, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x329, &x330, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x331, &x332, x303, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x333, &x334, x303, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x335, &x336, 0x0, x334, x331); + x337 = (x336 + x332); + fiat_sm2_addcarryx_u32(&x338, &x339, 0x0, x330, x327); + fiat_sm2_addcarryx_u32(&x340, &x341, x339, x328, x325); + fiat_sm2_addcarryx_u32(&x342, &x343, x341, x326, x323); + fiat_sm2_addcarryx_u32(&x344, &x345, x343, x324, x321); + x346 = (x345 + x322); + fiat_sm2_addcarryx_u32(&x347, &x348, 0x0, x303, x333); + fiat_sm2_addcarryx_u32(&x349, &x350, x348, x305, x335); + fiat_sm2_addcarryx_u32(&x351, &x352, x350, x307, x337); + fiat_sm2_addcarryx_u32(&x353, &x354, x352, x309, x329); + fiat_sm2_addcarryx_u32(&x355, &x356, x354, x311, x338); + fiat_sm2_addcarryx_u32(&x357, &x358, x356, x313, x340); + fiat_sm2_addcarryx_u32(&x359, &x360, x358, x315, x342); + fiat_sm2_addcarryx_u32(&x361, &x362, x360, x317, x344); + fiat_sm2_addcarryx_u32(&x363, &x364, x362, x319, x346); + x365 = ((uint32_t)x364 + x320); + fiat_sm2_mulx_u32(&x366, &x367, x4, (arg1[7])); + fiat_sm2_mulx_u32(&x368, &x369, x4, (arg1[6])); + fiat_sm2_mulx_u32(&x370, &x371, x4, (arg1[5])); + fiat_sm2_mulx_u32(&x372, &x373, x4, (arg1[4])); + fiat_sm2_mulx_u32(&x374, &x375, x4, (arg1[3])); + fiat_sm2_mulx_u32(&x376, &x377, x4, (arg1[2])); + fiat_sm2_mulx_u32(&x378, &x379, x4, (arg1[1])); + fiat_sm2_mulx_u32(&x380, &x381, x4, (arg1[0])); + fiat_sm2_addcarryx_u32(&x382, &x383, 0x0, x381, x378); + fiat_sm2_addcarryx_u32(&x384, &x385, x383, x379, x376); + fiat_sm2_addcarryx_u32(&x386, &x387, x385, x377, x374); + fiat_sm2_addcarryx_u32(&x388, &x389, x387, x375, x372); + fiat_sm2_addcarryx_u32(&x390, &x391, x389, x373, x370); + fiat_sm2_addcarryx_u32(&x392, &x393, x391, x371, x368); + fiat_sm2_addcarryx_u32(&x394, &x395, x393, x369, x366); + x396 = (x395 + x367); + fiat_sm2_addcarryx_u32(&x397, &x398, 0x0, x349, x380); + fiat_sm2_addcarryx_u32(&x399, &x400, x398, x351, x382); + fiat_sm2_addcarryx_u32(&x401, &x402, x400, x353, x384); + fiat_sm2_addcarryx_u32(&x403, &x404, x402, x355, x386); + fiat_sm2_addcarryx_u32(&x405, &x406, x404, x357, x388); + fiat_sm2_addcarryx_u32(&x407, &x408, x406, x359, x390); + fiat_sm2_addcarryx_u32(&x409, &x410, x408, x361, x392); + fiat_sm2_addcarryx_u32(&x411, &x412, x410, x363, x394); + fiat_sm2_addcarryx_u32(&x413, &x414, x412, x365, x396); + fiat_sm2_mulx_u32(&x415, &x416, x397, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x417, &x418, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x419, &x420, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x421, &x422, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x423, &x424, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x425, &x426, x397, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x427, &x428, x397, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x429, &x430, 0x0, x428, x425); + x431 = (x430 + x426); + fiat_sm2_addcarryx_u32(&x432, &x433, 0x0, x424, x421); + fiat_sm2_addcarryx_u32(&x434, &x435, x433, x422, x419); + fiat_sm2_addcarryx_u32(&x436, &x437, x435, x420, x417); + fiat_sm2_addcarryx_u32(&x438, &x439, x437, x418, x415); + x440 = (x439 + x416); + fiat_sm2_addcarryx_u32(&x441, &x442, 0x0, x397, x427); + fiat_sm2_addcarryx_u32(&x443, &x444, x442, x399, x429); + fiat_sm2_addcarryx_u32(&x445, &x446, x444, x401, x431); + fiat_sm2_addcarryx_u32(&x447, &x448, x446, x403, x423); + fiat_sm2_addcarryx_u32(&x449, &x450, x448, x405, x432); + fiat_sm2_addcarryx_u32(&x451, &x452, x450, x407, x434); + fiat_sm2_addcarryx_u32(&x453, &x454, x452, x409, x436); + fiat_sm2_addcarryx_u32(&x455, &x456, x454, x411, x438); + fiat_sm2_addcarryx_u32(&x457, &x458, x456, x413, x440); + x459 = ((uint32_t)x458 + x414); + fiat_sm2_mulx_u32(&x460, &x461, x5, (arg1[7])); + fiat_sm2_mulx_u32(&x462, &x463, x5, (arg1[6])); + fiat_sm2_mulx_u32(&x464, &x465, x5, (arg1[5])); + fiat_sm2_mulx_u32(&x466, &x467, x5, (arg1[4])); + fiat_sm2_mulx_u32(&x468, &x469, x5, (arg1[3])); + fiat_sm2_mulx_u32(&x470, &x471, x5, (arg1[2])); + fiat_sm2_mulx_u32(&x472, &x473, x5, (arg1[1])); + fiat_sm2_mulx_u32(&x474, &x475, x5, (arg1[0])); + fiat_sm2_addcarryx_u32(&x476, &x477, 0x0, x475, x472); + fiat_sm2_addcarryx_u32(&x478, &x479, x477, x473, x470); + fiat_sm2_addcarryx_u32(&x480, &x481, x479, x471, x468); + fiat_sm2_addcarryx_u32(&x482, &x483, x481, x469, x466); + fiat_sm2_addcarryx_u32(&x484, &x485, x483, x467, x464); + fiat_sm2_addcarryx_u32(&x486, &x487, x485, x465, x462); + fiat_sm2_addcarryx_u32(&x488, &x489, x487, x463, x460); + x490 = (x489 + x461); + fiat_sm2_addcarryx_u32(&x491, &x492, 0x0, x443, x474); + fiat_sm2_addcarryx_u32(&x493, &x494, x492, x445, x476); + fiat_sm2_addcarryx_u32(&x495, &x496, x494, x447, x478); + fiat_sm2_addcarryx_u32(&x497, &x498, x496, x449, x480); + fiat_sm2_addcarryx_u32(&x499, &x500, x498, x451, x482); + fiat_sm2_addcarryx_u32(&x501, &x502, x500, x453, x484); + fiat_sm2_addcarryx_u32(&x503, &x504, x502, x455, x486); + fiat_sm2_addcarryx_u32(&x505, &x506, x504, x457, x488); + fiat_sm2_addcarryx_u32(&x507, &x508, x506, x459, x490); + fiat_sm2_mulx_u32(&x509, &x510, x491, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x511, &x512, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x513, &x514, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x515, &x516, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x517, &x518, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x519, &x520, x491, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x521, &x522, x491, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x523, &x524, 0x0, x522, x519); + x525 = (x524 + x520); + fiat_sm2_addcarryx_u32(&x526, &x527, 0x0, x518, x515); + fiat_sm2_addcarryx_u32(&x528, &x529, x527, x516, x513); + fiat_sm2_addcarryx_u32(&x530, &x531, x529, x514, x511); + fiat_sm2_addcarryx_u32(&x532, &x533, x531, x512, x509); + x534 = (x533 + x510); + fiat_sm2_addcarryx_u32(&x535, &x536, 0x0, x491, x521); + fiat_sm2_addcarryx_u32(&x537, &x538, x536, x493, x523); + fiat_sm2_addcarryx_u32(&x539, &x540, x538, x495, x525); + fiat_sm2_addcarryx_u32(&x541, &x542, x540, x497, x517); + fiat_sm2_addcarryx_u32(&x543, &x544, x542, x499, x526); + fiat_sm2_addcarryx_u32(&x545, &x546, x544, x501, x528); + fiat_sm2_addcarryx_u32(&x547, &x548, x546, x503, x530); + fiat_sm2_addcarryx_u32(&x549, &x550, x548, x505, x532); + fiat_sm2_addcarryx_u32(&x551, &x552, x550, x507, x534); + x553 = ((uint32_t)x552 + x508); + fiat_sm2_mulx_u32(&x554, &x555, x6, (arg1[7])); + fiat_sm2_mulx_u32(&x556, &x557, x6, (arg1[6])); + fiat_sm2_mulx_u32(&x558, &x559, x6, (arg1[5])); + fiat_sm2_mulx_u32(&x560, &x561, x6, (arg1[4])); + fiat_sm2_mulx_u32(&x562, &x563, x6, (arg1[3])); + fiat_sm2_mulx_u32(&x564, &x565, x6, (arg1[2])); + fiat_sm2_mulx_u32(&x566, &x567, x6, (arg1[1])); + fiat_sm2_mulx_u32(&x568, &x569, x6, (arg1[0])); + fiat_sm2_addcarryx_u32(&x570, &x571, 0x0, x569, x566); + fiat_sm2_addcarryx_u32(&x572, &x573, x571, x567, x564); + fiat_sm2_addcarryx_u32(&x574, &x575, x573, x565, x562); + fiat_sm2_addcarryx_u32(&x576, &x577, x575, x563, x560); + fiat_sm2_addcarryx_u32(&x578, &x579, x577, x561, x558); + fiat_sm2_addcarryx_u32(&x580, &x581, x579, x559, x556); + fiat_sm2_addcarryx_u32(&x582, &x583, x581, x557, x554); + x584 = (x583 + x555); + fiat_sm2_addcarryx_u32(&x585, &x586, 0x0, x537, x568); + fiat_sm2_addcarryx_u32(&x587, &x588, x586, x539, x570); + fiat_sm2_addcarryx_u32(&x589, &x590, x588, x541, x572); + fiat_sm2_addcarryx_u32(&x591, &x592, x590, x543, x574); + fiat_sm2_addcarryx_u32(&x593, &x594, x592, x545, x576); + fiat_sm2_addcarryx_u32(&x595, &x596, x594, x547, x578); + fiat_sm2_addcarryx_u32(&x597, &x598, x596, x549, x580); + fiat_sm2_addcarryx_u32(&x599, &x600, x598, x551, x582); + fiat_sm2_addcarryx_u32(&x601, &x602, x600, x553, x584); + fiat_sm2_mulx_u32(&x603, &x604, x585, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x605, &x606, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x607, &x608, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x609, &x610, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x611, &x612, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x613, &x614, x585, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x615, &x616, x585, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x617, &x618, 0x0, x616, x613); + x619 = (x618 + x614); + fiat_sm2_addcarryx_u32(&x620, &x621, 0x0, x612, x609); + fiat_sm2_addcarryx_u32(&x622, &x623, x621, x610, x607); + fiat_sm2_addcarryx_u32(&x624, &x625, x623, x608, x605); + fiat_sm2_addcarryx_u32(&x626, &x627, x625, x606, x603); + x628 = (x627 + x604); + fiat_sm2_addcarryx_u32(&x629, &x630, 0x0, x585, x615); + fiat_sm2_addcarryx_u32(&x631, &x632, x630, x587, x617); + fiat_sm2_addcarryx_u32(&x633, &x634, x632, x589, x619); + fiat_sm2_addcarryx_u32(&x635, &x636, x634, x591, x611); + fiat_sm2_addcarryx_u32(&x637, &x638, x636, x593, x620); + fiat_sm2_addcarryx_u32(&x639, &x640, x638, x595, x622); + fiat_sm2_addcarryx_u32(&x641, &x642, x640, x597, x624); + fiat_sm2_addcarryx_u32(&x643, &x644, x642, x599, x626); + fiat_sm2_addcarryx_u32(&x645, &x646, x644, x601, x628); + x647 = ((uint32_t)x646 + x602); + fiat_sm2_mulx_u32(&x648, &x649, x7, (arg1[7])); + fiat_sm2_mulx_u32(&x650, &x651, x7, (arg1[6])); + fiat_sm2_mulx_u32(&x652, &x653, x7, (arg1[5])); + fiat_sm2_mulx_u32(&x654, &x655, x7, (arg1[4])); + fiat_sm2_mulx_u32(&x656, &x657, x7, (arg1[3])); + fiat_sm2_mulx_u32(&x658, &x659, x7, (arg1[2])); + fiat_sm2_mulx_u32(&x660, &x661, x7, (arg1[1])); + fiat_sm2_mulx_u32(&x662, &x663, x7, (arg1[0])); + fiat_sm2_addcarryx_u32(&x664, &x665, 0x0, x663, x660); + fiat_sm2_addcarryx_u32(&x666, &x667, x665, x661, x658); + fiat_sm2_addcarryx_u32(&x668, &x669, x667, x659, x656); + fiat_sm2_addcarryx_u32(&x670, &x671, x669, x657, x654); + fiat_sm2_addcarryx_u32(&x672, &x673, x671, x655, x652); + fiat_sm2_addcarryx_u32(&x674, &x675, x673, x653, x650); + fiat_sm2_addcarryx_u32(&x676, &x677, x675, x651, x648); + x678 = (x677 + x649); + fiat_sm2_addcarryx_u32(&x679, &x680, 0x0, x631, x662); + fiat_sm2_addcarryx_u32(&x681, &x682, x680, x633, x664); + fiat_sm2_addcarryx_u32(&x683, &x684, x682, x635, x666); + fiat_sm2_addcarryx_u32(&x685, &x686, x684, x637, x668); + fiat_sm2_addcarryx_u32(&x687, &x688, x686, x639, x670); + fiat_sm2_addcarryx_u32(&x689, &x690, x688, x641, x672); + fiat_sm2_addcarryx_u32(&x691, &x692, x690, x643, x674); + fiat_sm2_addcarryx_u32(&x693, &x694, x692, x645, x676); + fiat_sm2_addcarryx_u32(&x695, &x696, x694, x647, x678); + fiat_sm2_mulx_u32(&x697, &x698, x679, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x699, &x700, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x701, &x702, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x703, &x704, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x705, &x706, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x707, &x708, x679, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x709, &x710, x679, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x711, &x712, 0x0, x710, x707); + x713 = (x712 + x708); + fiat_sm2_addcarryx_u32(&x714, &x715, 0x0, x706, x703); + fiat_sm2_addcarryx_u32(&x716, &x717, x715, x704, x701); + fiat_sm2_addcarryx_u32(&x718, &x719, x717, x702, x699); + fiat_sm2_addcarryx_u32(&x720, &x721, x719, x700, x697); + x722 = (x721 + x698); + fiat_sm2_addcarryx_u32(&x723, &x724, 0x0, x679, x709); + fiat_sm2_addcarryx_u32(&x725, &x726, x724, x681, x711); + fiat_sm2_addcarryx_u32(&x727, &x728, x726, x683, x713); + fiat_sm2_addcarryx_u32(&x729, &x730, x728, x685, x705); + fiat_sm2_addcarryx_u32(&x731, &x732, x730, x687, x714); + fiat_sm2_addcarryx_u32(&x733, &x734, x732, x689, x716); + fiat_sm2_addcarryx_u32(&x735, &x736, x734, x691, x718); + fiat_sm2_addcarryx_u32(&x737, &x738, x736, x693, x720); + fiat_sm2_addcarryx_u32(&x739, &x740, x738, x695, x722); + x741 = ((uint32_t)x740 + x696); + fiat_sm2_subborrowx_u32(&x742, &x743, 0x0, x725, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x744, &x745, x743, x727, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x746, &x747, x745, x729, 0x0); + fiat_sm2_subborrowx_u32(&x748, &x749, x747, x731, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x750, &x751, x749, x733, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x752, &x753, x751, x735, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x754, &x755, x753, x737, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x756, &x757, x755, x739, UINT32_C(0xfffffffe)); + fiat_sm2_subborrowx_u32(&x758, &x759, x757, x741, 0x0); + fiat_sm2_cmovznz_u32(&x760, x759, x742, x725); + fiat_sm2_cmovznz_u32(&x761, x759, x744, x727); + fiat_sm2_cmovznz_u32(&x762, x759, x746, x729); + fiat_sm2_cmovznz_u32(&x763, x759, x748, x731); + fiat_sm2_cmovznz_u32(&x764, x759, x750, x733); + fiat_sm2_cmovznz_u32(&x765, x759, x752, x735); + fiat_sm2_cmovznz_u32(&x766, x759, x754, x737); + fiat_sm2_cmovznz_u32(&x767, x759, x756, x739); + out1[0] = x760; + out1[1] = x761; + out1[2] = x762; + out1[3] = x763; + out1[4] = x764; + out1[5] = x765; + out1[6] = x766; + out1[7] = x767; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_add(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1, const fiat_sm2_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_sm2_uint1 x2; + uint32_t x3; + fiat_sm2_uint1 x4; + uint32_t x5; + fiat_sm2_uint1 x6; + uint32_t x7; + fiat_sm2_uint1 x8; + uint32_t x9; + fiat_sm2_uint1 x10; + uint32_t x11; + fiat_sm2_uint1 x12; + uint32_t x13; + fiat_sm2_uint1 x14; + uint32_t x15; + fiat_sm2_uint1 x16; + uint32_t x17; + fiat_sm2_uint1 x18; + uint32_t x19; + fiat_sm2_uint1 x20; + uint32_t x21; + fiat_sm2_uint1 x22; + uint32_t x23; + fiat_sm2_uint1 x24; + uint32_t x25; + fiat_sm2_uint1 x26; + uint32_t x27; + fiat_sm2_uint1 x28; + uint32_t x29; + fiat_sm2_uint1 x30; + uint32_t x31; + fiat_sm2_uint1 x32; + uint32_t x33; + fiat_sm2_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_sm2_addcarryx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_addcarryx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_addcarryx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_addcarryx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_addcarryx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_sm2_addcarryx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_sm2_addcarryx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_sm2_addcarryx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_sm2_subborrowx_u32(&x17, &x18, 0x0, x1, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x19, &x20, x18, x3, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x21, &x22, x20, x5, 0x0); + fiat_sm2_subborrowx_u32(&x23, &x24, x22, x7, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x25, &x26, x24, x9, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x27, &x28, x26, x11, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x29, &x30, x28, x13, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x31, &x32, x30, x15, UINT32_C(0xfffffffe)); + fiat_sm2_subborrowx_u32(&x33, &x34, x32, x16, 0x0); + fiat_sm2_cmovznz_u32(&x35, x34, x17, x1); + fiat_sm2_cmovznz_u32(&x36, x34, x19, x3); + fiat_sm2_cmovznz_u32(&x37, x34, x21, x5); + fiat_sm2_cmovznz_u32(&x38, x34, x23, x7); + fiat_sm2_cmovznz_u32(&x39, x34, x25, x9); + fiat_sm2_cmovznz_u32(&x40, x34, x27, x11); + fiat_sm2_cmovznz_u32(&x41, x34, x29, x13); + fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_sub(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1, const fiat_sm2_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_sm2_uint1 x2; + uint32_t x3; + fiat_sm2_uint1 x4; + uint32_t x5; + fiat_sm2_uint1 x6; + uint32_t x7; + fiat_sm2_uint1 x8; + uint32_t x9; + fiat_sm2_uint1 x10; + uint32_t x11; + fiat_sm2_uint1 x12; + uint32_t x13; + fiat_sm2_uint1 x14; + uint32_t x15; + fiat_sm2_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_sm2_uint1 x19; + uint32_t x20; + fiat_sm2_uint1 x21; + uint32_t x22; + fiat_sm2_uint1 x23; + uint32_t x24; + fiat_sm2_uint1 x25; + uint32_t x26; + fiat_sm2_uint1 x27; + uint32_t x28; + fiat_sm2_uint1 x29; + uint32_t x30; + fiat_sm2_uint1 x31; + uint32_t x32; + fiat_sm2_uint1 x33; + fiat_sm2_subborrowx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_subborrowx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_subborrowx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_subborrowx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_subborrowx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_sm2_subborrowx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_sm2_subborrowx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_sm2_subborrowx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_sm2_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x18, &x19, 0x0, x1, x17); + fiat_sm2_addcarryx_u32(&x20, &x21, x19, x3, x17); + fiat_sm2_addcarryx_u32(&x22, &x23, x21, x5, 0x0); + fiat_sm2_addcarryx_u32(&x24, &x25, x23, x7, x17); + fiat_sm2_addcarryx_u32(&x26, &x27, x25, x9, x17); + fiat_sm2_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_sm2_addcarryx_u32(&x30, &x31, x29, x13, x17); + fiat_sm2_addcarryx_u32(&x32, &x33, x31, x15, (x17 & UINT32_C(0xfffffffe))); + 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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_opp(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1) { + uint32_t x1; + fiat_sm2_uint1 x2; + uint32_t x3; + fiat_sm2_uint1 x4; + uint32_t x5; + fiat_sm2_uint1 x6; + uint32_t x7; + fiat_sm2_uint1 x8; + uint32_t x9; + fiat_sm2_uint1 x10; + uint32_t x11; + fiat_sm2_uint1 x12; + uint32_t x13; + fiat_sm2_uint1 x14; + uint32_t x15; + fiat_sm2_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_sm2_uint1 x19; + uint32_t x20; + fiat_sm2_uint1 x21; + uint32_t x22; + fiat_sm2_uint1 x23; + uint32_t x24; + fiat_sm2_uint1 x25; + uint32_t x26; + fiat_sm2_uint1 x27; + uint32_t x28; + fiat_sm2_uint1 x29; + uint32_t x30; + fiat_sm2_uint1 x31; + uint32_t x32; + fiat_sm2_uint1 x33; + fiat_sm2_subborrowx_u32(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_sm2_subborrowx_u32(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_sm2_subborrowx_u32(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_sm2_subborrowx_u32(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_sm2_subborrowx_u32(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_sm2_subborrowx_u32(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_sm2_subborrowx_u32(&x13, &x14, x12, 0x0, (arg1[6])); + fiat_sm2_subborrowx_u32(&x15, &x16, x14, 0x0, (arg1[7])); + fiat_sm2_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x18, &x19, 0x0, x1, x17); + fiat_sm2_addcarryx_u32(&x20, &x21, x19, x3, x17); + fiat_sm2_addcarryx_u32(&x22, &x23, x21, x5, 0x0); + fiat_sm2_addcarryx_u32(&x24, &x25, x23, x7, x17); + fiat_sm2_addcarryx_u32(&x26, &x27, x25, x9, x17); + fiat_sm2_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_sm2_addcarryx_u32(&x30, &x31, x29, x13, x17); + fiat_sm2_addcarryx_u32(&x32, &x33, x31, x15, (x17 & UINT32_C(0xfffffffe))); + 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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_from_montgomery(fiat_sm2_non_montgomery_domain_field_element out1, const fiat_sm2_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; + fiat_sm2_uint1 x17; + uint32_t x18; + fiat_sm2_uint1 x19; + uint32_t x20; + fiat_sm2_uint1 x21; + uint32_t x22; + fiat_sm2_uint1 x23; + uint32_t x24; + fiat_sm2_uint1 x25; + uint32_t x26; + fiat_sm2_uint1 x27; + uint32_t x28; + fiat_sm2_uint1 x29; + uint32_t x30; + fiat_sm2_uint1 x31; + uint32_t x32; + fiat_sm2_uint1 x33; + uint32_t x34; + fiat_sm2_uint1 x35; + uint32_t x36; + fiat_sm2_uint1 x37; + uint32_t x38; + fiat_sm2_uint1 x39; + uint32_t x40; + fiat_sm2_uint1 x41; + uint32_t x42; + fiat_sm2_uint1 x43; + uint32_t x44; + fiat_sm2_uint1 x45; + uint32_t x46; + fiat_sm2_uint1 x47; + uint32_t x48; + fiat_sm2_uint1 x49; + uint32_t x50; + fiat_sm2_uint1 x51; + uint32_t x52; + fiat_sm2_uint1 x53; + uint32_t x54; + fiat_sm2_uint1 x55; + uint32_t x56; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x73; + uint32_t x74; + fiat_sm2_uint1 x75; + uint32_t x76; + fiat_sm2_uint1 x77; + uint32_t x78; + fiat_sm2_uint1 x79; + uint32_t x80; + fiat_sm2_uint1 x81; + uint32_t x82; + fiat_sm2_uint1 x83; + uint32_t x84; + fiat_sm2_uint1 x85; + uint32_t x86; + fiat_sm2_uint1 x87; + uint32_t x88; + fiat_sm2_uint1 x89; + uint32_t x90; + fiat_sm2_uint1 x91; + uint32_t x92; + fiat_sm2_uint1 x93; + uint32_t x94; + fiat_sm2_uint1 x95; + uint32_t x96; + fiat_sm2_uint1 x97; + uint32_t x98; + fiat_sm2_uint1 x99; + uint32_t x100; + fiat_sm2_uint1 x101; + uint32_t x102; + fiat_sm2_uint1 x103; + uint32_t x104; + fiat_sm2_uint1 x105; + uint32_t x106; + fiat_sm2_uint1 x107; + uint32_t x108; + fiat_sm2_uint1 x109; + uint32_t x110; + fiat_sm2_uint1 x111; + uint32_t x112; + fiat_sm2_uint1 x113; + uint32_t x114; + fiat_sm2_uint1 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; + uint32_t x127; + uint32_t x128; + uint32_t x129; + uint32_t x130; + fiat_sm2_uint1 x131; + uint32_t x132; + fiat_sm2_uint1 x133; + uint32_t x134; + fiat_sm2_uint1 x135; + uint32_t x136; + fiat_sm2_uint1 x137; + uint32_t x138; + fiat_sm2_uint1 x139; + uint32_t x140; + fiat_sm2_uint1 x141; + uint32_t x142; + fiat_sm2_uint1 x143; + uint32_t x144; + fiat_sm2_uint1 x145; + uint32_t x146; + fiat_sm2_uint1 x147; + uint32_t x148; + fiat_sm2_uint1 x149; + uint32_t x150; + fiat_sm2_uint1 x151; + uint32_t x152; + fiat_sm2_uint1 x153; + uint32_t x154; + fiat_sm2_uint1 x155; + uint32_t x156; + fiat_sm2_uint1 x157; + uint32_t x158; + fiat_sm2_uint1 x159; + uint32_t x160; + fiat_sm2_uint1 x161; + uint32_t x162; + fiat_sm2_uint1 x163; + uint32_t x164; + fiat_sm2_uint1 x165; + uint32_t x166; + fiat_sm2_uint1 x167; + uint32_t x168; + fiat_sm2_uint1 x169; + uint32_t x170; + fiat_sm2_uint1 x171; + uint32_t x172; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x189; + uint32_t x190; + fiat_sm2_uint1 x191; + uint32_t x192; + fiat_sm2_uint1 x193; + uint32_t x194; + fiat_sm2_uint1 x195; + uint32_t x196; + fiat_sm2_uint1 x197; + uint32_t x198; + fiat_sm2_uint1 x199; + uint32_t x200; + fiat_sm2_uint1 x201; + uint32_t x202; + fiat_sm2_uint1 x203; + uint32_t x204; + fiat_sm2_uint1 x205; + uint32_t x206; + fiat_sm2_uint1 x207; + uint32_t x208; + fiat_sm2_uint1 x209; + uint32_t x210; + fiat_sm2_uint1 x211; + uint32_t x212; + fiat_sm2_uint1 x213; + uint32_t x214; + fiat_sm2_uint1 x215; + uint32_t x216; + fiat_sm2_uint1 x217; + uint32_t x218; + fiat_sm2_uint1 x219; + uint32_t x220; + fiat_sm2_uint1 x221; + uint32_t x222; + fiat_sm2_uint1 x223; + uint32_t x224; + fiat_sm2_uint1 x225; + uint32_t x226; + fiat_sm2_uint1 x227; + uint32_t x228; + fiat_sm2_uint1 x229; + uint32_t x230; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x247; + uint32_t x248; + fiat_sm2_uint1 x249; + uint32_t x250; + fiat_sm2_uint1 x251; + uint32_t x252; + fiat_sm2_uint1 x253; + uint32_t x254; + fiat_sm2_uint1 x255; + uint32_t x256; + fiat_sm2_uint1 x257; + uint32_t x258; + fiat_sm2_uint1 x259; + uint32_t x260; + fiat_sm2_uint1 x261; + uint32_t x262; + fiat_sm2_uint1 x263; + uint32_t x264; + fiat_sm2_uint1 x265; + uint32_t x266; + fiat_sm2_uint1 x267; + uint32_t x268; + fiat_sm2_uint1 x269; + uint32_t x270; + fiat_sm2_uint1 x271; + uint32_t x272; + fiat_sm2_uint1 x273; + uint32_t x274; + fiat_sm2_uint1 x275; + uint32_t x276; + fiat_sm2_uint1 x277; + uint32_t x278; + fiat_sm2_uint1 x279; + uint32_t x280; + fiat_sm2_uint1 x281; + uint32_t x282; + fiat_sm2_uint1 x283; + uint32_t x284; + fiat_sm2_uint1 x285; + uint32_t x286; + fiat_sm2_uint1 x287; + uint32_t x288; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x305; + uint32_t x306; + fiat_sm2_uint1 x307; + uint32_t x308; + fiat_sm2_uint1 x309; + uint32_t x310; + fiat_sm2_uint1 x311; + uint32_t x312; + fiat_sm2_uint1 x313; + uint32_t x314; + fiat_sm2_uint1 x315; + uint32_t x316; + fiat_sm2_uint1 x317; + uint32_t x318; + fiat_sm2_uint1 x319; + uint32_t x320; + fiat_sm2_uint1 x321; + uint32_t x322; + fiat_sm2_uint1 x323; + uint32_t x324; + fiat_sm2_uint1 x325; + uint32_t x326; + fiat_sm2_uint1 x327; + uint32_t x328; + fiat_sm2_uint1 x329; + uint32_t x330; + fiat_sm2_uint1 x331; + uint32_t x332; + fiat_sm2_uint1 x333; + uint32_t x334; + fiat_sm2_uint1 x335; + uint32_t x336; + fiat_sm2_uint1 x337; + uint32_t x338; + fiat_sm2_uint1 x339; + uint32_t x340; + fiat_sm2_uint1 x341; + uint32_t x342; + fiat_sm2_uint1 x343; + uint32_t x344; + fiat_sm2_uint1 x345; + uint32_t x346; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x363; + uint32_t x364; + fiat_sm2_uint1 x365; + uint32_t x366; + fiat_sm2_uint1 x367; + uint32_t x368; + fiat_sm2_uint1 x369; + uint32_t x370; + fiat_sm2_uint1 x371; + uint32_t x372; + fiat_sm2_uint1 x373; + uint32_t x374; + fiat_sm2_uint1 x375; + uint32_t x376; + fiat_sm2_uint1 x377; + uint32_t x378; + fiat_sm2_uint1 x379; + uint32_t x380; + fiat_sm2_uint1 x381; + uint32_t x382; + fiat_sm2_uint1 x383; + uint32_t x384; + fiat_sm2_uint1 x385; + uint32_t x386; + fiat_sm2_uint1 x387; + uint32_t x388; + fiat_sm2_uint1 x389; + uint32_t x390; + fiat_sm2_uint1 x391; + uint32_t x392; + fiat_sm2_uint1 x393; + uint32_t x394; + fiat_sm2_uint1 x395; + uint32_t x396; + fiat_sm2_uint1 x397; + uint32_t x398; + fiat_sm2_uint1 x399; + uint32_t x400; + fiat_sm2_uint1 x401; + uint32_t x402; + fiat_sm2_uint1 x403; + uint32_t x404; + fiat_sm2_uint1 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_sm2_uint1 x421; + uint32_t x422; + fiat_sm2_uint1 x423; + uint32_t x424; + fiat_sm2_uint1 x425; + uint32_t x426; + fiat_sm2_uint1 x427; + uint32_t x428; + fiat_sm2_uint1 x429; + uint32_t x430; + fiat_sm2_uint1 x431; + uint32_t x432; + fiat_sm2_uint1 x433; + uint32_t x434; + fiat_sm2_uint1 x435; + uint32_t x436; + fiat_sm2_uint1 x437; + uint32_t x438; + fiat_sm2_uint1 x439; + uint32_t x440; + fiat_sm2_uint1 x441; + uint32_t x442; + fiat_sm2_uint1 x443; + uint32_t x444; + fiat_sm2_uint1 x445; + uint32_t x446; + fiat_sm2_uint1 x447; + uint32_t x448; + fiat_sm2_uint1 x449; + uint32_t x450; + fiat_sm2_uint1 x451; + uint32_t x452; + fiat_sm2_uint1 x453; + uint32_t x454; + fiat_sm2_uint1 x455; + uint32_t x456; + fiat_sm2_uint1 x457; + uint32_t x458; + fiat_sm2_uint1 x459; + uint32_t x460; + fiat_sm2_uint1 x461; + uint32_t x462; + fiat_sm2_uint1 x463; + uint32_t x464; + fiat_sm2_uint1 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; + x1 = (arg1[0]); + fiat_sm2_mulx_u32(&x2, &x3, x1, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x4, &x5, x1, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x6, &x7, x1, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x8, &x9, x1, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x10, &x11, x1, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x12, &x13, x1, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x14, &x15, x1, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x16, &x17, 0x0, x15, x12); + fiat_sm2_addcarryx_u32(&x18, &x19, 0x0, x11, x8); + fiat_sm2_addcarryx_u32(&x20, &x21, x19, x9, x6); + fiat_sm2_addcarryx_u32(&x22, &x23, x21, x7, x4); + fiat_sm2_addcarryx_u32(&x24, &x25, x23, x5, x2); + fiat_sm2_addcarryx_u32(&x26, &x27, 0x0, x1, x14); + fiat_sm2_addcarryx_u32(&x28, &x29, x27, 0x0, x16); + fiat_sm2_addcarryx_u32(&x30, &x31, x29, 0x0, (x17 + x13)); + fiat_sm2_addcarryx_u32(&x32, &x33, x31, 0x0, x10); + fiat_sm2_addcarryx_u32(&x34, &x35, x33, 0x0, x18); + fiat_sm2_addcarryx_u32(&x36, &x37, x35, 0x0, x20); + fiat_sm2_addcarryx_u32(&x38, &x39, x37, 0x0, x22); + fiat_sm2_addcarryx_u32(&x40, &x41, x39, 0x0, x24); + fiat_sm2_addcarryx_u32(&x42, &x43, 0x0, x28, (arg1[1])); + fiat_sm2_addcarryx_u32(&x44, &x45, x43, x30, 0x0); + fiat_sm2_addcarryx_u32(&x46, &x47, x45, x32, 0x0); + fiat_sm2_addcarryx_u32(&x48, &x49, x47, x34, 0x0); + fiat_sm2_addcarryx_u32(&x50, &x51, x49, x36, 0x0); + fiat_sm2_addcarryx_u32(&x52, &x53, x51, x38, 0x0); + fiat_sm2_addcarryx_u32(&x54, &x55, x53, x40, 0x0); + fiat_sm2_addcarryx_u32(&x56, &x57, x55, (x41 + (x25 + x3)), 0x0); + fiat_sm2_mulx_u32(&x58, &x59, x42, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x60, &x61, x42, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x62, &x63, x42, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x64, &x65, x42, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x66, &x67, x42, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x68, &x69, x42, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x70, &x71, x42, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x72, &x73, 0x0, x71, x68); + fiat_sm2_addcarryx_u32(&x74, &x75, 0x0, x67, x64); + fiat_sm2_addcarryx_u32(&x76, &x77, x75, x65, x62); + fiat_sm2_addcarryx_u32(&x78, &x79, x77, x63, x60); + fiat_sm2_addcarryx_u32(&x80, &x81, x79, x61, x58); + fiat_sm2_addcarryx_u32(&x82, &x83, 0x0, x42, x70); + fiat_sm2_addcarryx_u32(&x84, &x85, x83, x44, x72); + fiat_sm2_addcarryx_u32(&x86, &x87, x85, x46, (x73 + x69)); + fiat_sm2_addcarryx_u32(&x88, &x89, x87, x48, x66); + fiat_sm2_addcarryx_u32(&x90, &x91, x89, x50, x74); + fiat_sm2_addcarryx_u32(&x92, &x93, x91, x52, x76); + fiat_sm2_addcarryx_u32(&x94, &x95, x93, x54, x78); + fiat_sm2_addcarryx_u32(&x96, &x97, x95, x56, x80); + fiat_sm2_addcarryx_u32(&x98, &x99, x97, x57, (x81 + x59)); + fiat_sm2_addcarryx_u32(&x100, &x101, 0x0, x84, (arg1[2])); + fiat_sm2_addcarryx_u32(&x102, &x103, x101, x86, 0x0); + fiat_sm2_addcarryx_u32(&x104, &x105, x103, x88, 0x0); + fiat_sm2_addcarryx_u32(&x106, &x107, x105, x90, 0x0); + fiat_sm2_addcarryx_u32(&x108, &x109, x107, x92, 0x0); + fiat_sm2_addcarryx_u32(&x110, &x111, x109, x94, 0x0); + fiat_sm2_addcarryx_u32(&x112, &x113, x111, x96, 0x0); + fiat_sm2_addcarryx_u32(&x114, &x115, x113, x98, 0x0); + fiat_sm2_mulx_u32(&x116, &x117, x100, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x118, &x119, x100, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x120, &x121, x100, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x122, &x123, x100, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x124, &x125, x100, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x126, &x127, x100, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x128, &x129, x100, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x130, &x131, 0x0, x129, x126); + fiat_sm2_addcarryx_u32(&x132, &x133, 0x0, x125, x122); + fiat_sm2_addcarryx_u32(&x134, &x135, x133, x123, x120); + fiat_sm2_addcarryx_u32(&x136, &x137, x135, x121, x118); + fiat_sm2_addcarryx_u32(&x138, &x139, x137, x119, x116); + fiat_sm2_addcarryx_u32(&x140, &x141, 0x0, x100, x128); + fiat_sm2_addcarryx_u32(&x142, &x143, x141, x102, x130); + fiat_sm2_addcarryx_u32(&x144, &x145, x143, x104, (x131 + x127)); + fiat_sm2_addcarryx_u32(&x146, &x147, x145, x106, x124); + fiat_sm2_addcarryx_u32(&x148, &x149, x147, x108, x132); + fiat_sm2_addcarryx_u32(&x150, &x151, x149, x110, x134); + fiat_sm2_addcarryx_u32(&x152, &x153, x151, x112, x136); + fiat_sm2_addcarryx_u32(&x154, &x155, x153, x114, x138); + fiat_sm2_addcarryx_u32(&x156, &x157, x155, ((uint32_t)x115 + x99), (x139 + x117)); + fiat_sm2_addcarryx_u32(&x158, &x159, 0x0, x142, (arg1[3])); + fiat_sm2_addcarryx_u32(&x160, &x161, x159, x144, 0x0); + fiat_sm2_addcarryx_u32(&x162, &x163, x161, x146, 0x0); + fiat_sm2_addcarryx_u32(&x164, &x165, x163, x148, 0x0); + fiat_sm2_addcarryx_u32(&x166, &x167, x165, x150, 0x0); + fiat_sm2_addcarryx_u32(&x168, &x169, x167, x152, 0x0); + fiat_sm2_addcarryx_u32(&x170, &x171, x169, x154, 0x0); + fiat_sm2_addcarryx_u32(&x172, &x173, x171, x156, 0x0); + fiat_sm2_mulx_u32(&x174, &x175, x158, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x176, &x177, x158, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x178, &x179, x158, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x180, &x181, x158, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x182, &x183, x158, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x184, &x185, x158, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x186, &x187, x158, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x188, &x189, 0x0, x187, x184); + fiat_sm2_addcarryx_u32(&x190, &x191, 0x0, x183, x180); + fiat_sm2_addcarryx_u32(&x192, &x193, x191, x181, x178); + fiat_sm2_addcarryx_u32(&x194, &x195, x193, x179, x176); + fiat_sm2_addcarryx_u32(&x196, &x197, x195, x177, x174); + fiat_sm2_addcarryx_u32(&x198, &x199, 0x0, x158, x186); + fiat_sm2_addcarryx_u32(&x200, &x201, x199, x160, x188); + fiat_sm2_addcarryx_u32(&x202, &x203, x201, x162, (x189 + x185)); + fiat_sm2_addcarryx_u32(&x204, &x205, x203, x164, x182); + fiat_sm2_addcarryx_u32(&x206, &x207, x205, x166, x190); + fiat_sm2_addcarryx_u32(&x208, &x209, x207, x168, x192); + fiat_sm2_addcarryx_u32(&x210, &x211, x209, x170, x194); + fiat_sm2_addcarryx_u32(&x212, &x213, x211, x172, x196); + fiat_sm2_addcarryx_u32(&x214, &x215, x213, ((uint32_t)x173 + x157), (x197 + x175)); + fiat_sm2_addcarryx_u32(&x216, &x217, 0x0, x200, (arg1[4])); + fiat_sm2_addcarryx_u32(&x218, &x219, x217, x202, 0x0); + fiat_sm2_addcarryx_u32(&x220, &x221, x219, x204, 0x0); + fiat_sm2_addcarryx_u32(&x222, &x223, x221, x206, 0x0); + fiat_sm2_addcarryx_u32(&x224, &x225, x223, x208, 0x0); + fiat_sm2_addcarryx_u32(&x226, &x227, x225, x210, 0x0); + fiat_sm2_addcarryx_u32(&x228, &x229, x227, x212, 0x0); + fiat_sm2_addcarryx_u32(&x230, &x231, x229, x214, 0x0); + fiat_sm2_mulx_u32(&x232, &x233, x216, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x234, &x235, x216, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x236, &x237, x216, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x238, &x239, x216, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x240, &x241, x216, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x242, &x243, x216, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x244, &x245, x216, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x246, &x247, 0x0, x245, x242); + fiat_sm2_addcarryx_u32(&x248, &x249, 0x0, x241, x238); + fiat_sm2_addcarryx_u32(&x250, &x251, x249, x239, x236); + fiat_sm2_addcarryx_u32(&x252, &x253, x251, x237, x234); + fiat_sm2_addcarryx_u32(&x254, &x255, x253, x235, x232); + fiat_sm2_addcarryx_u32(&x256, &x257, 0x0, x216, x244); + fiat_sm2_addcarryx_u32(&x258, &x259, x257, x218, x246); + fiat_sm2_addcarryx_u32(&x260, &x261, x259, x220, (x247 + x243)); + fiat_sm2_addcarryx_u32(&x262, &x263, x261, x222, x240); + fiat_sm2_addcarryx_u32(&x264, &x265, x263, x224, x248); + fiat_sm2_addcarryx_u32(&x266, &x267, x265, x226, x250); + fiat_sm2_addcarryx_u32(&x268, &x269, x267, x228, x252); + fiat_sm2_addcarryx_u32(&x270, &x271, x269, x230, x254); + fiat_sm2_addcarryx_u32(&x272, &x273, x271, ((uint32_t)x231 + x215), (x255 + x233)); + fiat_sm2_addcarryx_u32(&x274, &x275, 0x0, x258, (arg1[5])); + fiat_sm2_addcarryx_u32(&x276, &x277, x275, x260, 0x0); + fiat_sm2_addcarryx_u32(&x278, &x279, x277, x262, 0x0); + fiat_sm2_addcarryx_u32(&x280, &x281, x279, x264, 0x0); + fiat_sm2_addcarryx_u32(&x282, &x283, x281, x266, 0x0); + fiat_sm2_addcarryx_u32(&x284, &x285, x283, x268, 0x0); + fiat_sm2_addcarryx_u32(&x286, &x287, x285, x270, 0x0); + fiat_sm2_addcarryx_u32(&x288, &x289, x287, x272, 0x0); + fiat_sm2_mulx_u32(&x290, &x291, x274, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x292, &x293, x274, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x294, &x295, x274, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x296, &x297, x274, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x298, &x299, x274, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x300, &x301, x274, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x302, &x303, x274, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x304, &x305, 0x0, x303, x300); + fiat_sm2_addcarryx_u32(&x306, &x307, 0x0, x299, x296); + fiat_sm2_addcarryx_u32(&x308, &x309, x307, x297, x294); + fiat_sm2_addcarryx_u32(&x310, &x311, x309, x295, x292); + fiat_sm2_addcarryx_u32(&x312, &x313, x311, x293, x290); + fiat_sm2_addcarryx_u32(&x314, &x315, 0x0, x274, x302); + fiat_sm2_addcarryx_u32(&x316, &x317, x315, x276, x304); + fiat_sm2_addcarryx_u32(&x318, &x319, x317, x278, (x305 + x301)); + fiat_sm2_addcarryx_u32(&x320, &x321, x319, x280, x298); + fiat_sm2_addcarryx_u32(&x322, &x323, x321, x282, x306); + fiat_sm2_addcarryx_u32(&x324, &x325, x323, x284, x308); + fiat_sm2_addcarryx_u32(&x326, &x327, x325, x286, x310); + fiat_sm2_addcarryx_u32(&x328, &x329, x327, x288, x312); + fiat_sm2_addcarryx_u32(&x330, &x331, x329, ((uint32_t)x289 + x273), (x313 + x291)); + fiat_sm2_addcarryx_u32(&x332, &x333, 0x0, x316, (arg1[6])); + fiat_sm2_addcarryx_u32(&x334, &x335, x333, x318, 0x0); + fiat_sm2_addcarryx_u32(&x336, &x337, x335, x320, 0x0); + fiat_sm2_addcarryx_u32(&x338, &x339, x337, x322, 0x0); + fiat_sm2_addcarryx_u32(&x340, &x341, x339, x324, 0x0); + fiat_sm2_addcarryx_u32(&x342, &x343, x341, x326, 0x0); + fiat_sm2_addcarryx_u32(&x344, &x345, x343, x328, 0x0); + fiat_sm2_addcarryx_u32(&x346, &x347, x345, x330, 0x0); + fiat_sm2_mulx_u32(&x348, &x349, x332, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x350, &x351, x332, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x352, &x353, x332, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x354, &x355, x332, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x356, &x357, x332, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x358, &x359, x332, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x360, &x361, x332, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x362, &x363, 0x0, x361, x358); + fiat_sm2_addcarryx_u32(&x364, &x365, 0x0, x357, x354); + fiat_sm2_addcarryx_u32(&x366, &x367, x365, x355, x352); + fiat_sm2_addcarryx_u32(&x368, &x369, x367, x353, x350); + fiat_sm2_addcarryx_u32(&x370, &x371, x369, x351, x348); + fiat_sm2_addcarryx_u32(&x372, &x373, 0x0, x332, x360); + fiat_sm2_addcarryx_u32(&x374, &x375, x373, x334, x362); + fiat_sm2_addcarryx_u32(&x376, &x377, x375, x336, (x363 + x359)); + fiat_sm2_addcarryx_u32(&x378, &x379, x377, x338, x356); + fiat_sm2_addcarryx_u32(&x380, &x381, x379, x340, x364); + fiat_sm2_addcarryx_u32(&x382, &x383, x381, x342, x366); + fiat_sm2_addcarryx_u32(&x384, &x385, x383, x344, x368); + fiat_sm2_addcarryx_u32(&x386, &x387, x385, x346, x370); + fiat_sm2_addcarryx_u32(&x388, &x389, x387, ((uint32_t)x347 + x331), (x371 + x349)); + fiat_sm2_addcarryx_u32(&x390, &x391, 0x0, x374, (arg1[7])); + fiat_sm2_addcarryx_u32(&x392, &x393, x391, x376, 0x0); + fiat_sm2_addcarryx_u32(&x394, &x395, x393, x378, 0x0); + fiat_sm2_addcarryx_u32(&x396, &x397, x395, x380, 0x0); + fiat_sm2_addcarryx_u32(&x398, &x399, x397, x382, 0x0); + fiat_sm2_addcarryx_u32(&x400, &x401, x399, x384, 0x0); + fiat_sm2_addcarryx_u32(&x402, &x403, x401, x386, 0x0); + fiat_sm2_addcarryx_u32(&x404, &x405, x403, x388, 0x0); + fiat_sm2_mulx_u32(&x406, &x407, x390, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x408, &x409, x390, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x410, &x411, x390, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x412, &x413, x390, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x414, &x415, x390, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x416, &x417, x390, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x418, &x419, x390, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x420, &x421, 0x0, x419, x416); + fiat_sm2_addcarryx_u32(&x422, &x423, 0x0, x415, x412); + fiat_sm2_addcarryx_u32(&x424, &x425, x423, x413, x410); + fiat_sm2_addcarryx_u32(&x426, &x427, x425, x411, x408); + fiat_sm2_addcarryx_u32(&x428, &x429, x427, x409, x406); + fiat_sm2_addcarryx_u32(&x430, &x431, 0x0, x390, x418); + fiat_sm2_addcarryx_u32(&x432, &x433, x431, x392, x420); + fiat_sm2_addcarryx_u32(&x434, &x435, x433, x394, (x421 + x417)); + fiat_sm2_addcarryx_u32(&x436, &x437, x435, x396, x414); + fiat_sm2_addcarryx_u32(&x438, &x439, x437, x398, x422); + fiat_sm2_addcarryx_u32(&x440, &x441, x439, x400, x424); + fiat_sm2_addcarryx_u32(&x442, &x443, x441, x402, x426); + fiat_sm2_addcarryx_u32(&x444, &x445, x443, x404, x428); + fiat_sm2_addcarryx_u32(&x446, &x447, x445, ((uint32_t)x405 + x389), (x429 + x407)); + fiat_sm2_subborrowx_u32(&x448, &x449, 0x0, x432, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x450, &x451, x449, x434, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x452, &x453, x451, x436, 0x0); + fiat_sm2_subborrowx_u32(&x454, &x455, x453, x438, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x456, &x457, x455, x440, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x458, &x459, x457, x442, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x460, &x461, x459, x444, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x462, &x463, x461, x446, UINT32_C(0xfffffffe)); + fiat_sm2_subborrowx_u32(&x464, &x465, x463, x447, 0x0); + fiat_sm2_cmovznz_u32(&x466, x465, x448, x432); + fiat_sm2_cmovznz_u32(&x467, x465, x450, x434); + fiat_sm2_cmovznz_u32(&x468, x465, x452, x436); + fiat_sm2_cmovznz_u32(&x469, x465, x454, x438); + fiat_sm2_cmovznz_u32(&x470, x465, x456, x440); + fiat_sm2_cmovznz_u32(&x471, x465, x458, x442); + fiat_sm2_cmovznz_u32(&x472, x465, x460, x444); + fiat_sm2_cmovznz_u32(&x473, x465, x462, x446); + out1[0] = x466; + out1[1] = x467; + out1[2] = x468; + out1[3] = x469; + out1[4] = x470; + out1[5] = x471; + out1[6] = x472; + out1[7] = x473; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_to_montgomery(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_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; + fiat_sm2_uint1 x22; + uint32_t x23; + fiat_sm2_uint1 x24; + uint32_t x25; + fiat_sm2_uint1 x26; + uint32_t x27; + fiat_sm2_uint1 x28; + uint32_t x29; + fiat_sm2_uint1 x30; + uint32_t x31; + fiat_sm2_uint1 x32; + uint32_t x33; + fiat_sm2_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; + uint32_t x43; + uint32_t x44; + uint32_t x45; + uint32_t x46; + uint32_t x47; + uint32_t x48; + uint32_t x49; + fiat_sm2_uint1 x50; + uint32_t x51; + fiat_sm2_uint1 x52; + uint32_t x53; + fiat_sm2_uint1 x54; + uint32_t x55; + fiat_sm2_uint1 x56; + uint32_t x57; + fiat_sm2_uint1 x58; + uint32_t x59; + fiat_sm2_uint1 x60; + uint32_t x61; + fiat_sm2_uint1 x62; + uint32_t x63; + fiat_sm2_uint1 x64; + uint32_t x65; + fiat_sm2_uint1 x66; + uint32_t x67; + fiat_sm2_uint1 x68; + uint32_t x69; + fiat_sm2_uint1 x70; + uint32_t x71; + fiat_sm2_uint1 x72; + uint32_t x73; + fiat_sm2_uint1 x74; + uint32_t x75; + fiat_sm2_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; + fiat_sm2_uint1 x90; + uint32_t x91; + fiat_sm2_uint1 x92; + uint32_t x93; + fiat_sm2_uint1 x94; + uint32_t x95; + fiat_sm2_uint1 x96; + uint32_t x97; + fiat_sm2_uint1 x98; + uint32_t x99; + fiat_sm2_uint1 x100; + uint32_t x101; + fiat_sm2_uint1 x102; + uint32_t x103; + fiat_sm2_uint1 x104; + uint32_t x105; + fiat_sm2_uint1 x106; + uint32_t x107; + fiat_sm2_uint1 x108; + uint32_t x109; + fiat_sm2_uint1 x110; + uint32_t x111; + fiat_sm2_uint1 x112; + uint32_t x113; + fiat_sm2_uint1 x114; + uint32_t x115; + fiat_sm2_uint1 x116; + uint32_t x117; + fiat_sm2_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; + uint32_t x132; + uint32_t x133; + fiat_sm2_uint1 x134; + uint32_t x135; + fiat_sm2_uint1 x136; + uint32_t x137; + fiat_sm2_uint1 x138; + uint32_t x139; + fiat_sm2_uint1 x140; + uint32_t x141; + fiat_sm2_uint1 x142; + uint32_t x143; + fiat_sm2_uint1 x144; + uint32_t x145; + fiat_sm2_uint1 x146; + uint32_t x147; + fiat_sm2_uint1 x148; + uint32_t x149; + fiat_sm2_uint1 x150; + uint32_t x151; + fiat_sm2_uint1 x152; + uint32_t x153; + fiat_sm2_uint1 x154; + uint32_t x155; + fiat_sm2_uint1 x156; + uint32_t x157; + fiat_sm2_uint1 x158; + uint32_t x159; + fiat_sm2_uint1 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; + uint32_t x170; + uint32_t x171; + uint32_t x172; + uint32_t x173; + fiat_sm2_uint1 x174; + uint32_t x175; + fiat_sm2_uint1 x176; + uint32_t x177; + fiat_sm2_uint1 x178; + uint32_t x179; + fiat_sm2_uint1 x180; + uint32_t x181; + fiat_sm2_uint1 x182; + uint32_t x183; + fiat_sm2_uint1 x184; + uint32_t x185; + fiat_sm2_uint1 x186; + uint32_t x187; + fiat_sm2_uint1 x188; + uint32_t x189; + fiat_sm2_uint1 x190; + uint32_t x191; + fiat_sm2_uint1 x192; + uint32_t x193; + fiat_sm2_uint1 x194; + uint32_t x195; + fiat_sm2_uint1 x196; + uint32_t x197; + fiat_sm2_uint1 x198; + uint32_t x199; + fiat_sm2_uint1 x200; + uint32_t x201; + fiat_sm2_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; + fiat_sm2_uint1 x218; + uint32_t x219; + fiat_sm2_uint1 x220; + uint32_t x221; + fiat_sm2_uint1 x222; + uint32_t x223; + fiat_sm2_uint1 x224; + uint32_t x225; + fiat_sm2_uint1 x226; + uint32_t x227; + fiat_sm2_uint1 x228; + uint32_t x229; + fiat_sm2_uint1 x230; + uint32_t x231; + fiat_sm2_uint1 x232; + uint32_t x233; + fiat_sm2_uint1 x234; + uint32_t x235; + fiat_sm2_uint1 x236; + uint32_t x237; + fiat_sm2_uint1 x238; + uint32_t x239; + fiat_sm2_uint1 x240; + uint32_t x241; + fiat_sm2_uint1 x242; + uint32_t x243; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x258; + uint32_t x259; + fiat_sm2_uint1 x260; + uint32_t x261; + fiat_sm2_uint1 x262; + uint32_t x263; + fiat_sm2_uint1 x264; + uint32_t x265; + fiat_sm2_uint1 x266; + uint32_t x267; + fiat_sm2_uint1 x268; + uint32_t x269; + fiat_sm2_uint1 x270; + uint32_t x271; + fiat_sm2_uint1 x272; + uint32_t x273; + fiat_sm2_uint1 x274; + uint32_t x275; + fiat_sm2_uint1 x276; + uint32_t x277; + fiat_sm2_uint1 x278; + uint32_t x279; + fiat_sm2_uint1 x280; + uint32_t x281; + fiat_sm2_uint1 x282; + uint32_t x283; + fiat_sm2_uint1 x284; + uint32_t x285; + fiat_sm2_uint1 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_sm2_uint1 x302; + uint32_t x303; + fiat_sm2_uint1 x304; + uint32_t x305; + fiat_sm2_uint1 x306; + uint32_t x307; + fiat_sm2_uint1 x308; + uint32_t x309; + fiat_sm2_uint1 x310; + uint32_t x311; + fiat_sm2_uint1 x312; + uint32_t x313; + fiat_sm2_uint1 x314; + uint32_t x315; + fiat_sm2_uint1 x316; + uint32_t x317; + fiat_sm2_uint1 x318; + uint32_t x319; + fiat_sm2_uint1 x320; + uint32_t x321; + fiat_sm2_uint1 x322; + uint32_t x323; + fiat_sm2_uint1 x324; + uint32_t x325; + fiat_sm2_uint1 x326; + uint32_t x327; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x342; + uint32_t x343; + fiat_sm2_uint1 x344; + uint32_t x345; + fiat_sm2_uint1 x346; + uint32_t x347; + fiat_sm2_uint1 x348; + uint32_t x349; + fiat_sm2_uint1 x350; + uint32_t x351; + fiat_sm2_uint1 x352; + uint32_t x353; + fiat_sm2_uint1 x354; + uint32_t x355; + fiat_sm2_uint1 x356; + uint32_t x357; + fiat_sm2_uint1 x358; + uint32_t x359; + fiat_sm2_uint1 x360; + uint32_t x361; + fiat_sm2_uint1 x362; + uint32_t x363; + fiat_sm2_uint1 x364; + uint32_t x365; + fiat_sm2_uint1 x366; + uint32_t x367; + fiat_sm2_uint1 x368; + uint32_t x369; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x386; + uint32_t x387; + fiat_sm2_uint1 x388; + uint32_t x389; + fiat_sm2_uint1 x390; + uint32_t x391; + fiat_sm2_uint1 x392; + uint32_t x393; + fiat_sm2_uint1 x394; + uint32_t x395; + fiat_sm2_uint1 x396; + uint32_t x397; + fiat_sm2_uint1 x398; + uint32_t x399; + fiat_sm2_uint1 x400; + uint32_t x401; + fiat_sm2_uint1 x402; + uint32_t x403; + fiat_sm2_uint1 x404; + uint32_t x405; + fiat_sm2_uint1 x406; + uint32_t x407; + fiat_sm2_uint1 x408; + uint32_t x409; + fiat_sm2_uint1 x410; + uint32_t x411; + fiat_sm2_uint1 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; + uint32_t x421; + uint32_t x422; + uint32_t x423; + uint32_t x424; + uint32_t x425; + fiat_sm2_uint1 x426; + uint32_t x427; + fiat_sm2_uint1 x428; + uint32_t x429; + fiat_sm2_uint1 x430; + uint32_t x431; + fiat_sm2_uint1 x432; + uint32_t x433; + fiat_sm2_uint1 x434; + uint32_t x435; + fiat_sm2_uint1 x436; + uint32_t x437; + fiat_sm2_uint1 x438; + uint32_t x439; + fiat_sm2_uint1 x440; + uint32_t x441; + fiat_sm2_uint1 x442; + uint32_t x443; + fiat_sm2_uint1 x444; + uint32_t x445; + fiat_sm2_uint1 x446; + uint32_t x447; + fiat_sm2_uint1 x448; + uint32_t x449; + fiat_sm2_uint1 x450; + uint32_t x451; + fiat_sm2_uint1 x452; + uint32_t x453; + fiat_sm2_uint1 x454; + uint32_t x455; + uint32_t x456; + uint32_t x457; + uint32_t x458; + uint32_t x459; + uint32_t x460; + uint32_t x461; + uint32_t x462; + uint32_t x463; + uint32_t x464; + uint32_t x465; + uint32_t x466; + uint32_t x467; + uint32_t x468; + uint32_t x469; + fiat_sm2_uint1 x470; + uint32_t x471; + fiat_sm2_uint1 x472; + uint32_t x473; + fiat_sm2_uint1 x474; + uint32_t x475; + fiat_sm2_uint1 x476; + uint32_t x477; + fiat_sm2_uint1 x478; + uint32_t x479; + fiat_sm2_uint1 x480; + uint32_t x481; + fiat_sm2_uint1 x482; + uint32_t x483; + fiat_sm2_uint1 x484; + uint32_t x485; + fiat_sm2_uint1 x486; + uint32_t x487; + fiat_sm2_uint1 x488; + uint32_t x489; + fiat_sm2_uint1 x490; + uint32_t x491; + fiat_sm2_uint1 x492; + uint32_t x493; + fiat_sm2_uint1 x494; + uint32_t x495; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x510; + uint32_t x511; + fiat_sm2_uint1 x512; + uint32_t x513; + fiat_sm2_uint1 x514; + uint32_t x515; + fiat_sm2_uint1 x516; + uint32_t x517; + fiat_sm2_uint1 x518; + uint32_t x519; + fiat_sm2_uint1 x520; + uint32_t x521; + fiat_sm2_uint1 x522; + uint32_t x523; + fiat_sm2_uint1 x524; + uint32_t x525; + fiat_sm2_uint1 x526; + uint32_t x527; + fiat_sm2_uint1 x528; + uint32_t x529; + fiat_sm2_uint1 x530; + uint32_t x531; + fiat_sm2_uint1 x532; + uint32_t x533; + fiat_sm2_uint1 x534; + uint32_t x535; + fiat_sm2_uint1 x536; + uint32_t x537; + fiat_sm2_uint1 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; + uint32_t x550; + uint32_t x551; + uint32_t x552; + uint32_t x553; + fiat_sm2_uint1 x554; + uint32_t x555; + fiat_sm2_uint1 x556; + uint32_t x557; + fiat_sm2_uint1 x558; + uint32_t x559; + fiat_sm2_uint1 x560; + uint32_t x561; + fiat_sm2_uint1 x562; + uint32_t x563; + fiat_sm2_uint1 x564; + uint32_t x565; + fiat_sm2_uint1 x566; + uint32_t x567; + fiat_sm2_uint1 x568; + uint32_t x569; + fiat_sm2_uint1 x570; + uint32_t x571; + fiat_sm2_uint1 x572; + uint32_t x573; + fiat_sm2_uint1 x574; + uint32_t x575; + fiat_sm2_uint1 x576; + uint32_t x577; + fiat_sm2_uint1 x578; + uint32_t x579; + fiat_sm2_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; + fiat_sm2_uint1 x594; + uint32_t x595; + fiat_sm2_uint1 x596; + uint32_t x597; + fiat_sm2_uint1 x598; + uint32_t x599; + fiat_sm2_uint1 x600; + uint32_t x601; + fiat_sm2_uint1 x602; + uint32_t x603; + fiat_sm2_uint1 x604; + uint32_t x605; + fiat_sm2_uint1 x606; + uint32_t x607; + fiat_sm2_uint1 x608; + uint32_t x609; + fiat_sm2_uint1 x610; + uint32_t x611; + fiat_sm2_uint1 x612; + uint32_t x613; + fiat_sm2_uint1 x614; + uint32_t x615; + fiat_sm2_uint1 x616; + uint32_t x617; + fiat_sm2_uint1 x618; + uint32_t x619; + fiat_sm2_uint1 x620; + uint32_t x621; + fiat_sm2_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; + fiat_sm2_uint1 x638; + uint32_t x639; + fiat_sm2_uint1 x640; + uint32_t x641; + fiat_sm2_uint1 x642; + uint32_t x643; + fiat_sm2_uint1 x644; + uint32_t x645; + fiat_sm2_uint1 x646; + uint32_t x647; + fiat_sm2_uint1 x648; + uint32_t x649; + fiat_sm2_uint1 x650; + uint32_t x651; + fiat_sm2_uint1 x652; + uint32_t x653; + fiat_sm2_uint1 x654; + uint32_t x655; + fiat_sm2_uint1 x656; + uint32_t x657; + fiat_sm2_uint1 x658; + uint32_t x659; + fiat_sm2_uint1 x660; + uint32_t x661; + fiat_sm2_uint1 x662; + uint32_t x663; + fiat_sm2_uint1 x664; + uint32_t x665; + fiat_sm2_uint1 x666; + uint32_t x667; + fiat_sm2_uint1 x668; + uint32_t x669; + fiat_sm2_uint1 x670; + uint32_t x671; + fiat_sm2_uint1 x672; + uint32_t x673; + fiat_sm2_uint1 x674; + uint32_t x675; + fiat_sm2_uint1 x676; + uint32_t x677; + fiat_sm2_uint1 x678; + uint32_t x679; + fiat_sm2_uint1 x680; + uint32_t x681; + fiat_sm2_uint1 x682; + uint32_t x683; + uint32_t x684; + uint32_t x685; + uint32_t x686; + uint32_t x687; + uint32_t x688; + uint32_t x689; + uint32_t x690; + 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_sm2_mulx_u32(&x9, &x10, x8, 0x4); + fiat_sm2_mulx_u32(&x11, &x12, x8, 0x2); + fiat_sm2_mulx_u32(&x13, &x14, x8, 0x2); + fiat_sm2_mulx_u32(&x15, &x16, x8, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x17, &x18, x8, 0x2); + fiat_sm2_mulx_u32(&x19, &x20, x8, 0x3); + fiat_sm2_addcarryx_u32(&x21, &x22, 0x0, x20, x17); + fiat_sm2_addcarryx_u32(&x23, &x24, x22, (fiat_sm2_uint1)x18, x15); + fiat_sm2_addcarryx_u32(&x25, &x26, x24, x16, x13); + fiat_sm2_addcarryx_u32(&x27, &x28, x26, (fiat_sm2_uint1)x14, x8); + fiat_sm2_addcarryx_u32(&x29, &x30, x28, 0x0, x8); + fiat_sm2_addcarryx_u32(&x31, &x32, x30, 0x0, x11); + fiat_sm2_addcarryx_u32(&x33, &x34, x32, (fiat_sm2_uint1)x12, x9); + fiat_sm2_mulx_u32(&x35, &x36, x19, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x37, &x38, x19, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x39, &x40, x19, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x41, &x42, x19, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x43, &x44, x19, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x45, &x46, x19, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x47, &x48, x19, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x49, &x50, 0x0, x48, x45); + fiat_sm2_addcarryx_u32(&x51, &x52, 0x0, x44, x41); + fiat_sm2_addcarryx_u32(&x53, &x54, x52, x42, x39); + fiat_sm2_addcarryx_u32(&x55, &x56, x54, x40, x37); + fiat_sm2_addcarryx_u32(&x57, &x58, x56, x38, x35); + fiat_sm2_addcarryx_u32(&x59, &x60, 0x0, x19, x47); + fiat_sm2_addcarryx_u32(&x61, &x62, x60, x21, x49); + fiat_sm2_addcarryx_u32(&x63, &x64, x62, x23, (x50 + x46)); + fiat_sm2_addcarryx_u32(&x65, &x66, x64, x25, x43); + fiat_sm2_addcarryx_u32(&x67, &x68, x66, x27, x51); + fiat_sm2_addcarryx_u32(&x69, &x70, x68, x29, x53); + fiat_sm2_addcarryx_u32(&x71, &x72, x70, x31, x55); + fiat_sm2_addcarryx_u32(&x73, &x74, x72, x33, x57); + fiat_sm2_addcarryx_u32(&x75, &x76, x74, (x34 + x10), (x58 + x36)); + fiat_sm2_mulx_u32(&x77, &x78, x1, 0x4); + fiat_sm2_mulx_u32(&x79, &x80, x1, 0x2); + fiat_sm2_mulx_u32(&x81, &x82, x1, 0x2); + fiat_sm2_mulx_u32(&x83, &x84, x1, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x85, &x86, x1, 0x2); + fiat_sm2_mulx_u32(&x87, &x88, x1, 0x3); + fiat_sm2_addcarryx_u32(&x89, &x90, 0x0, x88, x85); + fiat_sm2_addcarryx_u32(&x91, &x92, x90, (fiat_sm2_uint1)x86, x83); + fiat_sm2_addcarryx_u32(&x93, &x94, x92, x84, x81); + fiat_sm2_addcarryx_u32(&x95, &x96, x94, (fiat_sm2_uint1)x82, x1); + fiat_sm2_addcarryx_u32(&x97, &x98, x96, 0x0, x1); + fiat_sm2_addcarryx_u32(&x99, &x100, x98, 0x0, x79); + fiat_sm2_addcarryx_u32(&x101, &x102, x100, (fiat_sm2_uint1)x80, x77); + fiat_sm2_addcarryx_u32(&x103, &x104, 0x0, x61, x87); + fiat_sm2_addcarryx_u32(&x105, &x106, x104, x63, x89); + fiat_sm2_addcarryx_u32(&x107, &x108, x106, x65, x91); + fiat_sm2_addcarryx_u32(&x109, &x110, x108, x67, x93); + fiat_sm2_addcarryx_u32(&x111, &x112, x110, x69, x95); + fiat_sm2_addcarryx_u32(&x113, &x114, x112, x71, x97); + fiat_sm2_addcarryx_u32(&x115, &x116, x114, x73, x99); + fiat_sm2_addcarryx_u32(&x117, &x118, x116, x75, x101); + fiat_sm2_mulx_u32(&x119, &x120, x103, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x121, &x122, x103, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x123, &x124, x103, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x125, &x126, x103, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x127, &x128, x103, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x129, &x130, x103, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x131, &x132, x103, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x133, &x134, 0x0, x132, x129); + fiat_sm2_addcarryx_u32(&x135, &x136, 0x0, x128, x125); + fiat_sm2_addcarryx_u32(&x137, &x138, x136, x126, x123); + fiat_sm2_addcarryx_u32(&x139, &x140, x138, x124, x121); + fiat_sm2_addcarryx_u32(&x141, &x142, x140, x122, x119); + fiat_sm2_addcarryx_u32(&x143, &x144, 0x0, x103, x131); + fiat_sm2_addcarryx_u32(&x145, &x146, x144, x105, x133); + fiat_sm2_addcarryx_u32(&x147, &x148, x146, x107, (x134 + x130)); + fiat_sm2_addcarryx_u32(&x149, &x150, x148, x109, x127); + fiat_sm2_addcarryx_u32(&x151, &x152, x150, x111, x135); + fiat_sm2_addcarryx_u32(&x153, &x154, x152, x113, x137); + fiat_sm2_addcarryx_u32(&x155, &x156, x154, x115, x139); + fiat_sm2_addcarryx_u32(&x157, &x158, x156, x117, x141); + fiat_sm2_addcarryx_u32(&x159, &x160, x158, (((uint32_t)x118 + x76) + (x102 + x78)), (x142 + x120)); + fiat_sm2_mulx_u32(&x161, &x162, x2, 0x4); + fiat_sm2_mulx_u32(&x163, &x164, x2, 0x2); + fiat_sm2_mulx_u32(&x165, &x166, x2, 0x2); + fiat_sm2_mulx_u32(&x167, &x168, x2, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x169, &x170, x2, 0x2); + fiat_sm2_mulx_u32(&x171, &x172, x2, 0x3); + fiat_sm2_addcarryx_u32(&x173, &x174, 0x0, x172, x169); + fiat_sm2_addcarryx_u32(&x175, &x176, x174, (fiat_sm2_uint1)x170, x167); + fiat_sm2_addcarryx_u32(&x177, &x178, x176, x168, x165); + fiat_sm2_addcarryx_u32(&x179, &x180, x178, (fiat_sm2_uint1)x166, x2); + fiat_sm2_addcarryx_u32(&x181, &x182, x180, 0x0, x2); + fiat_sm2_addcarryx_u32(&x183, &x184, x182, 0x0, x163); + fiat_sm2_addcarryx_u32(&x185, &x186, x184, (fiat_sm2_uint1)x164, x161); + fiat_sm2_addcarryx_u32(&x187, &x188, 0x0, x145, x171); + fiat_sm2_addcarryx_u32(&x189, &x190, x188, x147, x173); + fiat_sm2_addcarryx_u32(&x191, &x192, x190, x149, x175); + fiat_sm2_addcarryx_u32(&x193, &x194, x192, x151, x177); + fiat_sm2_addcarryx_u32(&x195, &x196, x194, x153, x179); + fiat_sm2_addcarryx_u32(&x197, &x198, x196, x155, x181); + fiat_sm2_addcarryx_u32(&x199, &x200, x198, x157, x183); + fiat_sm2_addcarryx_u32(&x201, &x202, x200, x159, x185); + fiat_sm2_mulx_u32(&x203, &x204, x187, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x205, &x206, x187, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x207, &x208, x187, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x209, &x210, x187, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x211, &x212, x187, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x213, &x214, x187, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x215, &x216, x187, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x217, &x218, 0x0, x216, x213); + fiat_sm2_addcarryx_u32(&x219, &x220, 0x0, x212, x209); + fiat_sm2_addcarryx_u32(&x221, &x222, x220, x210, x207); + fiat_sm2_addcarryx_u32(&x223, &x224, x222, x208, x205); + fiat_sm2_addcarryx_u32(&x225, &x226, x224, x206, x203); + fiat_sm2_addcarryx_u32(&x227, &x228, 0x0, x187, x215); + fiat_sm2_addcarryx_u32(&x229, &x230, x228, x189, x217); + fiat_sm2_addcarryx_u32(&x231, &x232, x230, x191, (x218 + x214)); + fiat_sm2_addcarryx_u32(&x233, &x234, x232, x193, x211); + fiat_sm2_addcarryx_u32(&x235, &x236, x234, x195, x219); + fiat_sm2_addcarryx_u32(&x237, &x238, x236, x197, x221); + fiat_sm2_addcarryx_u32(&x239, &x240, x238, x199, x223); + fiat_sm2_addcarryx_u32(&x241, &x242, x240, x201, x225); + fiat_sm2_addcarryx_u32(&x243, &x244, x242, (((uint32_t)x202 + x160) + (x186 + x162)), (x226 + x204)); + fiat_sm2_mulx_u32(&x245, &x246, x3, 0x4); + fiat_sm2_mulx_u32(&x247, &x248, x3, 0x2); + fiat_sm2_mulx_u32(&x249, &x250, x3, 0x2); + fiat_sm2_mulx_u32(&x251, &x252, x3, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x253, &x254, x3, 0x2); + fiat_sm2_mulx_u32(&x255, &x256, x3, 0x3); + fiat_sm2_addcarryx_u32(&x257, &x258, 0x0, x256, x253); + fiat_sm2_addcarryx_u32(&x259, &x260, x258, (fiat_sm2_uint1)x254, x251); + fiat_sm2_addcarryx_u32(&x261, &x262, x260, x252, x249); + fiat_sm2_addcarryx_u32(&x263, &x264, x262, (fiat_sm2_uint1)x250, x3); + fiat_sm2_addcarryx_u32(&x265, &x266, x264, 0x0, x3); + fiat_sm2_addcarryx_u32(&x267, &x268, x266, 0x0, x247); + fiat_sm2_addcarryx_u32(&x269, &x270, x268, (fiat_sm2_uint1)x248, x245); + fiat_sm2_addcarryx_u32(&x271, &x272, 0x0, x229, x255); + fiat_sm2_addcarryx_u32(&x273, &x274, x272, x231, x257); + fiat_sm2_addcarryx_u32(&x275, &x276, x274, x233, x259); + fiat_sm2_addcarryx_u32(&x277, &x278, x276, x235, x261); + fiat_sm2_addcarryx_u32(&x279, &x280, x278, x237, x263); + fiat_sm2_addcarryx_u32(&x281, &x282, x280, x239, x265); + fiat_sm2_addcarryx_u32(&x283, &x284, x282, x241, x267); + fiat_sm2_addcarryx_u32(&x285, &x286, x284, x243, x269); + fiat_sm2_mulx_u32(&x287, &x288, x271, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x289, &x290, x271, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x291, &x292, x271, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x293, &x294, x271, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x295, &x296, x271, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x297, &x298, x271, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x299, &x300, x271, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x301, &x302, 0x0, x300, x297); + fiat_sm2_addcarryx_u32(&x303, &x304, 0x0, x296, x293); + fiat_sm2_addcarryx_u32(&x305, &x306, x304, x294, x291); + fiat_sm2_addcarryx_u32(&x307, &x308, x306, x292, x289); + fiat_sm2_addcarryx_u32(&x309, &x310, x308, x290, x287); + fiat_sm2_addcarryx_u32(&x311, &x312, 0x0, x271, x299); + fiat_sm2_addcarryx_u32(&x313, &x314, x312, x273, x301); + fiat_sm2_addcarryx_u32(&x315, &x316, x314, x275, (x302 + x298)); + fiat_sm2_addcarryx_u32(&x317, &x318, x316, x277, x295); + fiat_sm2_addcarryx_u32(&x319, &x320, x318, x279, x303); + fiat_sm2_addcarryx_u32(&x321, &x322, x320, x281, x305); + fiat_sm2_addcarryx_u32(&x323, &x324, x322, x283, x307); + fiat_sm2_addcarryx_u32(&x325, &x326, x324, x285, x309); + fiat_sm2_addcarryx_u32(&x327, &x328, x326, (((uint32_t)x286 + x244) + (x270 + x246)), (x310 + x288)); + fiat_sm2_mulx_u32(&x329, &x330, x4, 0x4); + fiat_sm2_mulx_u32(&x331, &x332, x4, 0x2); + fiat_sm2_mulx_u32(&x333, &x334, x4, 0x2); + fiat_sm2_mulx_u32(&x335, &x336, x4, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x337, &x338, x4, 0x2); + fiat_sm2_mulx_u32(&x339, &x340, x4, 0x3); + fiat_sm2_addcarryx_u32(&x341, &x342, 0x0, x340, x337); + fiat_sm2_addcarryx_u32(&x343, &x344, x342, (fiat_sm2_uint1)x338, x335); + fiat_sm2_addcarryx_u32(&x345, &x346, x344, x336, x333); + fiat_sm2_addcarryx_u32(&x347, &x348, x346, (fiat_sm2_uint1)x334, x4); + fiat_sm2_addcarryx_u32(&x349, &x350, x348, 0x0, x4); + fiat_sm2_addcarryx_u32(&x351, &x352, x350, 0x0, x331); + fiat_sm2_addcarryx_u32(&x353, &x354, x352, (fiat_sm2_uint1)x332, x329); + fiat_sm2_addcarryx_u32(&x355, &x356, 0x0, x313, x339); + fiat_sm2_addcarryx_u32(&x357, &x358, x356, x315, x341); + fiat_sm2_addcarryx_u32(&x359, &x360, x358, x317, x343); + fiat_sm2_addcarryx_u32(&x361, &x362, x360, x319, x345); + fiat_sm2_addcarryx_u32(&x363, &x364, x362, x321, x347); + fiat_sm2_addcarryx_u32(&x365, &x366, x364, x323, x349); + fiat_sm2_addcarryx_u32(&x367, &x368, x366, x325, x351); + fiat_sm2_addcarryx_u32(&x369, &x370, x368, x327, x353); + fiat_sm2_mulx_u32(&x371, &x372, x355, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x373, &x374, x355, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x375, &x376, x355, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x377, &x378, x355, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x379, &x380, x355, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x381, &x382, x355, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x383, &x384, x355, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x385, &x386, 0x0, x384, x381); + fiat_sm2_addcarryx_u32(&x387, &x388, 0x0, x380, x377); + fiat_sm2_addcarryx_u32(&x389, &x390, x388, x378, x375); + fiat_sm2_addcarryx_u32(&x391, &x392, x390, x376, x373); + fiat_sm2_addcarryx_u32(&x393, &x394, x392, x374, x371); + fiat_sm2_addcarryx_u32(&x395, &x396, 0x0, x355, x383); + fiat_sm2_addcarryx_u32(&x397, &x398, x396, x357, x385); + fiat_sm2_addcarryx_u32(&x399, &x400, x398, x359, (x386 + x382)); + fiat_sm2_addcarryx_u32(&x401, &x402, x400, x361, x379); + fiat_sm2_addcarryx_u32(&x403, &x404, x402, x363, x387); + fiat_sm2_addcarryx_u32(&x405, &x406, x404, x365, x389); + fiat_sm2_addcarryx_u32(&x407, &x408, x406, x367, x391); + fiat_sm2_addcarryx_u32(&x409, &x410, x408, x369, x393); + fiat_sm2_addcarryx_u32(&x411, &x412, x410, (((uint32_t)x370 + x328) + (x354 + x330)), (x394 + x372)); + fiat_sm2_mulx_u32(&x413, &x414, x5, 0x4); + fiat_sm2_mulx_u32(&x415, &x416, x5, 0x2); + fiat_sm2_mulx_u32(&x417, &x418, x5, 0x2); + fiat_sm2_mulx_u32(&x419, &x420, x5, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x421, &x422, x5, 0x2); + fiat_sm2_mulx_u32(&x423, &x424, x5, 0x3); + fiat_sm2_addcarryx_u32(&x425, &x426, 0x0, x424, x421); + fiat_sm2_addcarryx_u32(&x427, &x428, x426, (fiat_sm2_uint1)x422, x419); + fiat_sm2_addcarryx_u32(&x429, &x430, x428, x420, x417); + fiat_sm2_addcarryx_u32(&x431, &x432, x430, (fiat_sm2_uint1)x418, x5); + fiat_sm2_addcarryx_u32(&x433, &x434, x432, 0x0, x5); + fiat_sm2_addcarryx_u32(&x435, &x436, x434, 0x0, x415); + fiat_sm2_addcarryx_u32(&x437, &x438, x436, (fiat_sm2_uint1)x416, x413); + fiat_sm2_addcarryx_u32(&x439, &x440, 0x0, x397, x423); + fiat_sm2_addcarryx_u32(&x441, &x442, x440, x399, x425); + fiat_sm2_addcarryx_u32(&x443, &x444, x442, x401, x427); + fiat_sm2_addcarryx_u32(&x445, &x446, x444, x403, x429); + fiat_sm2_addcarryx_u32(&x447, &x448, x446, x405, x431); + fiat_sm2_addcarryx_u32(&x449, &x450, x448, x407, x433); + fiat_sm2_addcarryx_u32(&x451, &x452, x450, x409, x435); + fiat_sm2_addcarryx_u32(&x453, &x454, x452, x411, x437); + fiat_sm2_mulx_u32(&x455, &x456, x439, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x457, &x458, x439, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x459, &x460, x439, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x461, &x462, x439, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x463, &x464, x439, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x465, &x466, x439, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x467, &x468, x439, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x469, &x470, 0x0, x468, x465); + fiat_sm2_addcarryx_u32(&x471, &x472, 0x0, x464, x461); + fiat_sm2_addcarryx_u32(&x473, &x474, x472, x462, x459); + fiat_sm2_addcarryx_u32(&x475, &x476, x474, x460, x457); + fiat_sm2_addcarryx_u32(&x477, &x478, x476, x458, x455); + fiat_sm2_addcarryx_u32(&x479, &x480, 0x0, x439, x467); + fiat_sm2_addcarryx_u32(&x481, &x482, x480, x441, x469); + fiat_sm2_addcarryx_u32(&x483, &x484, x482, x443, (x470 + x466)); + fiat_sm2_addcarryx_u32(&x485, &x486, x484, x445, x463); + fiat_sm2_addcarryx_u32(&x487, &x488, x486, x447, x471); + fiat_sm2_addcarryx_u32(&x489, &x490, x488, x449, x473); + fiat_sm2_addcarryx_u32(&x491, &x492, x490, x451, x475); + fiat_sm2_addcarryx_u32(&x493, &x494, x492, x453, x477); + fiat_sm2_addcarryx_u32(&x495, &x496, x494, (((uint32_t)x454 + x412) + (x438 + x414)), (x478 + x456)); + fiat_sm2_mulx_u32(&x497, &x498, x6, 0x4); + fiat_sm2_mulx_u32(&x499, &x500, x6, 0x2); + fiat_sm2_mulx_u32(&x501, &x502, x6, 0x2); + fiat_sm2_mulx_u32(&x503, &x504, x6, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x505, &x506, x6, 0x2); + fiat_sm2_mulx_u32(&x507, &x508, x6, 0x3); + fiat_sm2_addcarryx_u32(&x509, &x510, 0x0, x508, x505); + fiat_sm2_addcarryx_u32(&x511, &x512, x510, (fiat_sm2_uint1)x506, x503); + fiat_sm2_addcarryx_u32(&x513, &x514, x512, x504, x501); + fiat_sm2_addcarryx_u32(&x515, &x516, x514, (fiat_sm2_uint1)x502, x6); + fiat_sm2_addcarryx_u32(&x517, &x518, x516, 0x0, x6); + fiat_sm2_addcarryx_u32(&x519, &x520, x518, 0x0, x499); + fiat_sm2_addcarryx_u32(&x521, &x522, x520, (fiat_sm2_uint1)x500, x497); + fiat_sm2_addcarryx_u32(&x523, &x524, 0x0, x481, x507); + fiat_sm2_addcarryx_u32(&x525, &x526, x524, x483, x509); + fiat_sm2_addcarryx_u32(&x527, &x528, x526, x485, x511); + fiat_sm2_addcarryx_u32(&x529, &x530, x528, x487, x513); + fiat_sm2_addcarryx_u32(&x531, &x532, x530, x489, x515); + fiat_sm2_addcarryx_u32(&x533, &x534, x532, x491, x517); + fiat_sm2_addcarryx_u32(&x535, &x536, x534, x493, x519); + fiat_sm2_addcarryx_u32(&x537, &x538, x536, x495, x521); + fiat_sm2_mulx_u32(&x539, &x540, x523, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x541, &x542, x523, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x543, &x544, x523, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x545, &x546, x523, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x547, &x548, x523, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x549, &x550, x523, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x551, &x552, x523, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x553, &x554, 0x0, x552, x549); + fiat_sm2_addcarryx_u32(&x555, &x556, 0x0, x548, x545); + fiat_sm2_addcarryx_u32(&x557, &x558, x556, x546, x543); + fiat_sm2_addcarryx_u32(&x559, &x560, x558, x544, x541); + fiat_sm2_addcarryx_u32(&x561, &x562, x560, x542, x539); + fiat_sm2_addcarryx_u32(&x563, &x564, 0x0, x523, x551); + fiat_sm2_addcarryx_u32(&x565, &x566, x564, x525, x553); + fiat_sm2_addcarryx_u32(&x567, &x568, x566, x527, (x554 + x550)); + fiat_sm2_addcarryx_u32(&x569, &x570, x568, x529, x547); + fiat_sm2_addcarryx_u32(&x571, &x572, x570, x531, x555); + fiat_sm2_addcarryx_u32(&x573, &x574, x572, x533, x557); + fiat_sm2_addcarryx_u32(&x575, &x576, x574, x535, x559); + fiat_sm2_addcarryx_u32(&x577, &x578, x576, x537, x561); + fiat_sm2_addcarryx_u32(&x579, &x580, x578, (((uint32_t)x538 + x496) + (x522 + x498)), (x562 + x540)); + fiat_sm2_mulx_u32(&x581, &x582, x7, 0x4); + fiat_sm2_mulx_u32(&x583, &x584, x7, 0x2); + fiat_sm2_mulx_u32(&x585, &x586, x7, 0x2); + fiat_sm2_mulx_u32(&x587, &x588, x7, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x589, &x590, x7, 0x2); + fiat_sm2_mulx_u32(&x591, &x592, x7, 0x3); + fiat_sm2_addcarryx_u32(&x593, &x594, 0x0, x592, x589); + fiat_sm2_addcarryx_u32(&x595, &x596, x594, (fiat_sm2_uint1)x590, x587); + fiat_sm2_addcarryx_u32(&x597, &x598, x596, x588, x585); + fiat_sm2_addcarryx_u32(&x599, &x600, x598, (fiat_sm2_uint1)x586, x7); + fiat_sm2_addcarryx_u32(&x601, &x602, x600, 0x0, x7); + fiat_sm2_addcarryx_u32(&x603, &x604, x602, 0x0, x583); + fiat_sm2_addcarryx_u32(&x605, &x606, x604, (fiat_sm2_uint1)x584, x581); + fiat_sm2_addcarryx_u32(&x607, &x608, 0x0, x565, x591); + fiat_sm2_addcarryx_u32(&x609, &x610, x608, x567, x593); + fiat_sm2_addcarryx_u32(&x611, &x612, x610, x569, x595); + fiat_sm2_addcarryx_u32(&x613, &x614, x612, x571, x597); + fiat_sm2_addcarryx_u32(&x615, &x616, x614, x573, x599); + fiat_sm2_addcarryx_u32(&x617, &x618, x616, x575, x601); + fiat_sm2_addcarryx_u32(&x619, &x620, x618, x577, x603); + fiat_sm2_addcarryx_u32(&x621, &x622, x620, x579, x605); + fiat_sm2_mulx_u32(&x623, &x624, x607, UINT32_C(0xfffffffe)); + fiat_sm2_mulx_u32(&x625, &x626, x607, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x627, &x628, x607, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x629, &x630, x607, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x631, &x632, x607, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x633, &x634, x607, UINT32_C(0xffffffff)); + fiat_sm2_mulx_u32(&x635, &x636, x607, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x637, &x638, 0x0, x636, x633); + fiat_sm2_addcarryx_u32(&x639, &x640, 0x0, x632, x629); + fiat_sm2_addcarryx_u32(&x641, &x642, x640, x630, x627); + fiat_sm2_addcarryx_u32(&x643, &x644, x642, x628, x625); + fiat_sm2_addcarryx_u32(&x645, &x646, x644, x626, x623); + fiat_sm2_addcarryx_u32(&x647, &x648, 0x0, x607, x635); + fiat_sm2_addcarryx_u32(&x649, &x650, x648, x609, x637); + fiat_sm2_addcarryx_u32(&x651, &x652, x650, x611, (x638 + x634)); + fiat_sm2_addcarryx_u32(&x653, &x654, x652, x613, x631); + fiat_sm2_addcarryx_u32(&x655, &x656, x654, x615, x639); + fiat_sm2_addcarryx_u32(&x657, &x658, x656, x617, x641); + fiat_sm2_addcarryx_u32(&x659, &x660, x658, x619, x643); + fiat_sm2_addcarryx_u32(&x661, &x662, x660, x621, x645); + fiat_sm2_addcarryx_u32(&x663, &x664, x662, (((uint32_t)x622 + x580) + (x606 + x582)), (x646 + x624)); + fiat_sm2_subborrowx_u32(&x665, &x666, 0x0, x649, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x667, &x668, x666, x651, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x669, &x670, x668, x653, 0x0); + fiat_sm2_subborrowx_u32(&x671, &x672, x670, x655, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x673, &x674, x672, x657, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x675, &x676, x674, x659, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x677, &x678, x676, x661, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x679, &x680, x678, x663, UINT32_C(0xfffffffe)); + fiat_sm2_subborrowx_u32(&x681, &x682, x680, x664, 0x0); + fiat_sm2_cmovznz_u32(&x683, x682, x665, x649); + fiat_sm2_cmovznz_u32(&x684, x682, x667, x651); + fiat_sm2_cmovznz_u32(&x685, x682, x669, x653); + fiat_sm2_cmovznz_u32(&x686, x682, x671, x655); + fiat_sm2_cmovznz_u32(&x687, x682, x673, x657); + fiat_sm2_cmovznz_u32(&x688, x682, x675, x659); + fiat_sm2_cmovznz_u32(&x689, x682, x677, x661); + fiat_sm2_cmovznz_u32(&x690, x682, x679, x663); + out1[0] = x683; + out1[1] = x684; + out1[2] = x685; + out1[3] = x686; + out1[4] = x687; + out1[5] = x688; + out1[6] = x689; + out1[7] = x690; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_selectznz(uint32_t out1[8], fiat_sm2_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_sm2_cmovznz_u32(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_sm2_cmovznz_u32(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_sm2_cmovznz_u32(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_sm2_cmovznz_u32(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_sm2_cmovznz_u32(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_sm2_cmovznz_u32(&x6, arg1, (arg2[5]), (arg3[5])); + fiat_sm2_cmovznz_u32(&x7, arg1, (arg2[6]), (arg3[6])); + fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_set_one(fiat_sm2_montgomery_domain_field_element out1) { + out1[0] = 0x1; + out1[1] = 0x0; + out1[2] = UINT32_C(0xffffffff); + out1[3] = 0x0; + out1[4] = 0x0; + out1[5] = 0x0; + out1[6] = 0x0; + out1[7] = 0x1; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_msat(uint32_t out1[9]) { + out1[0] = UINT32_C(0xffffffff); + out1[1] = UINT32_C(0xffffffff); + out1[2] = 0x0; + out1[3] = UINT32_C(0xffffffff); + out1[4] = UINT32_C(0xffffffff); + out1[5] = UINT32_C(0xffffffff); + out1[6] = UINT32_C(0xffffffff); + out1[7] = UINT32_C(0xfffffffe); + out1[8] = 0x0; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_uint1 x2; + fiat_sm2_uint1 x3; + uint32_t x4; + fiat_sm2_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_sm2_uint1 x17; + uint32_t x18; + fiat_sm2_uint1 x19; + uint32_t x20; + fiat_sm2_uint1 x21; + uint32_t x22; + fiat_sm2_uint1 x23; + uint32_t x24; + fiat_sm2_uint1 x25; + uint32_t x26; + fiat_sm2_uint1 x27; + uint32_t x28; + fiat_sm2_uint1 x29; + uint32_t x30; + fiat_sm2_uint1 x31; + uint32_t x32; + fiat_sm2_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_sm2_uint1 x52; + uint32_t x53; + fiat_sm2_uint1 x54; + uint32_t x55; + fiat_sm2_uint1 x56; + uint32_t x57; + fiat_sm2_uint1 x58; + uint32_t x59; + fiat_sm2_uint1 x60; + uint32_t x61; + fiat_sm2_uint1 x62; + uint32_t x63; + fiat_sm2_uint1 x64; + uint32_t x65; + fiat_sm2_uint1 x66; + uint32_t x67; + fiat_sm2_uint1 x68; + uint32_t x69; + fiat_sm2_uint1 x70; + uint32_t x71; + fiat_sm2_uint1 x72; + uint32_t x73; + fiat_sm2_uint1 x74; + uint32_t x75; + fiat_sm2_uint1 x76; + uint32_t x77; + fiat_sm2_uint1 x78; + uint32_t x79; + fiat_sm2_uint1 x80; + uint32_t x81; + fiat_sm2_uint1 x82; + uint32_t x83; + fiat_sm2_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_sm2_uint1 x94; + uint32_t x95; + fiat_sm2_uint1 x96; + uint32_t x97; + fiat_sm2_uint1 x98; + uint32_t x99; + fiat_sm2_uint1 x100; + uint32_t x101; + fiat_sm2_uint1 x102; + uint32_t x103; + fiat_sm2_uint1 x104; + uint32_t x105; + fiat_sm2_uint1 x106; + uint32_t x107; + fiat_sm2_uint1 x108; + uint32_t x109; + uint32_t x110; + fiat_sm2_uint1 x111; + uint32_t x112; + fiat_sm2_uint1 x113; + uint32_t x114; + fiat_sm2_uint1 x115; + uint32_t x116; + fiat_sm2_uint1 x117; + uint32_t x118; + fiat_sm2_uint1 x119; + uint32_t x120; + fiat_sm2_uint1 x121; + uint32_t x122; + fiat_sm2_uint1 x123; + uint32_t x124; + fiat_sm2_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_sm2_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_sm2_uint1 x145; + uint32_t x146; + fiat_sm2_uint1 x147; + uint32_t x148; + fiat_sm2_uint1 x149; + uint32_t x150; + fiat_sm2_uint1 x151; + uint32_t x152; + fiat_sm2_uint1 x153; + uint32_t x154; + fiat_sm2_uint1 x155; + uint32_t x156; + fiat_sm2_uint1 x157; + uint32_t x158; + fiat_sm2_uint1 x159; + uint32_t x160; + fiat_sm2_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_sm2_uint1 x171; + uint32_t x172; + fiat_sm2_uint1 x173; + uint32_t x174; + fiat_sm2_uint1 x175; + uint32_t x176; + fiat_sm2_uint1 x177; + uint32_t x178; + fiat_sm2_uint1 x179; + uint32_t x180; + fiat_sm2_uint1 x181; + uint32_t x182; + fiat_sm2_uint1 x183; + uint32_t x184; + fiat_sm2_uint1 x185; + uint32_t x186; + fiat_sm2_uint1 x187; + uint32_t x188; + fiat_sm2_uint1 x189; + uint32_t x190; + fiat_sm2_uint1 x191; + uint32_t x192; + fiat_sm2_uint1 x193; + uint32_t x194; + fiat_sm2_uint1 x195; + uint32_t x196; + fiat_sm2_uint1 x197; + uint32_t x198; + fiat_sm2_uint1 x199; + uint32_t x200; + fiat_sm2_uint1 x201; + uint32_t x202; + fiat_sm2_uint1 x203; + uint32_t x204; + fiat_sm2_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_sm2_addcarryx_u32(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_sm2_uint1)((fiat_sm2_uint1)(x1 >> 31) & (fiat_sm2_uint1)((arg3[0]) & 0x1)); + fiat_sm2_addcarryx_u32(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_sm2_cmovznz_u32(&x6, x3, arg1, x4); + fiat_sm2_cmovznz_u32(&x7, x3, (arg2[0]), (arg3[0])); + fiat_sm2_cmovznz_u32(&x8, x3, (arg2[1]), (arg3[1])); + fiat_sm2_cmovznz_u32(&x9, x3, (arg2[2]), (arg3[2])); + fiat_sm2_cmovznz_u32(&x10, x3, (arg2[3]), (arg3[3])); + fiat_sm2_cmovznz_u32(&x11, x3, (arg2[4]), (arg3[4])); + fiat_sm2_cmovznz_u32(&x12, x3, (arg2[5]), (arg3[5])); + fiat_sm2_cmovznz_u32(&x13, x3, (arg2[6]), (arg3[6])); + fiat_sm2_cmovznz_u32(&x14, x3, (arg2[7]), (arg3[7])); + fiat_sm2_cmovznz_u32(&x15, x3, (arg2[8]), (arg3[8])); + fiat_sm2_addcarryx_u32(&x16, &x17, 0x0, 0x1, (~(arg2[0]))); + fiat_sm2_addcarryx_u32(&x18, &x19, x17, 0x0, (~(arg2[1]))); + fiat_sm2_addcarryx_u32(&x20, &x21, x19, 0x0, (~(arg2[2]))); + fiat_sm2_addcarryx_u32(&x22, &x23, x21, 0x0, (~(arg2[3]))); + fiat_sm2_addcarryx_u32(&x24, &x25, x23, 0x0, (~(arg2[4]))); + fiat_sm2_addcarryx_u32(&x26, &x27, x25, 0x0, (~(arg2[5]))); + fiat_sm2_addcarryx_u32(&x28, &x29, x27, 0x0, (~(arg2[6]))); + fiat_sm2_addcarryx_u32(&x30, &x31, x29, 0x0, (~(arg2[7]))); + fiat_sm2_addcarryx_u32(&x32, &x33, x31, 0x0, (~(arg2[8]))); + fiat_sm2_cmovznz_u32(&x34, x3, (arg3[0]), x16); + fiat_sm2_cmovznz_u32(&x35, x3, (arg3[1]), x18); + fiat_sm2_cmovznz_u32(&x36, x3, (arg3[2]), x20); + fiat_sm2_cmovznz_u32(&x37, x3, (arg3[3]), x22); + fiat_sm2_cmovznz_u32(&x38, x3, (arg3[4]), x24); + fiat_sm2_cmovznz_u32(&x39, x3, (arg3[5]), x26); + fiat_sm2_cmovznz_u32(&x40, x3, (arg3[6]), x28); + fiat_sm2_cmovznz_u32(&x41, x3, (arg3[7]), x30); + fiat_sm2_cmovznz_u32(&x42, x3, (arg3[8]), x32); + fiat_sm2_cmovznz_u32(&x43, x3, (arg4[0]), (arg5[0])); + fiat_sm2_cmovznz_u32(&x44, x3, (arg4[1]), (arg5[1])); + fiat_sm2_cmovznz_u32(&x45, x3, (arg4[2]), (arg5[2])); + fiat_sm2_cmovznz_u32(&x46, x3, (arg4[3]), (arg5[3])); + fiat_sm2_cmovznz_u32(&x47, x3, (arg4[4]), (arg5[4])); + fiat_sm2_cmovznz_u32(&x48, x3, (arg4[5]), (arg5[5])); + fiat_sm2_cmovznz_u32(&x49, x3, (arg4[6]), (arg5[6])); + fiat_sm2_cmovznz_u32(&x50, x3, (arg4[7]), (arg5[7])); + fiat_sm2_addcarryx_u32(&x51, &x52, 0x0, x43, x43); + fiat_sm2_addcarryx_u32(&x53, &x54, x52, x44, x44); + fiat_sm2_addcarryx_u32(&x55, &x56, x54, x45, x45); + fiat_sm2_addcarryx_u32(&x57, &x58, x56, x46, x46); + fiat_sm2_addcarryx_u32(&x59, &x60, x58, x47, x47); + fiat_sm2_addcarryx_u32(&x61, &x62, x60, x48, x48); + fiat_sm2_addcarryx_u32(&x63, &x64, x62, x49, x49); + fiat_sm2_addcarryx_u32(&x65, &x66, x64, x50, x50); + fiat_sm2_subborrowx_u32(&x67, &x68, 0x0, x51, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x69, &x70, x68, x53, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x71, &x72, x70, x55, 0x0); + fiat_sm2_subborrowx_u32(&x73, &x74, x72, x57, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x75, &x76, x74, x59, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x77, &x78, x76, x61, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x79, &x80, x78, x63, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x81, &x82, x80, x65, UINT32_C(0xfffffffe)); + fiat_sm2_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_sm2_subborrowx_u32(&x93, &x94, 0x0, 0x0, x92); + fiat_sm2_subborrowx_u32(&x95, &x96, x94, 0x0, x91); + fiat_sm2_subborrowx_u32(&x97, &x98, x96, 0x0, x90); + fiat_sm2_subborrowx_u32(&x99, &x100, x98, 0x0, x89); + fiat_sm2_subborrowx_u32(&x101, &x102, x100, 0x0, x88); + fiat_sm2_subborrowx_u32(&x103, &x104, x102, 0x0, x87); + fiat_sm2_subborrowx_u32(&x105, &x106, x104, 0x0, x86); + fiat_sm2_subborrowx_u32(&x107, &x108, x106, 0x0, x85); + fiat_sm2_cmovznz_u32(&x109, x108, 0x0, UINT32_C(0xffffffff)); + fiat_sm2_addcarryx_u32(&x110, &x111, 0x0, x93, x109); + fiat_sm2_addcarryx_u32(&x112, &x113, x111, x95, x109); + fiat_sm2_addcarryx_u32(&x114, &x115, x113, x97, 0x0); + fiat_sm2_addcarryx_u32(&x116, &x117, x115, x99, x109); + fiat_sm2_addcarryx_u32(&x118, &x119, x117, x101, x109); + fiat_sm2_addcarryx_u32(&x120, &x121, x119, x103, x109); + fiat_sm2_addcarryx_u32(&x122, &x123, x121, x105, x109); + fiat_sm2_addcarryx_u32(&x124, &x125, x123, x107, (x109 & UINT32_C(0xfffffffe))); + fiat_sm2_cmovznz_u32(&x126, x3, (arg5[0]), x110); + fiat_sm2_cmovznz_u32(&x127, x3, (arg5[1]), x112); + fiat_sm2_cmovznz_u32(&x128, x3, (arg5[2]), x114); + fiat_sm2_cmovznz_u32(&x129, x3, (arg5[3]), x116); + fiat_sm2_cmovznz_u32(&x130, x3, (arg5[4]), x118); + fiat_sm2_cmovznz_u32(&x131, x3, (arg5[5]), x120); + fiat_sm2_cmovznz_u32(&x132, x3, (arg5[6]), x122); + fiat_sm2_cmovznz_u32(&x133, x3, (arg5[7]), x124); + x134 = (fiat_sm2_uint1)(x34 & 0x1); + fiat_sm2_cmovznz_u32(&x135, x134, 0x0, x7); + fiat_sm2_cmovznz_u32(&x136, x134, 0x0, x8); + fiat_sm2_cmovznz_u32(&x137, x134, 0x0, x9); + fiat_sm2_cmovznz_u32(&x138, x134, 0x0, x10); + fiat_sm2_cmovznz_u32(&x139, x134, 0x0, x11); + fiat_sm2_cmovznz_u32(&x140, x134, 0x0, x12); + fiat_sm2_cmovznz_u32(&x141, x134, 0x0, x13); + fiat_sm2_cmovznz_u32(&x142, x134, 0x0, x14); + fiat_sm2_cmovznz_u32(&x143, x134, 0x0, x15); + fiat_sm2_addcarryx_u32(&x144, &x145, 0x0, x34, x135); + fiat_sm2_addcarryx_u32(&x146, &x147, x145, x35, x136); + fiat_sm2_addcarryx_u32(&x148, &x149, x147, x36, x137); + fiat_sm2_addcarryx_u32(&x150, &x151, x149, x37, x138); + fiat_sm2_addcarryx_u32(&x152, &x153, x151, x38, x139); + fiat_sm2_addcarryx_u32(&x154, &x155, x153, x39, x140); + fiat_sm2_addcarryx_u32(&x156, &x157, x155, x40, x141); + fiat_sm2_addcarryx_u32(&x158, &x159, x157, x41, x142); + fiat_sm2_addcarryx_u32(&x160, &x161, x159, x42, x143); + fiat_sm2_cmovznz_u32(&x162, x134, 0x0, x43); + fiat_sm2_cmovznz_u32(&x163, x134, 0x0, x44); + fiat_sm2_cmovznz_u32(&x164, x134, 0x0, x45); + fiat_sm2_cmovznz_u32(&x165, x134, 0x0, x46); + fiat_sm2_cmovznz_u32(&x166, x134, 0x0, x47); + fiat_sm2_cmovznz_u32(&x167, x134, 0x0, x48); + fiat_sm2_cmovznz_u32(&x168, x134, 0x0, x49); + fiat_sm2_cmovznz_u32(&x169, x134, 0x0, x50); + fiat_sm2_addcarryx_u32(&x170, &x171, 0x0, x126, x162); + fiat_sm2_addcarryx_u32(&x172, &x173, x171, x127, x163); + fiat_sm2_addcarryx_u32(&x174, &x175, x173, x128, x164); + fiat_sm2_addcarryx_u32(&x176, &x177, x175, x129, x165); + fiat_sm2_addcarryx_u32(&x178, &x179, x177, x130, x166); + fiat_sm2_addcarryx_u32(&x180, &x181, x179, x131, x167); + fiat_sm2_addcarryx_u32(&x182, &x183, x181, x132, x168); + fiat_sm2_addcarryx_u32(&x184, &x185, x183, x133, x169); + fiat_sm2_subborrowx_u32(&x186, &x187, 0x0, x170, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x188, &x189, x187, x172, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x190, &x191, x189, x174, 0x0); + fiat_sm2_subborrowx_u32(&x192, &x193, x191, x176, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x194, &x195, x193, x178, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x196, &x197, x195, x180, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x198, &x199, x197, x182, UINT32_C(0xffffffff)); + fiat_sm2_subborrowx_u32(&x200, &x201, x199, x184, UINT32_C(0xfffffffe)); + fiat_sm2_subborrowx_u32(&x202, &x203, x201, x185, 0x0); + fiat_sm2_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_sm2_cmovznz_u32(&x215, x84, x67, x51); + fiat_sm2_cmovznz_u32(&x216, x84, x69, x53); + fiat_sm2_cmovznz_u32(&x217, x84, x71, x55); + fiat_sm2_cmovznz_u32(&x218, x84, x73, x57); + fiat_sm2_cmovznz_u32(&x219, x84, x75, x59); + fiat_sm2_cmovznz_u32(&x220, x84, x77, x61); + fiat_sm2_cmovznz_u32(&x221, x84, x79, x63); + fiat_sm2_cmovznz_u32(&x222, x84, x81, x65); + fiat_sm2_cmovznz_u32(&x223, x203, x186, x170); + fiat_sm2_cmovznz_u32(&x224, x203, x188, x172); + fiat_sm2_cmovznz_u32(&x225, x203, x190, x174); + fiat_sm2_cmovznz_u32(&x226, x203, x192, x176); + fiat_sm2_cmovznz_u32(&x227, x203, x194, x178); + fiat_sm2_cmovznz_u32(&x228, x203, x196, x180); + fiat_sm2_cmovznz_u32(&x229, x203, x198, x182); + fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_divstep_precomp(uint32_t out1[8]) { + out1[0] = UINT32_C(0x8ffffffe); + out1[1] = UINT32_C(0x50000002); + out1[2] = UINT32_C(0x9ffffffe); + out1[3] = UINT32_C(0xe8000000); + out1[4] = UINT32_C(0x8ffffffe); + out1[5] = UINT32_C(0xd0000001); + out1[6] = UINT32_C(0x1ffffffd); + out1[7] = UINT32_C(0x28000001); +} diff --git a/fiat-c/src/sm2_64.c b/fiat-c/src/sm2_64.c new file mode 100644 index 00000000000..5fb05d5fae0 --- /dev/null +++ b/fiat-c/src/sm2_64.c @@ -0,0 +1,2167 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier sm2 64 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2 */ +/* 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") */ +/* */ +/* 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_sm2_uint1; +typedef signed char fiat_sm2_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_SM2_FIAT_EXTENSION __extension__ +# define FIAT_SM2_FIAT_INLINE __inline__ +#else +# define FIAT_SM2_FIAT_EXTENSION +# define FIAT_SM2_FIAT_INLINE +#endif + +FIAT_SM2_FIAT_EXTENSION typedef signed __int128 fiat_sm2_int128; +FIAT_SM2_FIAT_EXTENSION typedef unsigned __int128 fiat_sm2_uint128; + +/* The type fiat_sm2_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_sm2_montgomery_domain_field_element[4]; + +/* The type fiat_sm2_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_sm2_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_SM2_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint64_t fiat_sm2_value_barrier_u64(uint64_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_sm2_value_barrier_u64(x) (x) +#endif + + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_addcarryx_u64(uint64_t* out1, fiat_sm2_uint1* out2, fiat_sm2_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_sm2_uint128 x1; + uint64_t x2; + fiat_sm2_uint1 x3; + x1 = ((arg1 + (fiat_sm2_uint128)arg2) + arg3); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (fiat_sm2_uint1)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_subborrowx_u64(uint64_t* out1, fiat_sm2_uint1* out2, fiat_sm2_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_sm2_int128 x1; + fiat_sm2_int1 x2; + uint64_t x3; + x1 = ((arg2 - (fiat_sm2_int128)arg1) - arg3); + x2 = (fiat_sm2_int1)(x1 >> 64); + x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + *out1 = x3; + *out2 = (fiat_sm2_uint1)(0x0 - x2); +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { + fiat_sm2_uint128 x1; + uint64_t x2; + uint64_t x3; + x1 = ((fiat_sm2_uint128)arg1 * arg2); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (uint64_t)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_cmovznz_u64(uint64_t* out1, fiat_sm2_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_sm2_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_sm2_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_sm2_value_barrier_u64(x2) & arg3) | (fiat_sm2_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_mul(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1, const fiat_sm2_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_sm2_uint1 x14; + uint64_t x15; + fiat_sm2_uint1 x16; + uint64_t x17; + fiat_sm2_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_sm2_uint1 x29; + uint64_t x30; + fiat_sm2_uint1 x31; + uint64_t x32; + fiat_sm2_uint1 x33; + uint64_t x34; + uint64_t x35; + fiat_sm2_uint1 x36; + uint64_t x37; + fiat_sm2_uint1 x38; + uint64_t x39; + fiat_sm2_uint1 x40; + uint64_t x41; + fiat_sm2_uint1 x42; + uint64_t x43; + fiat_sm2_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_sm2_uint1 x54; + uint64_t x55; + fiat_sm2_uint1 x56; + uint64_t x57; + fiat_sm2_uint1 x58; + uint64_t x59; + uint64_t x60; + fiat_sm2_uint1 x61; + uint64_t x62; + fiat_sm2_uint1 x63; + uint64_t x64; + fiat_sm2_uint1 x65; + uint64_t x66; + fiat_sm2_uint1 x67; + uint64_t x68; + fiat_sm2_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; + fiat_sm2_uint1 x79; + uint64_t x80; + fiat_sm2_uint1 x81; + uint64_t x82; + fiat_sm2_uint1 x83; + uint64_t x84; + uint64_t x85; + fiat_sm2_uint1 x86; + uint64_t x87; + fiat_sm2_uint1 x88; + uint64_t x89; + fiat_sm2_uint1 x90; + uint64_t x91; + fiat_sm2_uint1 x92; + uint64_t x93; + fiat_sm2_uint1 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; + uint64_t x103; + uint64_t x104; + fiat_sm2_uint1 x105; + uint64_t x106; + fiat_sm2_uint1 x107; + uint64_t x108; + fiat_sm2_uint1 x109; + uint64_t x110; + uint64_t x111; + fiat_sm2_uint1 x112; + uint64_t x113; + fiat_sm2_uint1 x114; + uint64_t x115; + fiat_sm2_uint1 x116; + uint64_t x117; + fiat_sm2_uint1 x118; + uint64_t x119; + fiat_sm2_uint1 x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + fiat_sm2_uint1 x130; + uint64_t x131; + fiat_sm2_uint1 x132; + uint64_t x133; + fiat_sm2_uint1 x134; + uint64_t x135; + uint64_t x136; + fiat_sm2_uint1 x137; + uint64_t x138; + fiat_sm2_uint1 x139; + uint64_t x140; + fiat_sm2_uint1 x141; + uint64_t x142; + fiat_sm2_uint1 x143; + uint64_t x144; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x156; + uint64_t x157; + fiat_sm2_uint1 x158; + uint64_t x159; + fiat_sm2_uint1 x160; + uint64_t x161; + uint64_t x162; + fiat_sm2_uint1 x163; + uint64_t x164; + fiat_sm2_uint1 x165; + uint64_t x166; + fiat_sm2_uint1 x167; + uint64_t x168; + fiat_sm2_uint1 x169; + uint64_t x170; + fiat_sm2_uint1 x171; + uint64_t 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; + fiat_sm2_uint1 x181; + uint64_t x182; + fiat_sm2_uint1 x183; + uint64_t x184; + fiat_sm2_uint1 x185; + uint64_t x186; + uint64_t x187; + fiat_sm2_uint1 x188; + uint64_t x189; + fiat_sm2_uint1 x190; + uint64_t x191; + fiat_sm2_uint1 x192; + uint64_t x193; + fiat_sm2_uint1 x194; + uint64_t x195; + fiat_sm2_uint1 x196; + uint64_t x197; + uint64_t x198; + fiat_sm2_uint1 x199; + uint64_t x200; + fiat_sm2_uint1 x201; + uint64_t x202; + fiat_sm2_uint1 x203; + uint64_t x204; + fiat_sm2_uint1 x205; + uint64_t x206; + fiat_sm2_uint1 x207; + uint64_t x208; + uint64_t x209; + uint64_t x210; + uint64_t x211; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_sm2_mulx_u64(&x5, &x6, x4, (arg2[3])); + fiat_sm2_mulx_u64(&x7, &x8, x4, (arg2[2])); + fiat_sm2_mulx_u64(&x9, &x10, x4, (arg2[1])); + fiat_sm2_mulx_u64(&x11, &x12, x4, (arg2[0])); + fiat_sm2_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_sm2_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_sm2_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_sm2_mulx_u64(&x20, &x21, x11, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x22, &x23, x11, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x24, &x25, x11, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x26, &x27, x11, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x28, &x29, 0x0, x27, x24); + fiat_sm2_addcarryx_u64(&x30, &x31, x29, x25, x22); + fiat_sm2_addcarryx_u64(&x32, &x33, x31, x23, x20); + x34 = (x33 + x21); + fiat_sm2_addcarryx_u64(&x35, &x36, 0x0, x11, x26); + fiat_sm2_addcarryx_u64(&x37, &x38, x36, x13, x28); + fiat_sm2_addcarryx_u64(&x39, &x40, x38, x15, x30); + fiat_sm2_addcarryx_u64(&x41, &x42, x40, x17, x32); + fiat_sm2_addcarryx_u64(&x43, &x44, x42, x19, x34); + fiat_sm2_mulx_u64(&x45, &x46, x1, (arg2[3])); + fiat_sm2_mulx_u64(&x47, &x48, x1, (arg2[2])); + fiat_sm2_mulx_u64(&x49, &x50, x1, (arg2[1])); + fiat_sm2_mulx_u64(&x51, &x52, x1, (arg2[0])); + fiat_sm2_addcarryx_u64(&x53, &x54, 0x0, x52, x49); + fiat_sm2_addcarryx_u64(&x55, &x56, x54, x50, x47); + fiat_sm2_addcarryx_u64(&x57, &x58, x56, x48, x45); + x59 = (x58 + x46); + fiat_sm2_addcarryx_u64(&x60, &x61, 0x0, x37, x51); + fiat_sm2_addcarryx_u64(&x62, &x63, x61, x39, x53); + fiat_sm2_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_sm2_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_sm2_addcarryx_u64(&x68, &x69, x67, x44, x59); + fiat_sm2_mulx_u64(&x70, &x71, x60, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x72, &x73, x60, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x74, &x75, x60, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x76, &x77, x60, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x78, &x79, 0x0, x77, x74); + fiat_sm2_addcarryx_u64(&x80, &x81, x79, x75, x72); + fiat_sm2_addcarryx_u64(&x82, &x83, x81, x73, x70); + x84 = (x83 + x71); + fiat_sm2_addcarryx_u64(&x85, &x86, 0x0, x60, x76); + fiat_sm2_addcarryx_u64(&x87, &x88, x86, x62, x78); + fiat_sm2_addcarryx_u64(&x89, &x90, x88, x64, x80); + fiat_sm2_addcarryx_u64(&x91, &x92, x90, x66, x82); + fiat_sm2_addcarryx_u64(&x93, &x94, x92, x68, x84); + x95 = ((uint64_t)x94 + x69); + fiat_sm2_mulx_u64(&x96, &x97, x2, (arg2[3])); + fiat_sm2_mulx_u64(&x98, &x99, x2, (arg2[2])); + fiat_sm2_mulx_u64(&x100, &x101, x2, (arg2[1])); + fiat_sm2_mulx_u64(&x102, &x103, x2, (arg2[0])); + fiat_sm2_addcarryx_u64(&x104, &x105, 0x0, x103, x100); + fiat_sm2_addcarryx_u64(&x106, &x107, x105, x101, x98); + fiat_sm2_addcarryx_u64(&x108, &x109, x107, x99, x96); + x110 = (x109 + x97); + fiat_sm2_addcarryx_u64(&x111, &x112, 0x0, x87, x102); + fiat_sm2_addcarryx_u64(&x113, &x114, x112, x89, x104); + fiat_sm2_addcarryx_u64(&x115, &x116, x114, x91, x106); + fiat_sm2_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_sm2_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_sm2_mulx_u64(&x121, &x122, x111, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x123, &x124, x111, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x125, &x126, x111, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x127, &x128, x111, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x129, &x130, 0x0, x128, x125); + fiat_sm2_addcarryx_u64(&x131, &x132, x130, x126, x123); + fiat_sm2_addcarryx_u64(&x133, &x134, x132, x124, x121); + x135 = (x134 + x122); + fiat_sm2_addcarryx_u64(&x136, &x137, 0x0, x111, x127); + fiat_sm2_addcarryx_u64(&x138, &x139, x137, x113, x129); + fiat_sm2_addcarryx_u64(&x140, &x141, x139, x115, x131); + fiat_sm2_addcarryx_u64(&x142, &x143, x141, x117, x133); + fiat_sm2_addcarryx_u64(&x144, &x145, x143, x119, x135); + x146 = ((uint64_t)x145 + x120); + fiat_sm2_mulx_u64(&x147, &x148, x3, (arg2[3])); + fiat_sm2_mulx_u64(&x149, &x150, x3, (arg2[2])); + fiat_sm2_mulx_u64(&x151, &x152, x3, (arg2[1])); + fiat_sm2_mulx_u64(&x153, &x154, x3, (arg2[0])); + fiat_sm2_addcarryx_u64(&x155, &x156, 0x0, x154, x151); + fiat_sm2_addcarryx_u64(&x157, &x158, x156, x152, x149); + fiat_sm2_addcarryx_u64(&x159, &x160, x158, x150, x147); + x161 = (x160 + x148); + fiat_sm2_addcarryx_u64(&x162, &x163, 0x0, x138, x153); + fiat_sm2_addcarryx_u64(&x164, &x165, x163, x140, x155); + fiat_sm2_addcarryx_u64(&x166, &x167, x165, x142, x157); + fiat_sm2_addcarryx_u64(&x168, &x169, x167, x144, x159); + fiat_sm2_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_sm2_mulx_u64(&x172, &x173, x162, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x174, &x175, x162, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x176, &x177, x162, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x178, &x179, x162, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x180, &x181, 0x0, x179, x176); + fiat_sm2_addcarryx_u64(&x182, &x183, x181, x177, x174); + fiat_sm2_addcarryx_u64(&x184, &x185, x183, x175, x172); + x186 = (x185 + x173); + fiat_sm2_addcarryx_u64(&x187, &x188, 0x0, x162, x178); + fiat_sm2_addcarryx_u64(&x189, &x190, x188, x164, x180); + fiat_sm2_addcarryx_u64(&x191, &x192, x190, x166, x182); + fiat_sm2_addcarryx_u64(&x193, &x194, x192, x168, x184); + fiat_sm2_addcarryx_u64(&x195, &x196, x194, x170, x186); + x197 = ((uint64_t)x196 + x171); + fiat_sm2_subborrowx_u64(&x198, &x199, 0x0, x189, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x200, &x201, x199, x191, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x202, &x203, x201, x193, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x204, &x205, x203, x195, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x206, &x207, x205, x197, 0x0); + fiat_sm2_cmovznz_u64(&x208, x207, x198, x189); + fiat_sm2_cmovznz_u64(&x209, x207, x200, x191); + fiat_sm2_cmovznz_u64(&x210, x207, x202, x193); + fiat_sm2_cmovznz_u64(&x211, x207, x204, x195); + out1[0] = x208; + out1[1] = x209; + out1[2] = x210; + out1[3] = x211; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_square(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_uint1 x14; + uint64_t x15; + fiat_sm2_uint1 x16; + uint64_t x17; + fiat_sm2_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_sm2_uint1 x29; + uint64_t x30; + fiat_sm2_uint1 x31; + uint64_t x32; + fiat_sm2_uint1 x33; + uint64_t x34; + uint64_t x35; + fiat_sm2_uint1 x36; + uint64_t x37; + fiat_sm2_uint1 x38; + uint64_t x39; + fiat_sm2_uint1 x40; + uint64_t x41; + fiat_sm2_uint1 x42; + uint64_t x43; + fiat_sm2_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_sm2_uint1 x54; + uint64_t x55; + fiat_sm2_uint1 x56; + uint64_t x57; + fiat_sm2_uint1 x58; + uint64_t x59; + uint64_t x60; + fiat_sm2_uint1 x61; + uint64_t x62; + fiat_sm2_uint1 x63; + uint64_t x64; + fiat_sm2_uint1 x65; + uint64_t x66; + fiat_sm2_uint1 x67; + uint64_t x68; + fiat_sm2_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; + fiat_sm2_uint1 x79; + uint64_t x80; + fiat_sm2_uint1 x81; + uint64_t x82; + fiat_sm2_uint1 x83; + uint64_t x84; + uint64_t x85; + fiat_sm2_uint1 x86; + uint64_t x87; + fiat_sm2_uint1 x88; + uint64_t x89; + fiat_sm2_uint1 x90; + uint64_t x91; + fiat_sm2_uint1 x92; + uint64_t x93; + fiat_sm2_uint1 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; + uint64_t x103; + uint64_t x104; + fiat_sm2_uint1 x105; + uint64_t x106; + fiat_sm2_uint1 x107; + uint64_t x108; + fiat_sm2_uint1 x109; + uint64_t x110; + uint64_t x111; + fiat_sm2_uint1 x112; + uint64_t x113; + fiat_sm2_uint1 x114; + uint64_t x115; + fiat_sm2_uint1 x116; + uint64_t x117; + fiat_sm2_uint1 x118; + uint64_t x119; + fiat_sm2_uint1 x120; + uint64_t x121; + uint64_t x122; + uint64_t x123; + uint64_t x124; + uint64_t x125; + uint64_t x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + fiat_sm2_uint1 x130; + uint64_t x131; + fiat_sm2_uint1 x132; + uint64_t x133; + fiat_sm2_uint1 x134; + uint64_t x135; + uint64_t x136; + fiat_sm2_uint1 x137; + uint64_t x138; + fiat_sm2_uint1 x139; + uint64_t x140; + fiat_sm2_uint1 x141; + uint64_t x142; + fiat_sm2_uint1 x143; + uint64_t x144; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x156; + uint64_t x157; + fiat_sm2_uint1 x158; + uint64_t x159; + fiat_sm2_uint1 x160; + uint64_t x161; + uint64_t x162; + fiat_sm2_uint1 x163; + uint64_t x164; + fiat_sm2_uint1 x165; + uint64_t x166; + fiat_sm2_uint1 x167; + uint64_t x168; + fiat_sm2_uint1 x169; + uint64_t x170; + fiat_sm2_uint1 x171; + uint64_t 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; + fiat_sm2_uint1 x181; + uint64_t x182; + fiat_sm2_uint1 x183; + uint64_t x184; + fiat_sm2_uint1 x185; + uint64_t x186; + uint64_t x187; + fiat_sm2_uint1 x188; + uint64_t x189; + fiat_sm2_uint1 x190; + uint64_t x191; + fiat_sm2_uint1 x192; + uint64_t x193; + fiat_sm2_uint1 x194; + uint64_t x195; + fiat_sm2_uint1 x196; + uint64_t x197; + uint64_t x198; + fiat_sm2_uint1 x199; + uint64_t x200; + fiat_sm2_uint1 x201; + uint64_t x202; + fiat_sm2_uint1 x203; + uint64_t x204; + fiat_sm2_uint1 x205; + uint64_t x206; + fiat_sm2_uint1 x207; + uint64_t x208; + uint64_t x209; + uint64_t x210; + uint64_t x211; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_sm2_mulx_u64(&x5, &x6, x4, (arg1[3])); + fiat_sm2_mulx_u64(&x7, &x8, x4, (arg1[2])); + fiat_sm2_mulx_u64(&x9, &x10, x4, (arg1[1])); + fiat_sm2_mulx_u64(&x11, &x12, x4, (arg1[0])); + fiat_sm2_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_sm2_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_sm2_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_sm2_mulx_u64(&x20, &x21, x11, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x22, &x23, x11, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x24, &x25, x11, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x26, &x27, x11, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x28, &x29, 0x0, x27, x24); + fiat_sm2_addcarryx_u64(&x30, &x31, x29, x25, x22); + fiat_sm2_addcarryx_u64(&x32, &x33, x31, x23, x20); + x34 = (x33 + x21); + fiat_sm2_addcarryx_u64(&x35, &x36, 0x0, x11, x26); + fiat_sm2_addcarryx_u64(&x37, &x38, x36, x13, x28); + fiat_sm2_addcarryx_u64(&x39, &x40, x38, x15, x30); + fiat_sm2_addcarryx_u64(&x41, &x42, x40, x17, x32); + fiat_sm2_addcarryx_u64(&x43, &x44, x42, x19, x34); + fiat_sm2_mulx_u64(&x45, &x46, x1, (arg1[3])); + fiat_sm2_mulx_u64(&x47, &x48, x1, (arg1[2])); + fiat_sm2_mulx_u64(&x49, &x50, x1, (arg1[1])); + fiat_sm2_mulx_u64(&x51, &x52, x1, (arg1[0])); + fiat_sm2_addcarryx_u64(&x53, &x54, 0x0, x52, x49); + fiat_sm2_addcarryx_u64(&x55, &x56, x54, x50, x47); + fiat_sm2_addcarryx_u64(&x57, &x58, x56, x48, x45); + x59 = (x58 + x46); + fiat_sm2_addcarryx_u64(&x60, &x61, 0x0, x37, x51); + fiat_sm2_addcarryx_u64(&x62, &x63, x61, x39, x53); + fiat_sm2_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_sm2_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_sm2_addcarryx_u64(&x68, &x69, x67, x44, x59); + fiat_sm2_mulx_u64(&x70, &x71, x60, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x72, &x73, x60, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x74, &x75, x60, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x76, &x77, x60, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x78, &x79, 0x0, x77, x74); + fiat_sm2_addcarryx_u64(&x80, &x81, x79, x75, x72); + fiat_sm2_addcarryx_u64(&x82, &x83, x81, x73, x70); + x84 = (x83 + x71); + fiat_sm2_addcarryx_u64(&x85, &x86, 0x0, x60, x76); + fiat_sm2_addcarryx_u64(&x87, &x88, x86, x62, x78); + fiat_sm2_addcarryx_u64(&x89, &x90, x88, x64, x80); + fiat_sm2_addcarryx_u64(&x91, &x92, x90, x66, x82); + fiat_sm2_addcarryx_u64(&x93, &x94, x92, x68, x84); + x95 = ((uint64_t)x94 + x69); + fiat_sm2_mulx_u64(&x96, &x97, x2, (arg1[3])); + fiat_sm2_mulx_u64(&x98, &x99, x2, (arg1[2])); + fiat_sm2_mulx_u64(&x100, &x101, x2, (arg1[1])); + fiat_sm2_mulx_u64(&x102, &x103, x2, (arg1[0])); + fiat_sm2_addcarryx_u64(&x104, &x105, 0x0, x103, x100); + fiat_sm2_addcarryx_u64(&x106, &x107, x105, x101, x98); + fiat_sm2_addcarryx_u64(&x108, &x109, x107, x99, x96); + x110 = (x109 + x97); + fiat_sm2_addcarryx_u64(&x111, &x112, 0x0, x87, x102); + fiat_sm2_addcarryx_u64(&x113, &x114, x112, x89, x104); + fiat_sm2_addcarryx_u64(&x115, &x116, x114, x91, x106); + fiat_sm2_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_sm2_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_sm2_mulx_u64(&x121, &x122, x111, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x123, &x124, x111, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x125, &x126, x111, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x127, &x128, x111, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x129, &x130, 0x0, x128, x125); + fiat_sm2_addcarryx_u64(&x131, &x132, x130, x126, x123); + fiat_sm2_addcarryx_u64(&x133, &x134, x132, x124, x121); + x135 = (x134 + x122); + fiat_sm2_addcarryx_u64(&x136, &x137, 0x0, x111, x127); + fiat_sm2_addcarryx_u64(&x138, &x139, x137, x113, x129); + fiat_sm2_addcarryx_u64(&x140, &x141, x139, x115, x131); + fiat_sm2_addcarryx_u64(&x142, &x143, x141, x117, x133); + fiat_sm2_addcarryx_u64(&x144, &x145, x143, x119, x135); + x146 = ((uint64_t)x145 + x120); + fiat_sm2_mulx_u64(&x147, &x148, x3, (arg1[3])); + fiat_sm2_mulx_u64(&x149, &x150, x3, (arg1[2])); + fiat_sm2_mulx_u64(&x151, &x152, x3, (arg1[1])); + fiat_sm2_mulx_u64(&x153, &x154, x3, (arg1[0])); + fiat_sm2_addcarryx_u64(&x155, &x156, 0x0, x154, x151); + fiat_sm2_addcarryx_u64(&x157, &x158, x156, x152, x149); + fiat_sm2_addcarryx_u64(&x159, &x160, x158, x150, x147); + x161 = (x160 + x148); + fiat_sm2_addcarryx_u64(&x162, &x163, 0x0, x138, x153); + fiat_sm2_addcarryx_u64(&x164, &x165, x163, x140, x155); + fiat_sm2_addcarryx_u64(&x166, &x167, x165, x142, x157); + fiat_sm2_addcarryx_u64(&x168, &x169, x167, x144, x159); + fiat_sm2_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_sm2_mulx_u64(&x172, &x173, x162, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x174, &x175, x162, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x176, &x177, x162, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x178, &x179, x162, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x180, &x181, 0x0, x179, x176); + fiat_sm2_addcarryx_u64(&x182, &x183, x181, x177, x174); + fiat_sm2_addcarryx_u64(&x184, &x185, x183, x175, x172); + x186 = (x185 + x173); + fiat_sm2_addcarryx_u64(&x187, &x188, 0x0, x162, x178); + fiat_sm2_addcarryx_u64(&x189, &x190, x188, x164, x180); + fiat_sm2_addcarryx_u64(&x191, &x192, x190, x166, x182); + fiat_sm2_addcarryx_u64(&x193, &x194, x192, x168, x184); + fiat_sm2_addcarryx_u64(&x195, &x196, x194, x170, x186); + x197 = ((uint64_t)x196 + x171); + fiat_sm2_subborrowx_u64(&x198, &x199, 0x0, x189, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x200, &x201, x199, x191, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x202, &x203, x201, x193, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x204, &x205, x203, x195, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x206, &x207, x205, x197, 0x0); + fiat_sm2_cmovznz_u64(&x208, x207, x198, x189); + fiat_sm2_cmovznz_u64(&x209, x207, x200, x191); + fiat_sm2_cmovznz_u64(&x210, x207, x202, x193); + fiat_sm2_cmovznz_u64(&x211, x207, x204, x195); + out1[0] = x208; + out1[1] = x209; + out1[2] = x210; + out1[3] = x211; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_add(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1, const fiat_sm2_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_sm2_uint1 x2; + uint64_t x3; + fiat_sm2_uint1 x4; + uint64_t x5; + fiat_sm2_uint1 x6; + uint64_t x7; + fiat_sm2_uint1 x8; + uint64_t x9; + fiat_sm2_uint1 x10; + uint64_t x11; + fiat_sm2_uint1 x12; + uint64_t x13; + fiat_sm2_uint1 x14; + uint64_t x15; + fiat_sm2_uint1 x16; + uint64_t x17; + fiat_sm2_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_sm2_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x11, &x12, x10, x3, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x13, &x14, x12, x5, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x17, &x18, x16, x8, 0x0); + fiat_sm2_cmovznz_u64(&x19, x18, x9, x1); + fiat_sm2_cmovznz_u64(&x20, x18, x11, x3); + fiat_sm2_cmovznz_u64(&x21, x18, x13, x5); + fiat_sm2_cmovznz_u64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_sub(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1, const fiat_sm2_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_sm2_uint1 x2; + uint64_t x3; + fiat_sm2_uint1 x4; + uint64_t x5; + fiat_sm2_uint1 x6; + uint64_t x7; + fiat_sm2_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_sm2_uint1 x11; + uint64_t x12; + fiat_sm2_uint1 x13; + uint64_t x14; + fiat_sm2_uint1 x15; + uint64_t x16; + fiat_sm2_uint1 x17; + fiat_sm2_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x10, &x11, 0x0, x1, x9); + fiat_sm2_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0xffffffff00000000))); + fiat_sm2_addcarryx_u64(&x14, &x15, x13, x5, x9); + fiat_sm2_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xfffffffeffffffff))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_opp(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_sm2_uint1 x2; + uint64_t x3; + fiat_sm2_uint1 x4; + uint64_t x5; + fiat_sm2_uint1 x6; + uint64_t x7; + fiat_sm2_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_sm2_uint1 x11; + uint64_t x12; + fiat_sm2_uint1 x13; + uint64_t x14; + fiat_sm2_uint1 x15; + uint64_t x16; + fiat_sm2_uint1 x17; + fiat_sm2_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_sm2_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_sm2_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_sm2_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_sm2_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x10, &x11, 0x0, x1, x9); + fiat_sm2_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0xffffffff00000000))); + fiat_sm2_addcarryx_u64(&x14, &x15, x13, x5, x9); + fiat_sm2_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xfffffffeffffffff))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_from_montgomery(fiat_sm2_non_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_uint1 x11; + uint64_t x12; + fiat_sm2_uint1 x13; + uint64_t x14; + fiat_sm2_uint1 x15; + uint64_t x16; + fiat_sm2_uint1 x17; + uint64_t x18; + fiat_sm2_uint1 x19; + uint64_t x20; + fiat_sm2_uint1 x21; + uint64_t x22; + fiat_sm2_uint1 x23; + uint64_t x24; + fiat_sm2_uint1 x25; + uint64_t x26; + fiat_sm2_uint1 x27; + uint64_t x28; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x39; + uint64_t x40; + fiat_sm2_uint1 x41; + uint64_t x42; + fiat_sm2_uint1 x43; + uint64_t x44; + fiat_sm2_uint1 x45; + uint64_t x46; + fiat_sm2_uint1 x47; + uint64_t x48; + fiat_sm2_uint1 x49; + uint64_t x50; + fiat_sm2_uint1 x51; + uint64_t x52; + fiat_sm2_uint1 x53; + uint64_t x54; + fiat_sm2_uint1 x55; + uint64_t x56; + fiat_sm2_uint1 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_sm2_uint1 x67; + uint64_t x68; + fiat_sm2_uint1 x69; + uint64_t x70; + fiat_sm2_uint1 x71; + uint64_t x72; + fiat_sm2_uint1 x73; + uint64_t x74; + fiat_sm2_uint1 x75; + uint64_t x76; + fiat_sm2_uint1 x77; + uint64_t x78; + fiat_sm2_uint1 x79; + uint64_t x80; + fiat_sm2_uint1 x81; + uint64_t x82; + fiat_sm2_uint1 x83; + uint64_t x84; + fiat_sm2_uint1 x85; + uint64_t 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; + fiat_sm2_uint1 x95; + uint64_t x96; + fiat_sm2_uint1 x97; + uint64_t x98; + fiat_sm2_uint1 x99; + uint64_t x100; + fiat_sm2_uint1 x101; + uint64_t x102; + fiat_sm2_uint1 x103; + uint64_t x104; + fiat_sm2_uint1 x105; + uint64_t x106; + fiat_sm2_uint1 x107; + uint64_t x108; + uint64_t x109; + fiat_sm2_uint1 x110; + uint64_t x111; + fiat_sm2_uint1 x112; + uint64_t x113; + fiat_sm2_uint1 x114; + uint64_t x115; + fiat_sm2_uint1 x116; + uint64_t x117; + fiat_sm2_uint1 x118; + uint64_t x119; + uint64_t x120; + uint64_t x121; + uint64_t x122; + x1 = (arg1[0]); + fiat_sm2_mulx_u64(&x2, &x3, x1, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x4, &x5, x1, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x6, &x7, x1, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x8, &x9, x1, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x10, &x11, 0x0, x9, x6); + fiat_sm2_addcarryx_u64(&x12, &x13, x11, x7, x4); + fiat_sm2_addcarryx_u64(&x14, &x15, x13, x5, x2); + fiat_sm2_addcarryx_u64(&x16, &x17, 0x0, x1, x8); + fiat_sm2_addcarryx_u64(&x18, &x19, x17, 0x0, x10); + fiat_sm2_addcarryx_u64(&x20, &x21, x19, 0x0, x12); + fiat_sm2_addcarryx_u64(&x22, &x23, x21, 0x0, x14); + fiat_sm2_addcarryx_u64(&x24, &x25, 0x0, x18, (arg1[1])); + fiat_sm2_addcarryx_u64(&x26, &x27, x25, x20, 0x0); + fiat_sm2_addcarryx_u64(&x28, &x29, x27, x22, 0x0); + fiat_sm2_mulx_u64(&x30, &x31, x24, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x32, &x33, x24, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x34, &x35, x24, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x36, &x37, x24, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x38, &x39, 0x0, x37, x34); + fiat_sm2_addcarryx_u64(&x40, &x41, x39, x35, x32); + fiat_sm2_addcarryx_u64(&x42, &x43, x41, x33, x30); + fiat_sm2_addcarryx_u64(&x44, &x45, 0x0, x24, x36); + fiat_sm2_addcarryx_u64(&x46, &x47, x45, x26, x38); + fiat_sm2_addcarryx_u64(&x48, &x49, x47, x28, x40); + fiat_sm2_addcarryx_u64(&x50, &x51, x49, (x29 + (x23 + (x15 + x3))), x42); + fiat_sm2_addcarryx_u64(&x52, &x53, 0x0, x46, (arg1[2])); + fiat_sm2_addcarryx_u64(&x54, &x55, x53, x48, 0x0); + fiat_sm2_addcarryx_u64(&x56, &x57, x55, x50, 0x0); + fiat_sm2_mulx_u64(&x58, &x59, x52, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x60, &x61, x52, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x62, &x63, x52, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x64, &x65, x52, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x66, &x67, 0x0, x65, x62); + fiat_sm2_addcarryx_u64(&x68, &x69, x67, x63, x60); + fiat_sm2_addcarryx_u64(&x70, &x71, x69, x61, x58); + fiat_sm2_addcarryx_u64(&x72, &x73, 0x0, x52, x64); + fiat_sm2_addcarryx_u64(&x74, &x75, x73, x54, x66); + fiat_sm2_addcarryx_u64(&x76, &x77, x75, x56, x68); + fiat_sm2_addcarryx_u64(&x78, &x79, x77, (x57 + (x51 + (x43 + x31))), x70); + fiat_sm2_addcarryx_u64(&x80, &x81, 0x0, x74, (arg1[3])); + fiat_sm2_addcarryx_u64(&x82, &x83, x81, x76, 0x0); + fiat_sm2_addcarryx_u64(&x84, &x85, x83, x78, 0x0); + fiat_sm2_mulx_u64(&x86, &x87, x80, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x88, &x89, x80, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x90, &x91, x80, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x92, &x93, x80, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x94, &x95, 0x0, x93, x90); + fiat_sm2_addcarryx_u64(&x96, &x97, x95, x91, x88); + fiat_sm2_addcarryx_u64(&x98, &x99, x97, x89, x86); + fiat_sm2_addcarryx_u64(&x100, &x101, 0x0, x80, x92); + fiat_sm2_addcarryx_u64(&x102, &x103, x101, x82, x94); + fiat_sm2_addcarryx_u64(&x104, &x105, x103, x84, x96); + fiat_sm2_addcarryx_u64(&x106, &x107, x105, (x85 + (x79 + (x71 + x59))), x98); + x108 = (x107 + (x99 + x87)); + fiat_sm2_subborrowx_u64(&x109, &x110, 0x0, x102, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x111, &x112, x110, x104, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x113, &x114, x112, x106, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x115, &x116, x114, x108, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x117, &x118, x116, 0x0, 0x0); + fiat_sm2_cmovznz_u64(&x119, x118, x109, x102); + fiat_sm2_cmovznz_u64(&x120, x118, x111, x104); + fiat_sm2_cmovznz_u64(&x121, x118, x113, x106); + fiat_sm2_cmovznz_u64(&x122, x118, x115, x108); + out1[0] = x119; + out1[1] = x120; + out1[2] = x121; + out1[3] = x122; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_to_montgomery(fiat_sm2_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_uint1 x14; + uint64_t x15; + fiat_sm2_uint1 x16; + uint64_t x17; + fiat_sm2_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_sm2_uint1 x28; + uint64_t x29; + fiat_sm2_uint1 x30; + uint64_t x31; + fiat_sm2_uint1 x32; + uint64_t x33; + fiat_sm2_uint1 x34; + uint64_t x35; + fiat_sm2_uint1 x36; + uint64_t x37; + fiat_sm2_uint1 x38; + uint64_t x39; + fiat_sm2_uint1 x40; + uint64_t x41; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x52; + uint64_t x53; + fiat_sm2_uint1 x54; + uint64_t x55; + fiat_sm2_uint1 x56; + uint64_t x57; + fiat_sm2_uint1 x58; + uint64_t x59; + fiat_sm2_uint1 x60; + uint64_t x61; + fiat_sm2_uint1 x62; + uint64_t x63; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x74; + uint64_t x75; + fiat_sm2_uint1 x76; + uint64_t x77; + fiat_sm2_uint1 x78; + uint64_t x79; + fiat_sm2_uint1 x80; + uint64_t x81; + fiat_sm2_uint1 x82; + uint64_t x83; + fiat_sm2_uint1 x84; + uint64_t x85; + fiat_sm2_uint1 x86; + uint64_t x87; + fiat_sm2_uint1 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; + uint64_t x97; + fiat_sm2_uint1 x98; + uint64_t x99; + fiat_sm2_uint1 x100; + uint64_t x101; + fiat_sm2_uint1 x102; + uint64_t x103; + fiat_sm2_uint1 x104; + uint64_t x105; + fiat_sm2_uint1 x106; + uint64_t x107; + fiat_sm2_uint1 x108; + uint64_t x109; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x120; + uint64_t x121; + fiat_sm2_uint1 x122; + uint64_t x123; + fiat_sm2_uint1 x124; + uint64_t x125; + fiat_sm2_uint1 x126; + uint64_t x127; + fiat_sm2_uint1 x128; + uint64_t x129; + fiat_sm2_uint1 x130; + uint64_t x131; + fiat_sm2_uint1 x132; + uint64_t x133; + fiat_sm2_uint1 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_sm2_uint1 x144; + uint64_t x145; + fiat_sm2_uint1 x146; + uint64_t x147; + fiat_sm2_uint1 x148; + uint64_t x149; + fiat_sm2_uint1 x150; + uint64_t x151; + fiat_sm2_uint1 x152; + uint64_t x153; + fiat_sm2_uint1 x154; + uint64_t x155; + fiat_sm2_uint1 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; + fiat_sm2_uint1 x166; + uint64_t x167; + fiat_sm2_uint1 x168; + uint64_t x169; + fiat_sm2_uint1 x170; + uint64_t x171; + fiat_sm2_uint1 x172; + uint64_t x173; + fiat_sm2_uint1 x174; + uint64_t x175; + fiat_sm2_uint1 x176; + uint64_t x177; + fiat_sm2_uint1 x178; + uint64_t x179; + fiat_sm2_uint1 x180; + uint64_t x181; + fiat_sm2_uint1 x182; + uint64_t x183; + fiat_sm2_uint1 x184; + uint64_t x185; + fiat_sm2_uint1 x186; + uint64_t x187; + fiat_sm2_uint1 x188; + uint64_t x189; + fiat_sm2_uint1 x190; + uint64_t x191; + uint64_t x192; + uint64_t x193; + uint64_t x194; + x1 = (arg1[1]); + x2 = (arg1[2]); + x3 = (arg1[3]); + x4 = (arg1[0]); + fiat_sm2_mulx_u64(&x5, &x6, x4, UINT64_C(0x400000002)); + fiat_sm2_mulx_u64(&x7, &x8, x4, UINT64_C(0x100000001)); + fiat_sm2_mulx_u64(&x9, &x10, x4, UINT64_C(0x2ffffffff)); + fiat_sm2_mulx_u64(&x11, &x12, x4, UINT64_C(0x200000003)); + fiat_sm2_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_sm2_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_sm2_addcarryx_u64(&x17, &x18, x16, x8, x5); + fiat_sm2_mulx_u64(&x19, &x20, x11, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x21, &x22, x11, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x23, &x24, x11, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x25, &x26, x11, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x27, &x28, 0x0, x26, x23); + fiat_sm2_addcarryx_u64(&x29, &x30, x28, x24, x21); + fiat_sm2_addcarryx_u64(&x31, &x32, x30, x22, x19); + fiat_sm2_addcarryx_u64(&x33, &x34, 0x0, x11, x25); + fiat_sm2_addcarryx_u64(&x35, &x36, x34, x13, x27); + fiat_sm2_addcarryx_u64(&x37, &x38, x36, x15, x29); + fiat_sm2_addcarryx_u64(&x39, &x40, x38, x17, x31); + fiat_sm2_addcarryx_u64(&x41, &x42, x40, (x18 + x6), (x32 + x20)); + fiat_sm2_mulx_u64(&x43, &x44, x1, UINT64_C(0x400000002)); + fiat_sm2_mulx_u64(&x45, &x46, x1, UINT64_C(0x100000001)); + fiat_sm2_mulx_u64(&x47, &x48, x1, UINT64_C(0x2ffffffff)); + fiat_sm2_mulx_u64(&x49, &x50, x1, UINT64_C(0x200000003)); + fiat_sm2_addcarryx_u64(&x51, &x52, 0x0, x50, x47); + fiat_sm2_addcarryx_u64(&x53, &x54, x52, x48, x45); + fiat_sm2_addcarryx_u64(&x55, &x56, x54, x46, x43); + fiat_sm2_addcarryx_u64(&x57, &x58, 0x0, x35, x49); + fiat_sm2_addcarryx_u64(&x59, &x60, x58, x37, x51); + fiat_sm2_addcarryx_u64(&x61, &x62, x60, x39, x53); + fiat_sm2_addcarryx_u64(&x63, &x64, x62, x41, x55); + fiat_sm2_mulx_u64(&x65, &x66, x57, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x67, &x68, x57, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x69, &x70, x57, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x71, &x72, x57, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x73, &x74, 0x0, x72, x69); + fiat_sm2_addcarryx_u64(&x75, &x76, x74, x70, x67); + fiat_sm2_addcarryx_u64(&x77, &x78, x76, x68, x65); + fiat_sm2_addcarryx_u64(&x79, &x80, 0x0, x57, x71); + fiat_sm2_addcarryx_u64(&x81, &x82, x80, x59, x73); + fiat_sm2_addcarryx_u64(&x83, &x84, x82, x61, x75); + fiat_sm2_addcarryx_u64(&x85, &x86, x84, x63, x77); + fiat_sm2_addcarryx_u64(&x87, &x88, x86, (((uint64_t)x64 + x42) + (x56 + x44)), (x78 + x66)); + fiat_sm2_mulx_u64(&x89, &x90, x2, UINT64_C(0x400000002)); + fiat_sm2_mulx_u64(&x91, &x92, x2, UINT64_C(0x100000001)); + fiat_sm2_mulx_u64(&x93, &x94, x2, UINT64_C(0x2ffffffff)); + fiat_sm2_mulx_u64(&x95, &x96, x2, UINT64_C(0x200000003)); + fiat_sm2_addcarryx_u64(&x97, &x98, 0x0, x96, x93); + fiat_sm2_addcarryx_u64(&x99, &x100, x98, x94, x91); + fiat_sm2_addcarryx_u64(&x101, &x102, x100, x92, x89); + fiat_sm2_addcarryx_u64(&x103, &x104, 0x0, x81, x95); + fiat_sm2_addcarryx_u64(&x105, &x106, x104, x83, x97); + fiat_sm2_addcarryx_u64(&x107, &x108, x106, x85, x99); + fiat_sm2_addcarryx_u64(&x109, &x110, x108, x87, x101); + fiat_sm2_mulx_u64(&x111, &x112, x103, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x113, &x114, x103, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x115, &x116, x103, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x117, &x118, x103, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x119, &x120, 0x0, x118, x115); + fiat_sm2_addcarryx_u64(&x121, &x122, x120, x116, x113); + fiat_sm2_addcarryx_u64(&x123, &x124, x122, x114, x111); + fiat_sm2_addcarryx_u64(&x125, &x126, 0x0, x103, x117); + fiat_sm2_addcarryx_u64(&x127, &x128, x126, x105, x119); + fiat_sm2_addcarryx_u64(&x129, &x130, x128, x107, x121); + fiat_sm2_addcarryx_u64(&x131, &x132, x130, x109, x123); + fiat_sm2_addcarryx_u64(&x133, &x134, x132, (((uint64_t)x110 + x88) + (x102 + x90)), (x124 + x112)); + fiat_sm2_mulx_u64(&x135, &x136, x3, UINT64_C(0x400000002)); + fiat_sm2_mulx_u64(&x137, &x138, x3, UINT64_C(0x100000001)); + fiat_sm2_mulx_u64(&x139, &x140, x3, UINT64_C(0x2ffffffff)); + fiat_sm2_mulx_u64(&x141, &x142, x3, UINT64_C(0x200000003)); + fiat_sm2_addcarryx_u64(&x143, &x144, 0x0, x142, x139); + fiat_sm2_addcarryx_u64(&x145, &x146, x144, x140, x137); + fiat_sm2_addcarryx_u64(&x147, &x148, x146, x138, x135); + fiat_sm2_addcarryx_u64(&x149, &x150, 0x0, x127, x141); + fiat_sm2_addcarryx_u64(&x151, &x152, x150, x129, x143); + fiat_sm2_addcarryx_u64(&x153, &x154, x152, x131, x145); + fiat_sm2_addcarryx_u64(&x155, &x156, x154, x133, x147); + fiat_sm2_mulx_u64(&x157, &x158, x149, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_mulx_u64(&x159, &x160, x149, UINT64_C(0xffffffffffffffff)); + fiat_sm2_mulx_u64(&x161, &x162, x149, UINT64_C(0xffffffff00000000)); + fiat_sm2_mulx_u64(&x163, &x164, x149, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x165, &x166, 0x0, x164, x161); + fiat_sm2_addcarryx_u64(&x167, &x168, x166, x162, x159); + fiat_sm2_addcarryx_u64(&x169, &x170, x168, x160, x157); + fiat_sm2_addcarryx_u64(&x171, &x172, 0x0, x149, x163); + fiat_sm2_addcarryx_u64(&x173, &x174, x172, x151, x165); + fiat_sm2_addcarryx_u64(&x175, &x176, x174, x153, x167); + fiat_sm2_addcarryx_u64(&x177, &x178, x176, x155, x169); + fiat_sm2_addcarryx_u64(&x179, &x180, x178, (((uint64_t)x156 + x134) + (x148 + x136)), (x170 + x158)); + fiat_sm2_subborrowx_u64(&x181, &x182, 0x0, x173, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x183, &x184, x182, x175, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x185, &x186, x184, x177, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x187, &x188, x186, x179, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x189, &x190, x188, x180, 0x0); + fiat_sm2_cmovznz_u64(&x191, x190, x181, x173); + fiat_sm2_cmovznz_u64(&x192, x190, x183, x175); + fiat_sm2_cmovznz_u64(&x193, x190, x185, x177); + fiat_sm2_cmovznz_u64(&x194, x190, x187, x179); + out1[0] = x191; + out1[1] = x192; + out1[2] = x193; + out1[3] = x194; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_selectznz(uint64_t out1[4], fiat_sm2_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_sm2_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_sm2_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_sm2_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_sm2_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_set_one(fiat_sm2_montgomery_domain_field_element out1) { + out1[0] = 0x1; + out1[1] = UINT32_C(0xffffffff); + out1[2] = 0x0; + out1[3] = UINT64_C(0x100000000); +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_msat(uint64_t out1[5]) { + out1[0] = UINT64_C(0xffffffffffffffff); + out1[1] = UINT64_C(0xffffffff00000000); + out1[2] = UINT64_C(0xffffffffffffffff); + out1[3] = UINT64_C(0xfffffffeffffffff); + out1[4] = 0x0; +} + +/* + * The function fiat_sm2_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_SM2_FIAT_INLINE void fiat_sm2_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_sm2_uint1 x2; + fiat_sm2_uint1 x3; + uint64_t x4; + fiat_sm2_uint1 x5; + uint64_t x6; + uint64_t x7; + uint64_t x8; + uint64_t x9; + uint64_t x10; + uint64_t x11; + uint64_t x12; + fiat_sm2_uint1 x13; + uint64_t x14; + fiat_sm2_uint1 x15; + uint64_t x16; + fiat_sm2_uint1 x17; + uint64_t x18; + fiat_sm2_uint1 x19; + uint64_t x20; + fiat_sm2_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_sm2_uint1 x32; + uint64_t x33; + fiat_sm2_uint1 x34; + uint64_t x35; + fiat_sm2_uint1 x36; + uint64_t x37; + fiat_sm2_uint1 x38; + uint64_t x39; + fiat_sm2_uint1 x40; + uint64_t x41; + fiat_sm2_uint1 x42; + uint64_t x43; + fiat_sm2_uint1 x44; + uint64_t x45; + fiat_sm2_uint1 x46; + uint64_t x47; + fiat_sm2_uint1 x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_sm2_uint1 x54; + uint64_t x55; + fiat_sm2_uint1 x56; + uint64_t x57; + fiat_sm2_uint1 x58; + uint64_t x59; + fiat_sm2_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_sm2_uint1 x63; + uint64_t x64; + fiat_sm2_uint1 x65; + uint64_t x66; + fiat_sm2_uint1 x67; + uint64_t x68; + fiat_sm2_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_sm2_uint1 x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_sm2_uint1 x81; + uint64_t x82; + fiat_sm2_uint1 x83; + uint64_t x84; + fiat_sm2_uint1 x85; + uint64_t x86; + fiat_sm2_uint1 x87; + uint64_t x88; + fiat_sm2_uint1 x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + fiat_sm2_uint1 x95; + uint64_t x96; + fiat_sm2_uint1 x97; + uint64_t x98; + fiat_sm2_uint1 x99; + uint64_t x100; + fiat_sm2_uint1 x101; + uint64_t x102; + fiat_sm2_uint1 x103; + uint64_t x104; + fiat_sm2_uint1 x105; + uint64_t x106; + fiat_sm2_uint1 x107; + uint64_t x108; + fiat_sm2_uint1 x109; + uint64_t x110; + fiat_sm2_uint1 x111; + uint64_t x112; + fiat_sm2_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_sm2_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_sm2_uint1)((fiat_sm2_uint1)(x1 >> 63) & (fiat_sm2_uint1)((arg3[0]) & 0x1)); + fiat_sm2_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_sm2_cmovznz_u64(&x6, x3, arg1, x4); + fiat_sm2_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_sm2_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_sm2_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_sm2_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_sm2_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_sm2_addcarryx_u64(&x12, &x13, 0x0, 0x1, (~(arg2[0]))); + fiat_sm2_addcarryx_u64(&x14, &x15, x13, 0x0, (~(arg2[1]))); + fiat_sm2_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[2]))); + fiat_sm2_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[3]))); + fiat_sm2_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[4]))); + fiat_sm2_cmovznz_u64(&x22, x3, (arg3[0]), x12); + fiat_sm2_cmovznz_u64(&x23, x3, (arg3[1]), x14); + fiat_sm2_cmovznz_u64(&x24, x3, (arg3[2]), x16); + fiat_sm2_cmovznz_u64(&x25, x3, (arg3[3]), x18); + fiat_sm2_cmovznz_u64(&x26, x3, (arg3[4]), x20); + fiat_sm2_cmovznz_u64(&x27, x3, (arg4[0]), (arg5[0])); + fiat_sm2_cmovznz_u64(&x28, x3, (arg4[1]), (arg5[1])); + fiat_sm2_cmovznz_u64(&x29, x3, (arg4[2]), (arg5[2])); + fiat_sm2_cmovznz_u64(&x30, x3, (arg4[3]), (arg5[3])); + fiat_sm2_addcarryx_u64(&x31, &x32, 0x0, x27, x27); + fiat_sm2_addcarryx_u64(&x33, &x34, x32, x28, x28); + fiat_sm2_addcarryx_u64(&x35, &x36, x34, x29, x29); + fiat_sm2_addcarryx_u64(&x37, &x38, x36, x30, x30); + fiat_sm2_subborrowx_u64(&x39, &x40, 0x0, x31, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x41, &x42, x40, x33, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x43, &x44, x42, x35, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x45, &x46, x44, x37, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x47, &x48, x46, x38, 0x0); + x49 = (arg4[3]); + x50 = (arg4[2]); + x51 = (arg4[1]); + x52 = (arg4[0]); + fiat_sm2_subborrowx_u64(&x53, &x54, 0x0, 0x0, x52); + fiat_sm2_subborrowx_u64(&x55, &x56, x54, 0x0, x51); + fiat_sm2_subborrowx_u64(&x57, &x58, x56, 0x0, x50); + fiat_sm2_subborrowx_u64(&x59, &x60, x58, 0x0, x49); + fiat_sm2_cmovznz_u64(&x61, x60, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_sm2_addcarryx_u64(&x62, &x63, 0x0, x53, x61); + fiat_sm2_addcarryx_u64(&x64, &x65, x63, x55, (x61 & UINT64_C(0xffffffff00000000))); + fiat_sm2_addcarryx_u64(&x66, &x67, x65, x57, x61); + fiat_sm2_addcarryx_u64(&x68, &x69, x67, x59, (x61 & UINT64_C(0xfffffffeffffffff))); + fiat_sm2_cmovznz_u64(&x70, x3, (arg5[0]), x62); + fiat_sm2_cmovznz_u64(&x71, x3, (arg5[1]), x64); + fiat_sm2_cmovznz_u64(&x72, x3, (arg5[2]), x66); + fiat_sm2_cmovznz_u64(&x73, x3, (arg5[3]), x68); + x74 = (fiat_sm2_uint1)(x22 & 0x1); + fiat_sm2_cmovznz_u64(&x75, x74, 0x0, x7); + fiat_sm2_cmovznz_u64(&x76, x74, 0x0, x8); + fiat_sm2_cmovznz_u64(&x77, x74, 0x0, x9); + fiat_sm2_cmovznz_u64(&x78, x74, 0x0, x10); + fiat_sm2_cmovznz_u64(&x79, x74, 0x0, x11); + fiat_sm2_addcarryx_u64(&x80, &x81, 0x0, x22, x75); + fiat_sm2_addcarryx_u64(&x82, &x83, x81, x23, x76); + fiat_sm2_addcarryx_u64(&x84, &x85, x83, x24, x77); + fiat_sm2_addcarryx_u64(&x86, &x87, x85, x25, x78); + fiat_sm2_addcarryx_u64(&x88, &x89, x87, x26, x79); + fiat_sm2_cmovznz_u64(&x90, x74, 0x0, x27); + fiat_sm2_cmovznz_u64(&x91, x74, 0x0, x28); + fiat_sm2_cmovznz_u64(&x92, x74, 0x0, x29); + fiat_sm2_cmovznz_u64(&x93, x74, 0x0, x30); + fiat_sm2_addcarryx_u64(&x94, &x95, 0x0, x70, x90); + fiat_sm2_addcarryx_u64(&x96, &x97, x95, x71, x91); + fiat_sm2_addcarryx_u64(&x98, &x99, x97, x72, x92); + fiat_sm2_addcarryx_u64(&x100, &x101, x99, x73, x93); + fiat_sm2_subborrowx_u64(&x102, &x103, 0x0, x94, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x104, &x105, x103, x96, UINT64_C(0xffffffff00000000)); + fiat_sm2_subborrowx_u64(&x106, &x107, x105, x98, UINT64_C(0xffffffffffffffff)); + fiat_sm2_subborrowx_u64(&x108, &x109, x107, x100, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_subborrowx_u64(&x110, &x111, x109, x101, 0x0); + fiat_sm2_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_sm2_cmovznz_u64(&x119, x48, x39, x31); + fiat_sm2_cmovznz_u64(&x120, x48, x41, x33); + fiat_sm2_cmovznz_u64(&x121, x48, x43, x35); + fiat_sm2_cmovznz_u64(&x122, x48, x45, x37); + fiat_sm2_cmovznz_u64(&x123, x111, x102, x94); + fiat_sm2_cmovznz_u64(&x124, x111, x104, x96); + fiat_sm2_cmovznz_u64(&x125, x111, x106, x98); + fiat_sm2_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_sm2_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_SM2_FIAT_INLINE void fiat_sm2_divstep_precomp(uint64_t out1[4]) { + out1[0] = UINT64_C(0x500000028ffffffe); + out1[1] = UINT64_C(0xe80000009ffffffe); + out1[2] = UINT64_C(0xd00000018ffffffe); + out1[3] = UINT64_C(0x280000011ffffffd); +} diff --git a/fiat-c/src/sm2_scalar_32.c b/fiat-c/src/sm2_scalar_32.c new file mode 100644 index 00000000000..dbf9a8168a7 --- /dev/null +++ b/fiat-c/src/sm2_scalar_32.c @@ -0,0 +1,5846 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier sm2_scalar 32 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") */ +/* */ +/* 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_sm2_scalar_uint1; +typedef signed char fiat_sm2_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_SM2_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_SM2_SCALAR_FIAT_INLINE +#endif + +/* The type fiat_sm2_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_sm2_scalar_montgomery_domain_field_element[8]; + +/* The type fiat_sm2_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_sm2_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_SM2_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint32_t fiat_sm2_scalar_value_barrier_u32(uint32_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_sm2_scalar_value_barrier_u32(x) (x) +#endif + + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_addcarryx_u32(uint32_t* out1, fiat_sm2_scalar_uint1* out2, fiat_sm2_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + uint64_t x1; + uint32_t x2; + fiat_sm2_scalar_uint1 x3; + x1 = ((arg1 + (uint64_t)arg2) + arg3); + x2 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + x3 = (fiat_sm2_scalar_uint1)(x1 >> 32); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_subborrowx_u32(uint32_t* out1, fiat_sm2_scalar_uint1* out2, fiat_sm2_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + int64_t x1; + fiat_sm2_scalar_int1 x2; + uint32_t x3; + x1 = ((arg2 - (int64_t)arg1) - arg3); + x2 = (fiat_sm2_scalar_int1)(x1 >> 32); + x3 = (uint32_t)(x1 & UINT32_C(0xffffffff)); + *out1 = x3; + *out2 = (fiat_sm2_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_cmovznz_u32(uint32_t* out1, fiat_sm2_scalar_uint1 arg1, uint32_t arg2, uint32_t arg3) { + fiat_sm2_scalar_uint1 x1; + uint32_t x2; + uint32_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_sm2_scalar_int1)(0x0 - x1) & UINT32_C(0xffffffff)); + x3 = ((fiat_sm2_scalar_value_barrier_u32(x2) & arg3) | (fiat_sm2_scalar_value_barrier_u32((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_mul(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1, const fiat_sm2_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_sm2_scalar_uint1 x26; + uint32_t x27; + fiat_sm2_scalar_uint1 x28; + uint32_t x29; + fiat_sm2_scalar_uint1 x30; + uint32_t x31; + fiat_sm2_scalar_uint1 x32; + uint32_t x33; + fiat_sm2_scalar_uint1 x34; + uint32_t x35; + fiat_sm2_scalar_uint1 x36; + uint32_t x37; + fiat_sm2_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_sm2_scalar_uint1 x59; + uint32_t x60; + fiat_sm2_scalar_uint1 x61; + uint32_t x62; + fiat_sm2_scalar_uint1 x63; + uint32_t x64; + fiat_sm2_scalar_uint1 x65; + uint32_t x66; + fiat_sm2_scalar_uint1 x67; + uint32_t x68; + fiat_sm2_scalar_uint1 x69; + uint32_t x70; + fiat_sm2_scalar_uint1 x71; + uint32_t x72; + uint32_t x73; + fiat_sm2_scalar_uint1 x74; + uint32_t x75; + fiat_sm2_scalar_uint1 x76; + uint32_t x77; + fiat_sm2_scalar_uint1 x78; + uint32_t x79; + fiat_sm2_scalar_uint1 x80; + uint32_t x81; + fiat_sm2_scalar_uint1 x82; + uint32_t x83; + fiat_sm2_scalar_uint1 x84; + uint32_t x85; + fiat_sm2_scalar_uint1 x86; + uint32_t x87; + fiat_sm2_scalar_uint1 x88; + uint32_t x89; + fiat_sm2_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_sm2_scalar_uint1 x108; + uint32_t x109; + fiat_sm2_scalar_uint1 x110; + uint32_t x111; + fiat_sm2_scalar_uint1 x112; + uint32_t x113; + fiat_sm2_scalar_uint1 x114; + uint32_t x115; + fiat_sm2_scalar_uint1 x116; + uint32_t x117; + fiat_sm2_scalar_uint1 x118; + uint32_t x119; + fiat_sm2_scalar_uint1 x120; + uint32_t x121; + uint32_t x122; + fiat_sm2_scalar_uint1 x123; + uint32_t x124; + fiat_sm2_scalar_uint1 x125; + uint32_t x126; + fiat_sm2_scalar_uint1 x127; + uint32_t x128; + fiat_sm2_scalar_uint1 x129; + uint32_t x130; + fiat_sm2_scalar_uint1 x131; + uint32_t x132; + fiat_sm2_scalar_uint1 x133; + uint32_t x134; + fiat_sm2_scalar_uint1 x135; + uint32_t x136; + fiat_sm2_scalar_uint1 x137; + uint32_t x138; + fiat_sm2_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_sm2_scalar_uint1 x159; + uint32_t x160; + fiat_sm2_scalar_uint1 x161; + uint32_t x162; + fiat_sm2_scalar_uint1 x163; + uint32_t x164; + fiat_sm2_scalar_uint1 x165; + uint32_t x166; + fiat_sm2_scalar_uint1 x167; + uint32_t x168; + fiat_sm2_scalar_uint1 x169; + uint32_t x170; + fiat_sm2_scalar_uint1 x171; + uint32_t x172; + uint32_t x173; + fiat_sm2_scalar_uint1 x174; + uint32_t x175; + fiat_sm2_scalar_uint1 x176; + uint32_t x177; + fiat_sm2_scalar_uint1 x178; + uint32_t x179; + fiat_sm2_scalar_uint1 x180; + uint32_t x181; + fiat_sm2_scalar_uint1 x182; + uint32_t x183; + fiat_sm2_scalar_uint1 x184; + uint32_t x185; + fiat_sm2_scalar_uint1 x186; + uint32_t x187; + fiat_sm2_scalar_uint1 x188; + uint32_t x189; + fiat_sm2_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_sm2_scalar_uint1 x209; + uint32_t x210; + fiat_sm2_scalar_uint1 x211; + uint32_t x212; + fiat_sm2_scalar_uint1 x213; + uint32_t x214; + fiat_sm2_scalar_uint1 x215; + uint32_t x216; + fiat_sm2_scalar_uint1 x217; + uint32_t x218; + fiat_sm2_scalar_uint1 x219; + uint32_t x220; + fiat_sm2_scalar_uint1 x221; + uint32_t x222; + uint32_t x223; + fiat_sm2_scalar_uint1 x224; + uint32_t x225; + fiat_sm2_scalar_uint1 x226; + uint32_t x227; + fiat_sm2_scalar_uint1 x228; + uint32_t x229; + fiat_sm2_scalar_uint1 x230; + uint32_t x231; + fiat_sm2_scalar_uint1 x232; + uint32_t x233; + fiat_sm2_scalar_uint1 x234; + uint32_t x235; + fiat_sm2_scalar_uint1 x236; + uint32_t x237; + fiat_sm2_scalar_uint1 x238; + uint32_t x239; + fiat_sm2_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_sm2_scalar_uint1 x260; + uint32_t x261; + fiat_sm2_scalar_uint1 x262; + uint32_t x263; + fiat_sm2_scalar_uint1 x264; + uint32_t x265; + fiat_sm2_scalar_uint1 x266; + uint32_t x267; + fiat_sm2_scalar_uint1 x268; + uint32_t x269; + fiat_sm2_scalar_uint1 x270; + uint32_t x271; + fiat_sm2_scalar_uint1 x272; + uint32_t x273; + uint32_t x274; + fiat_sm2_scalar_uint1 x275; + uint32_t x276; + fiat_sm2_scalar_uint1 x277; + uint32_t x278; + fiat_sm2_scalar_uint1 x279; + uint32_t x280; + fiat_sm2_scalar_uint1 x281; + uint32_t x282; + fiat_sm2_scalar_uint1 x283; + uint32_t x284; + fiat_sm2_scalar_uint1 x285; + uint32_t x286; + fiat_sm2_scalar_uint1 x287; + uint32_t x288; + fiat_sm2_scalar_uint1 x289; + uint32_t x290; + fiat_sm2_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_sm2_scalar_uint1 x310; + uint32_t x311; + fiat_sm2_scalar_uint1 x312; + uint32_t x313; + fiat_sm2_scalar_uint1 x314; + uint32_t x315; + fiat_sm2_scalar_uint1 x316; + uint32_t x317; + fiat_sm2_scalar_uint1 x318; + uint32_t x319; + fiat_sm2_scalar_uint1 x320; + uint32_t x321; + fiat_sm2_scalar_uint1 x322; + uint32_t x323; + uint32_t x324; + fiat_sm2_scalar_uint1 x325; + uint32_t x326; + fiat_sm2_scalar_uint1 x327; + uint32_t x328; + fiat_sm2_scalar_uint1 x329; + uint32_t x330; + fiat_sm2_scalar_uint1 x331; + uint32_t x332; + fiat_sm2_scalar_uint1 x333; + uint32_t x334; + fiat_sm2_scalar_uint1 x335; + uint32_t x336; + fiat_sm2_scalar_uint1 x337; + uint32_t x338; + fiat_sm2_scalar_uint1 x339; + uint32_t x340; + fiat_sm2_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_sm2_scalar_uint1 x361; + uint32_t x362; + fiat_sm2_scalar_uint1 x363; + uint32_t x364; + fiat_sm2_scalar_uint1 x365; + uint32_t x366; + fiat_sm2_scalar_uint1 x367; + uint32_t x368; + fiat_sm2_scalar_uint1 x369; + uint32_t x370; + fiat_sm2_scalar_uint1 x371; + uint32_t x372; + fiat_sm2_scalar_uint1 x373; + uint32_t x374; + uint32_t x375; + fiat_sm2_scalar_uint1 x376; + uint32_t x377; + fiat_sm2_scalar_uint1 x378; + uint32_t x379; + fiat_sm2_scalar_uint1 x380; + uint32_t x381; + fiat_sm2_scalar_uint1 x382; + uint32_t x383; + fiat_sm2_scalar_uint1 x384; + uint32_t x385; + fiat_sm2_scalar_uint1 x386; + uint32_t x387; + fiat_sm2_scalar_uint1 x388; + uint32_t x389; + fiat_sm2_scalar_uint1 x390; + uint32_t x391; + fiat_sm2_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_sm2_scalar_uint1 x411; + uint32_t x412; + fiat_sm2_scalar_uint1 x413; + uint32_t x414; + fiat_sm2_scalar_uint1 x415; + uint32_t x416; + fiat_sm2_scalar_uint1 x417; + uint32_t x418; + fiat_sm2_scalar_uint1 x419; + uint32_t x420; + fiat_sm2_scalar_uint1 x421; + uint32_t x422; + fiat_sm2_scalar_uint1 x423; + uint32_t x424; + uint32_t x425; + fiat_sm2_scalar_uint1 x426; + uint32_t x427; + fiat_sm2_scalar_uint1 x428; + uint32_t x429; + fiat_sm2_scalar_uint1 x430; + uint32_t x431; + fiat_sm2_scalar_uint1 x432; + uint32_t x433; + fiat_sm2_scalar_uint1 x434; + uint32_t x435; + fiat_sm2_scalar_uint1 x436; + uint32_t x437; + fiat_sm2_scalar_uint1 x438; + uint32_t x439; + fiat_sm2_scalar_uint1 x440; + uint32_t x441; + fiat_sm2_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_sm2_scalar_uint1 x462; + uint32_t x463; + fiat_sm2_scalar_uint1 x464; + uint32_t x465; + fiat_sm2_scalar_uint1 x466; + uint32_t x467; + fiat_sm2_scalar_uint1 x468; + uint32_t x469; + fiat_sm2_scalar_uint1 x470; + uint32_t x471; + fiat_sm2_scalar_uint1 x472; + uint32_t x473; + fiat_sm2_scalar_uint1 x474; + uint32_t x475; + uint32_t x476; + fiat_sm2_scalar_uint1 x477; + uint32_t x478; + fiat_sm2_scalar_uint1 x479; + uint32_t x480; + fiat_sm2_scalar_uint1 x481; + uint32_t x482; + fiat_sm2_scalar_uint1 x483; + uint32_t x484; + fiat_sm2_scalar_uint1 x485; + uint32_t x486; + fiat_sm2_scalar_uint1 x487; + uint32_t x488; + fiat_sm2_scalar_uint1 x489; + uint32_t x490; + fiat_sm2_scalar_uint1 x491; + uint32_t x492; + fiat_sm2_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_sm2_scalar_uint1 x512; + uint32_t x513; + fiat_sm2_scalar_uint1 x514; + uint32_t x515; + fiat_sm2_scalar_uint1 x516; + uint32_t x517; + fiat_sm2_scalar_uint1 x518; + uint32_t x519; + fiat_sm2_scalar_uint1 x520; + uint32_t x521; + fiat_sm2_scalar_uint1 x522; + uint32_t x523; + fiat_sm2_scalar_uint1 x524; + uint32_t x525; + uint32_t x526; + fiat_sm2_scalar_uint1 x527; + uint32_t x528; + fiat_sm2_scalar_uint1 x529; + uint32_t x530; + fiat_sm2_scalar_uint1 x531; + uint32_t x532; + fiat_sm2_scalar_uint1 x533; + uint32_t x534; + fiat_sm2_scalar_uint1 x535; + uint32_t x536; + fiat_sm2_scalar_uint1 x537; + uint32_t x538; + fiat_sm2_scalar_uint1 x539; + uint32_t x540; + fiat_sm2_scalar_uint1 x541; + uint32_t x542; + fiat_sm2_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_sm2_scalar_uint1 x563; + uint32_t x564; + fiat_sm2_scalar_uint1 x565; + uint32_t x566; + fiat_sm2_scalar_uint1 x567; + uint32_t x568; + fiat_sm2_scalar_uint1 x569; + uint32_t x570; + fiat_sm2_scalar_uint1 x571; + uint32_t x572; + fiat_sm2_scalar_uint1 x573; + uint32_t x574; + fiat_sm2_scalar_uint1 x575; + uint32_t x576; + uint32_t x577; + fiat_sm2_scalar_uint1 x578; + uint32_t x579; + fiat_sm2_scalar_uint1 x580; + uint32_t x581; + fiat_sm2_scalar_uint1 x582; + uint32_t x583; + fiat_sm2_scalar_uint1 x584; + uint32_t x585; + fiat_sm2_scalar_uint1 x586; + uint32_t x587; + fiat_sm2_scalar_uint1 x588; + uint32_t x589; + fiat_sm2_scalar_uint1 x590; + uint32_t x591; + fiat_sm2_scalar_uint1 x592; + uint32_t x593; + fiat_sm2_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_sm2_scalar_uint1 x613; + uint32_t x614; + fiat_sm2_scalar_uint1 x615; + uint32_t x616; + fiat_sm2_scalar_uint1 x617; + uint32_t x618; + fiat_sm2_scalar_uint1 x619; + uint32_t x620; + fiat_sm2_scalar_uint1 x621; + uint32_t x622; + fiat_sm2_scalar_uint1 x623; + uint32_t x624; + fiat_sm2_scalar_uint1 x625; + uint32_t x626; + uint32_t x627; + fiat_sm2_scalar_uint1 x628; + uint32_t x629; + fiat_sm2_scalar_uint1 x630; + uint32_t x631; + fiat_sm2_scalar_uint1 x632; + uint32_t x633; + fiat_sm2_scalar_uint1 x634; + uint32_t x635; + fiat_sm2_scalar_uint1 x636; + uint32_t x637; + fiat_sm2_scalar_uint1 x638; + uint32_t x639; + fiat_sm2_scalar_uint1 x640; + uint32_t x641; + fiat_sm2_scalar_uint1 x642; + uint32_t x643; + fiat_sm2_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_sm2_scalar_uint1 x664; + uint32_t x665; + fiat_sm2_scalar_uint1 x666; + uint32_t x667; + fiat_sm2_scalar_uint1 x668; + uint32_t x669; + fiat_sm2_scalar_uint1 x670; + uint32_t x671; + fiat_sm2_scalar_uint1 x672; + uint32_t x673; + fiat_sm2_scalar_uint1 x674; + uint32_t x675; + fiat_sm2_scalar_uint1 x676; + uint32_t x677; + uint32_t x678; + fiat_sm2_scalar_uint1 x679; + uint32_t x680; + fiat_sm2_scalar_uint1 x681; + uint32_t x682; + fiat_sm2_scalar_uint1 x683; + uint32_t x684; + fiat_sm2_scalar_uint1 x685; + uint32_t x686; + fiat_sm2_scalar_uint1 x687; + uint32_t x688; + fiat_sm2_scalar_uint1 x689; + uint32_t x690; + fiat_sm2_scalar_uint1 x691; + uint32_t x692; + fiat_sm2_scalar_uint1 x693; + uint32_t x694; + fiat_sm2_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_sm2_scalar_uint1 x714; + uint32_t x715; + fiat_sm2_scalar_uint1 x716; + uint32_t x717; + fiat_sm2_scalar_uint1 x718; + uint32_t x719; + fiat_sm2_scalar_uint1 x720; + uint32_t x721; + fiat_sm2_scalar_uint1 x722; + uint32_t x723; + fiat_sm2_scalar_uint1 x724; + uint32_t x725; + fiat_sm2_scalar_uint1 x726; + uint32_t x727; + uint32_t x728; + fiat_sm2_scalar_uint1 x729; + uint32_t x730; + fiat_sm2_scalar_uint1 x731; + uint32_t x732; + fiat_sm2_scalar_uint1 x733; + uint32_t x734; + fiat_sm2_scalar_uint1 x735; + uint32_t x736; + fiat_sm2_scalar_uint1 x737; + uint32_t x738; + fiat_sm2_scalar_uint1 x739; + uint32_t x740; + fiat_sm2_scalar_uint1 x741; + uint32_t x742; + fiat_sm2_scalar_uint1 x743; + uint32_t x744; + fiat_sm2_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_sm2_scalar_uint1 x765; + uint32_t x766; + fiat_sm2_scalar_uint1 x767; + uint32_t x768; + fiat_sm2_scalar_uint1 x769; + uint32_t x770; + fiat_sm2_scalar_uint1 x771; + uint32_t x772; + fiat_sm2_scalar_uint1 x773; + uint32_t x774; + fiat_sm2_scalar_uint1 x775; + uint32_t x776; + fiat_sm2_scalar_uint1 x777; + uint32_t x778; + uint32_t x779; + fiat_sm2_scalar_uint1 x780; + uint32_t x781; + fiat_sm2_scalar_uint1 x782; + uint32_t x783; + fiat_sm2_scalar_uint1 x784; + uint32_t x785; + fiat_sm2_scalar_uint1 x786; + uint32_t x787; + fiat_sm2_scalar_uint1 x788; + uint32_t x789; + fiat_sm2_scalar_uint1 x790; + uint32_t x791; + fiat_sm2_scalar_uint1 x792; + uint32_t x793; + fiat_sm2_scalar_uint1 x794; + uint32_t x795; + fiat_sm2_scalar_uint1 x796; + uint32_t x797; + uint32_t x798; + fiat_sm2_scalar_uint1 x799; + uint32_t x800; + fiat_sm2_scalar_uint1 x801; + uint32_t x802; + fiat_sm2_scalar_uint1 x803; + uint32_t x804; + fiat_sm2_scalar_uint1 x805; + uint32_t x806; + fiat_sm2_scalar_uint1 x807; + uint32_t x808; + fiat_sm2_scalar_uint1 x809; + uint32_t x810; + fiat_sm2_scalar_uint1 x811; + uint32_t x812; + fiat_sm2_scalar_uint1 x813; + uint32_t x814; + fiat_sm2_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_sm2_scalar_mulx_u32(&x9, &x10, x8, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x11, &x12, x8, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x13, &x14, x8, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x15, &x16, x8, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x17, &x18, x8, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x19, &x20, x8, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x21, &x22, x8, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x23, &x24, x8, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_sm2_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_sm2_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_sm2_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_sm2_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_sm2_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_sm2_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_sm2_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x52, &x53, x40, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x54, &x55, x40, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x56, &x57, x40, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x58, &x59, 0x0, x57, x54); + fiat_sm2_scalar_addcarryx_u32(&x60, &x61, x59, x55, x52); + fiat_sm2_scalar_addcarryx_u32(&x62, &x63, x61, x53, x50); + fiat_sm2_scalar_addcarryx_u32(&x64, &x65, x63, x51, x48); + fiat_sm2_scalar_addcarryx_u32(&x66, &x67, x65, x49, x46); + fiat_sm2_scalar_addcarryx_u32(&x68, &x69, x67, x47, x44); + fiat_sm2_scalar_addcarryx_u32(&x70, &x71, x69, x45, x42); + x72 = (x71 + x43); + fiat_sm2_scalar_addcarryx_u32(&x73, &x74, 0x0, x23, x56); + fiat_sm2_scalar_addcarryx_u32(&x75, &x76, x74, x25, x58); + fiat_sm2_scalar_addcarryx_u32(&x77, &x78, x76, x27, x60); + fiat_sm2_scalar_addcarryx_u32(&x79, &x80, x78, x29, x62); + fiat_sm2_scalar_addcarryx_u32(&x81, &x82, x80, x31, x64); + fiat_sm2_scalar_addcarryx_u32(&x83, &x84, x82, x33, x66); + fiat_sm2_scalar_addcarryx_u32(&x85, &x86, x84, x35, x68); + fiat_sm2_scalar_addcarryx_u32(&x87, &x88, x86, x37, x70); + fiat_sm2_scalar_addcarryx_u32(&x89, &x90, x88, x39, x72); + fiat_sm2_scalar_mulx_u32(&x91, &x92, x1, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x93, &x94, x1, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x95, &x96, x1, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x97, &x98, x1, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x99, &x100, x1, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x101, &x102, x1, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x103, &x104, x1, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x105, &x106, x1, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x107, &x108, 0x0, x106, x103); + fiat_sm2_scalar_addcarryx_u32(&x109, &x110, x108, x104, x101); + fiat_sm2_scalar_addcarryx_u32(&x111, &x112, x110, x102, x99); + fiat_sm2_scalar_addcarryx_u32(&x113, &x114, x112, x100, x97); + fiat_sm2_scalar_addcarryx_u32(&x115, &x116, x114, x98, x95); + fiat_sm2_scalar_addcarryx_u32(&x117, &x118, x116, x96, x93); + fiat_sm2_scalar_addcarryx_u32(&x119, &x120, x118, x94, x91); + x121 = (x120 + x92); + fiat_sm2_scalar_addcarryx_u32(&x122, &x123, 0x0, x75, x105); + fiat_sm2_scalar_addcarryx_u32(&x124, &x125, x123, x77, x107); + fiat_sm2_scalar_addcarryx_u32(&x126, &x127, x125, x79, x109); + fiat_sm2_scalar_addcarryx_u32(&x128, &x129, x127, x81, x111); + fiat_sm2_scalar_addcarryx_u32(&x130, &x131, x129, x83, x113); + fiat_sm2_scalar_addcarryx_u32(&x132, &x133, x131, x85, x115); + fiat_sm2_scalar_addcarryx_u32(&x134, &x135, x133, x87, x117); + fiat_sm2_scalar_addcarryx_u32(&x136, &x137, x135, x89, x119); + fiat_sm2_scalar_addcarryx_u32(&x138, &x139, x137, x90, x121); + fiat_sm2_scalar_mulx_u32(&x140, &x141, x122, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x142, &x143, x140, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x144, &x145, x140, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x146, &x147, x140, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x148, &x149, x140, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x150, &x151, x140, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x152, &x153, x140, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x154, &x155, x140, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x156, &x157, x140, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x158, &x159, 0x0, x157, x154); + fiat_sm2_scalar_addcarryx_u32(&x160, &x161, x159, x155, x152); + fiat_sm2_scalar_addcarryx_u32(&x162, &x163, x161, x153, x150); + fiat_sm2_scalar_addcarryx_u32(&x164, &x165, x163, x151, x148); + fiat_sm2_scalar_addcarryx_u32(&x166, &x167, x165, x149, x146); + fiat_sm2_scalar_addcarryx_u32(&x168, &x169, x167, x147, x144); + fiat_sm2_scalar_addcarryx_u32(&x170, &x171, x169, x145, x142); + x172 = (x171 + x143); + fiat_sm2_scalar_addcarryx_u32(&x173, &x174, 0x0, x122, x156); + fiat_sm2_scalar_addcarryx_u32(&x175, &x176, x174, x124, x158); + fiat_sm2_scalar_addcarryx_u32(&x177, &x178, x176, x126, x160); + fiat_sm2_scalar_addcarryx_u32(&x179, &x180, x178, x128, x162); + fiat_sm2_scalar_addcarryx_u32(&x181, &x182, x180, x130, x164); + fiat_sm2_scalar_addcarryx_u32(&x183, &x184, x182, x132, x166); + fiat_sm2_scalar_addcarryx_u32(&x185, &x186, x184, x134, x168); + fiat_sm2_scalar_addcarryx_u32(&x187, &x188, x186, x136, x170); + fiat_sm2_scalar_addcarryx_u32(&x189, &x190, x188, x138, x172); + x191 = ((uint32_t)x190 + x139); + fiat_sm2_scalar_mulx_u32(&x192, &x193, x2, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x194, &x195, x2, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x196, &x197, x2, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x198, &x199, x2, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x200, &x201, x2, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x202, &x203, x2, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x204, &x205, x2, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x206, &x207, x2, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x208, &x209, 0x0, x207, x204); + fiat_sm2_scalar_addcarryx_u32(&x210, &x211, x209, x205, x202); + fiat_sm2_scalar_addcarryx_u32(&x212, &x213, x211, x203, x200); + fiat_sm2_scalar_addcarryx_u32(&x214, &x215, x213, x201, x198); + fiat_sm2_scalar_addcarryx_u32(&x216, &x217, x215, x199, x196); + fiat_sm2_scalar_addcarryx_u32(&x218, &x219, x217, x197, x194); + fiat_sm2_scalar_addcarryx_u32(&x220, &x221, x219, x195, x192); + x222 = (x221 + x193); + fiat_sm2_scalar_addcarryx_u32(&x223, &x224, 0x0, x175, x206); + fiat_sm2_scalar_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_sm2_scalar_addcarryx_u32(&x227, &x228, x226, x179, x210); + fiat_sm2_scalar_addcarryx_u32(&x229, &x230, x228, x181, x212); + fiat_sm2_scalar_addcarryx_u32(&x231, &x232, x230, x183, x214); + fiat_sm2_scalar_addcarryx_u32(&x233, &x234, x232, x185, x216); + fiat_sm2_scalar_addcarryx_u32(&x235, &x236, x234, x187, x218); + fiat_sm2_scalar_addcarryx_u32(&x237, &x238, x236, x189, x220); + fiat_sm2_scalar_addcarryx_u32(&x239, &x240, x238, x191, x222); + fiat_sm2_scalar_mulx_u32(&x241, &x242, x223, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x243, &x244, x241, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x245, &x246, x241, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x247, &x248, x241, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x249, &x250, x241, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x251, &x252, x241, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x253, &x254, x241, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x255, &x256, x241, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x257, &x258, x241, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x259, &x260, 0x0, x258, x255); + fiat_sm2_scalar_addcarryx_u32(&x261, &x262, x260, x256, x253); + fiat_sm2_scalar_addcarryx_u32(&x263, &x264, x262, x254, x251); + fiat_sm2_scalar_addcarryx_u32(&x265, &x266, x264, x252, x249); + fiat_sm2_scalar_addcarryx_u32(&x267, &x268, x266, x250, x247); + fiat_sm2_scalar_addcarryx_u32(&x269, &x270, x268, x248, x245); + fiat_sm2_scalar_addcarryx_u32(&x271, &x272, x270, x246, x243); + x273 = (x272 + x244); + fiat_sm2_scalar_addcarryx_u32(&x274, &x275, 0x0, x223, x257); + fiat_sm2_scalar_addcarryx_u32(&x276, &x277, x275, x225, x259); + fiat_sm2_scalar_addcarryx_u32(&x278, &x279, x277, x227, x261); + fiat_sm2_scalar_addcarryx_u32(&x280, &x281, x279, x229, x263); + fiat_sm2_scalar_addcarryx_u32(&x282, &x283, x281, x231, x265); + fiat_sm2_scalar_addcarryx_u32(&x284, &x285, x283, x233, x267); + fiat_sm2_scalar_addcarryx_u32(&x286, &x287, x285, x235, x269); + fiat_sm2_scalar_addcarryx_u32(&x288, &x289, x287, x237, x271); + fiat_sm2_scalar_addcarryx_u32(&x290, &x291, x289, x239, x273); + x292 = ((uint32_t)x291 + x240); + fiat_sm2_scalar_mulx_u32(&x293, &x294, x3, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x295, &x296, x3, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x297, &x298, x3, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x299, &x300, x3, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x301, &x302, x3, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x303, &x304, x3, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x305, &x306, x3, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x307, &x308, x3, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x309, &x310, 0x0, x308, x305); + fiat_sm2_scalar_addcarryx_u32(&x311, &x312, x310, x306, x303); + fiat_sm2_scalar_addcarryx_u32(&x313, &x314, x312, x304, x301); + fiat_sm2_scalar_addcarryx_u32(&x315, &x316, x314, x302, x299); + fiat_sm2_scalar_addcarryx_u32(&x317, &x318, x316, x300, x297); + fiat_sm2_scalar_addcarryx_u32(&x319, &x320, x318, x298, x295); + fiat_sm2_scalar_addcarryx_u32(&x321, &x322, x320, x296, x293); + x323 = (x322 + x294); + fiat_sm2_scalar_addcarryx_u32(&x324, &x325, 0x0, x276, x307); + fiat_sm2_scalar_addcarryx_u32(&x326, &x327, x325, x278, x309); + fiat_sm2_scalar_addcarryx_u32(&x328, &x329, x327, x280, x311); + fiat_sm2_scalar_addcarryx_u32(&x330, &x331, x329, x282, x313); + fiat_sm2_scalar_addcarryx_u32(&x332, &x333, x331, x284, x315); + fiat_sm2_scalar_addcarryx_u32(&x334, &x335, x333, x286, x317); + fiat_sm2_scalar_addcarryx_u32(&x336, &x337, x335, x288, x319); + fiat_sm2_scalar_addcarryx_u32(&x338, &x339, x337, x290, x321); + fiat_sm2_scalar_addcarryx_u32(&x340, &x341, x339, x292, x323); + fiat_sm2_scalar_mulx_u32(&x342, &x343, x324, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x344, &x345, x342, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x346, &x347, x342, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x348, &x349, x342, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x350, &x351, x342, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x352, &x353, x342, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x354, &x355, x342, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x356, &x357, x342, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x358, &x359, x342, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x360, &x361, 0x0, x359, x356); + fiat_sm2_scalar_addcarryx_u32(&x362, &x363, x361, x357, x354); + fiat_sm2_scalar_addcarryx_u32(&x364, &x365, x363, x355, x352); + fiat_sm2_scalar_addcarryx_u32(&x366, &x367, x365, x353, x350); + fiat_sm2_scalar_addcarryx_u32(&x368, &x369, x367, x351, x348); + fiat_sm2_scalar_addcarryx_u32(&x370, &x371, x369, x349, x346); + fiat_sm2_scalar_addcarryx_u32(&x372, &x373, x371, x347, x344); + x374 = (x373 + x345); + fiat_sm2_scalar_addcarryx_u32(&x375, &x376, 0x0, x324, x358); + fiat_sm2_scalar_addcarryx_u32(&x377, &x378, x376, x326, x360); + fiat_sm2_scalar_addcarryx_u32(&x379, &x380, x378, x328, x362); + fiat_sm2_scalar_addcarryx_u32(&x381, &x382, x380, x330, x364); + fiat_sm2_scalar_addcarryx_u32(&x383, &x384, x382, x332, x366); + fiat_sm2_scalar_addcarryx_u32(&x385, &x386, x384, x334, x368); + fiat_sm2_scalar_addcarryx_u32(&x387, &x388, x386, x336, x370); + fiat_sm2_scalar_addcarryx_u32(&x389, &x390, x388, x338, x372); + fiat_sm2_scalar_addcarryx_u32(&x391, &x392, x390, x340, x374); + x393 = ((uint32_t)x392 + x341); + fiat_sm2_scalar_mulx_u32(&x394, &x395, x4, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x396, &x397, x4, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x398, &x399, x4, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x400, &x401, x4, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x402, &x403, x4, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x404, &x405, x4, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x406, &x407, x4, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x408, &x409, x4, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x410, &x411, 0x0, x409, x406); + fiat_sm2_scalar_addcarryx_u32(&x412, &x413, x411, x407, x404); + fiat_sm2_scalar_addcarryx_u32(&x414, &x415, x413, x405, x402); + fiat_sm2_scalar_addcarryx_u32(&x416, &x417, x415, x403, x400); + fiat_sm2_scalar_addcarryx_u32(&x418, &x419, x417, x401, x398); + fiat_sm2_scalar_addcarryx_u32(&x420, &x421, x419, x399, x396); + fiat_sm2_scalar_addcarryx_u32(&x422, &x423, x421, x397, x394); + x424 = (x423 + x395); + fiat_sm2_scalar_addcarryx_u32(&x425, &x426, 0x0, x377, x408); + fiat_sm2_scalar_addcarryx_u32(&x427, &x428, x426, x379, x410); + fiat_sm2_scalar_addcarryx_u32(&x429, &x430, x428, x381, x412); + fiat_sm2_scalar_addcarryx_u32(&x431, &x432, x430, x383, x414); + fiat_sm2_scalar_addcarryx_u32(&x433, &x434, x432, x385, x416); + fiat_sm2_scalar_addcarryx_u32(&x435, &x436, x434, x387, x418); + fiat_sm2_scalar_addcarryx_u32(&x437, &x438, x436, x389, x420); + fiat_sm2_scalar_addcarryx_u32(&x439, &x440, x438, x391, x422); + fiat_sm2_scalar_addcarryx_u32(&x441, &x442, x440, x393, x424); + fiat_sm2_scalar_mulx_u32(&x443, &x444, x425, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x445, &x446, x443, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x447, &x448, x443, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x449, &x450, x443, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x451, &x452, x443, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x453, &x454, x443, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x455, &x456, x443, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x457, &x458, x443, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x459, &x460, x443, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x461, &x462, 0x0, x460, x457); + fiat_sm2_scalar_addcarryx_u32(&x463, &x464, x462, x458, x455); + fiat_sm2_scalar_addcarryx_u32(&x465, &x466, x464, x456, x453); + fiat_sm2_scalar_addcarryx_u32(&x467, &x468, x466, x454, x451); + fiat_sm2_scalar_addcarryx_u32(&x469, &x470, x468, x452, x449); + fiat_sm2_scalar_addcarryx_u32(&x471, &x472, x470, x450, x447); + fiat_sm2_scalar_addcarryx_u32(&x473, &x474, x472, x448, x445); + x475 = (x474 + x446); + fiat_sm2_scalar_addcarryx_u32(&x476, &x477, 0x0, x425, x459); + fiat_sm2_scalar_addcarryx_u32(&x478, &x479, x477, x427, x461); + fiat_sm2_scalar_addcarryx_u32(&x480, &x481, x479, x429, x463); + fiat_sm2_scalar_addcarryx_u32(&x482, &x483, x481, x431, x465); + fiat_sm2_scalar_addcarryx_u32(&x484, &x485, x483, x433, x467); + fiat_sm2_scalar_addcarryx_u32(&x486, &x487, x485, x435, x469); + fiat_sm2_scalar_addcarryx_u32(&x488, &x489, x487, x437, x471); + fiat_sm2_scalar_addcarryx_u32(&x490, &x491, x489, x439, x473); + fiat_sm2_scalar_addcarryx_u32(&x492, &x493, x491, x441, x475); + x494 = ((uint32_t)x493 + x442); + fiat_sm2_scalar_mulx_u32(&x495, &x496, x5, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x497, &x498, x5, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x499, &x500, x5, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x501, &x502, x5, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x503, &x504, x5, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x505, &x506, x5, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x507, &x508, x5, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x509, &x510, x5, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x511, &x512, 0x0, x510, x507); + fiat_sm2_scalar_addcarryx_u32(&x513, &x514, x512, x508, x505); + fiat_sm2_scalar_addcarryx_u32(&x515, &x516, x514, x506, x503); + fiat_sm2_scalar_addcarryx_u32(&x517, &x518, x516, x504, x501); + fiat_sm2_scalar_addcarryx_u32(&x519, &x520, x518, x502, x499); + fiat_sm2_scalar_addcarryx_u32(&x521, &x522, x520, x500, x497); + fiat_sm2_scalar_addcarryx_u32(&x523, &x524, x522, x498, x495); + x525 = (x524 + x496); + fiat_sm2_scalar_addcarryx_u32(&x526, &x527, 0x0, x478, x509); + fiat_sm2_scalar_addcarryx_u32(&x528, &x529, x527, x480, x511); + fiat_sm2_scalar_addcarryx_u32(&x530, &x531, x529, x482, x513); + fiat_sm2_scalar_addcarryx_u32(&x532, &x533, x531, x484, x515); + fiat_sm2_scalar_addcarryx_u32(&x534, &x535, x533, x486, x517); + fiat_sm2_scalar_addcarryx_u32(&x536, &x537, x535, x488, x519); + fiat_sm2_scalar_addcarryx_u32(&x538, &x539, x537, x490, x521); + fiat_sm2_scalar_addcarryx_u32(&x540, &x541, x539, x492, x523); + fiat_sm2_scalar_addcarryx_u32(&x542, &x543, x541, x494, x525); + fiat_sm2_scalar_mulx_u32(&x544, &x545, x526, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x546, &x547, x544, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x548, &x549, x544, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x550, &x551, x544, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x552, &x553, x544, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x554, &x555, x544, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x556, &x557, x544, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x558, &x559, x544, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x560, &x561, x544, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x562, &x563, 0x0, x561, x558); + fiat_sm2_scalar_addcarryx_u32(&x564, &x565, x563, x559, x556); + fiat_sm2_scalar_addcarryx_u32(&x566, &x567, x565, x557, x554); + fiat_sm2_scalar_addcarryx_u32(&x568, &x569, x567, x555, x552); + fiat_sm2_scalar_addcarryx_u32(&x570, &x571, x569, x553, x550); + fiat_sm2_scalar_addcarryx_u32(&x572, &x573, x571, x551, x548); + fiat_sm2_scalar_addcarryx_u32(&x574, &x575, x573, x549, x546); + x576 = (x575 + x547); + fiat_sm2_scalar_addcarryx_u32(&x577, &x578, 0x0, x526, x560); + fiat_sm2_scalar_addcarryx_u32(&x579, &x580, x578, x528, x562); + fiat_sm2_scalar_addcarryx_u32(&x581, &x582, x580, x530, x564); + fiat_sm2_scalar_addcarryx_u32(&x583, &x584, x582, x532, x566); + fiat_sm2_scalar_addcarryx_u32(&x585, &x586, x584, x534, x568); + fiat_sm2_scalar_addcarryx_u32(&x587, &x588, x586, x536, x570); + fiat_sm2_scalar_addcarryx_u32(&x589, &x590, x588, x538, x572); + fiat_sm2_scalar_addcarryx_u32(&x591, &x592, x590, x540, x574); + fiat_sm2_scalar_addcarryx_u32(&x593, &x594, x592, x542, x576); + x595 = ((uint32_t)x594 + x543); + fiat_sm2_scalar_mulx_u32(&x596, &x597, x6, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x598, &x599, x6, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x600, &x601, x6, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x602, &x603, x6, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x604, &x605, x6, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x606, &x607, x6, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x608, &x609, x6, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x610, &x611, x6, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x612, &x613, 0x0, x611, x608); + fiat_sm2_scalar_addcarryx_u32(&x614, &x615, x613, x609, x606); + fiat_sm2_scalar_addcarryx_u32(&x616, &x617, x615, x607, x604); + fiat_sm2_scalar_addcarryx_u32(&x618, &x619, x617, x605, x602); + fiat_sm2_scalar_addcarryx_u32(&x620, &x621, x619, x603, x600); + fiat_sm2_scalar_addcarryx_u32(&x622, &x623, x621, x601, x598); + fiat_sm2_scalar_addcarryx_u32(&x624, &x625, x623, x599, x596); + x626 = (x625 + x597); + fiat_sm2_scalar_addcarryx_u32(&x627, &x628, 0x0, x579, x610); + fiat_sm2_scalar_addcarryx_u32(&x629, &x630, x628, x581, x612); + fiat_sm2_scalar_addcarryx_u32(&x631, &x632, x630, x583, x614); + fiat_sm2_scalar_addcarryx_u32(&x633, &x634, x632, x585, x616); + fiat_sm2_scalar_addcarryx_u32(&x635, &x636, x634, x587, x618); + fiat_sm2_scalar_addcarryx_u32(&x637, &x638, x636, x589, x620); + fiat_sm2_scalar_addcarryx_u32(&x639, &x640, x638, x591, x622); + fiat_sm2_scalar_addcarryx_u32(&x641, &x642, x640, x593, x624); + fiat_sm2_scalar_addcarryx_u32(&x643, &x644, x642, x595, x626); + fiat_sm2_scalar_mulx_u32(&x645, &x646, x627, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x647, &x648, x645, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x649, &x650, x645, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x651, &x652, x645, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x653, &x654, x645, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x655, &x656, x645, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x657, &x658, x645, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x659, &x660, x645, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x661, &x662, x645, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x663, &x664, 0x0, x662, x659); + fiat_sm2_scalar_addcarryx_u32(&x665, &x666, x664, x660, x657); + fiat_sm2_scalar_addcarryx_u32(&x667, &x668, x666, x658, x655); + fiat_sm2_scalar_addcarryx_u32(&x669, &x670, x668, x656, x653); + fiat_sm2_scalar_addcarryx_u32(&x671, &x672, x670, x654, x651); + fiat_sm2_scalar_addcarryx_u32(&x673, &x674, x672, x652, x649); + fiat_sm2_scalar_addcarryx_u32(&x675, &x676, x674, x650, x647); + x677 = (x676 + x648); + fiat_sm2_scalar_addcarryx_u32(&x678, &x679, 0x0, x627, x661); + fiat_sm2_scalar_addcarryx_u32(&x680, &x681, x679, x629, x663); + fiat_sm2_scalar_addcarryx_u32(&x682, &x683, x681, x631, x665); + fiat_sm2_scalar_addcarryx_u32(&x684, &x685, x683, x633, x667); + fiat_sm2_scalar_addcarryx_u32(&x686, &x687, x685, x635, x669); + fiat_sm2_scalar_addcarryx_u32(&x688, &x689, x687, x637, x671); + fiat_sm2_scalar_addcarryx_u32(&x690, &x691, x689, x639, x673); + fiat_sm2_scalar_addcarryx_u32(&x692, &x693, x691, x641, x675); + fiat_sm2_scalar_addcarryx_u32(&x694, &x695, x693, x643, x677); + x696 = ((uint32_t)x695 + x644); + fiat_sm2_scalar_mulx_u32(&x697, &x698, x7, (arg2[7])); + fiat_sm2_scalar_mulx_u32(&x699, &x700, x7, (arg2[6])); + fiat_sm2_scalar_mulx_u32(&x701, &x702, x7, (arg2[5])); + fiat_sm2_scalar_mulx_u32(&x703, &x704, x7, (arg2[4])); + fiat_sm2_scalar_mulx_u32(&x705, &x706, x7, (arg2[3])); + fiat_sm2_scalar_mulx_u32(&x707, &x708, x7, (arg2[2])); + fiat_sm2_scalar_mulx_u32(&x709, &x710, x7, (arg2[1])); + fiat_sm2_scalar_mulx_u32(&x711, &x712, x7, (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x713, &x714, 0x0, x712, x709); + fiat_sm2_scalar_addcarryx_u32(&x715, &x716, x714, x710, x707); + fiat_sm2_scalar_addcarryx_u32(&x717, &x718, x716, x708, x705); + fiat_sm2_scalar_addcarryx_u32(&x719, &x720, x718, x706, x703); + fiat_sm2_scalar_addcarryx_u32(&x721, &x722, x720, x704, x701); + fiat_sm2_scalar_addcarryx_u32(&x723, &x724, x722, x702, x699); + fiat_sm2_scalar_addcarryx_u32(&x725, &x726, x724, x700, x697); + x727 = (x726 + x698); + fiat_sm2_scalar_addcarryx_u32(&x728, &x729, 0x0, x680, x711); + fiat_sm2_scalar_addcarryx_u32(&x730, &x731, x729, x682, x713); + fiat_sm2_scalar_addcarryx_u32(&x732, &x733, x731, x684, x715); + fiat_sm2_scalar_addcarryx_u32(&x734, &x735, x733, x686, x717); + fiat_sm2_scalar_addcarryx_u32(&x736, &x737, x735, x688, x719); + fiat_sm2_scalar_addcarryx_u32(&x738, &x739, x737, x690, x721); + fiat_sm2_scalar_addcarryx_u32(&x740, &x741, x739, x692, x723); + fiat_sm2_scalar_addcarryx_u32(&x742, &x743, x741, x694, x725); + fiat_sm2_scalar_addcarryx_u32(&x744, &x745, x743, x696, x727); + fiat_sm2_scalar_mulx_u32(&x746, &x747, x728, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x748, &x749, x746, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x750, &x751, x746, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x752, &x753, x746, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x754, &x755, x746, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x756, &x757, x746, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x758, &x759, x746, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x760, &x761, x746, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x762, &x763, x746, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x764, &x765, 0x0, x763, x760); + fiat_sm2_scalar_addcarryx_u32(&x766, &x767, x765, x761, x758); + fiat_sm2_scalar_addcarryx_u32(&x768, &x769, x767, x759, x756); + fiat_sm2_scalar_addcarryx_u32(&x770, &x771, x769, x757, x754); + fiat_sm2_scalar_addcarryx_u32(&x772, &x773, x771, x755, x752); + fiat_sm2_scalar_addcarryx_u32(&x774, &x775, x773, x753, x750); + fiat_sm2_scalar_addcarryx_u32(&x776, &x777, x775, x751, x748); + x778 = (x777 + x749); + fiat_sm2_scalar_addcarryx_u32(&x779, &x780, 0x0, x728, x762); + fiat_sm2_scalar_addcarryx_u32(&x781, &x782, x780, x730, x764); + fiat_sm2_scalar_addcarryx_u32(&x783, &x784, x782, x732, x766); + fiat_sm2_scalar_addcarryx_u32(&x785, &x786, x784, x734, x768); + fiat_sm2_scalar_addcarryx_u32(&x787, &x788, x786, x736, x770); + fiat_sm2_scalar_addcarryx_u32(&x789, &x790, x788, x738, x772); + fiat_sm2_scalar_addcarryx_u32(&x791, &x792, x790, x740, x774); + fiat_sm2_scalar_addcarryx_u32(&x793, &x794, x792, x742, x776); + fiat_sm2_scalar_addcarryx_u32(&x795, &x796, x794, x744, x778); + x797 = ((uint32_t)x796 + x745); + fiat_sm2_scalar_subborrowx_u32(&x798, &x799, 0x0, x781, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x800, &x801, x799, x783, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x802, &x803, x801, x785, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x804, &x805, x803, x787, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x806, &x807, x805, x789, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x808, &x809, x807, x791, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x810, &x811, x809, x793, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x812, &x813, x811, x795, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_subborrowx_u32(&x814, &x815, x813, x797, 0x0); + fiat_sm2_scalar_cmovznz_u32(&x816, x815, x798, x781); + fiat_sm2_scalar_cmovznz_u32(&x817, x815, x800, x783); + fiat_sm2_scalar_cmovznz_u32(&x818, x815, x802, x785); + fiat_sm2_scalar_cmovznz_u32(&x819, x815, x804, x787); + fiat_sm2_scalar_cmovznz_u32(&x820, x815, x806, x789); + fiat_sm2_scalar_cmovznz_u32(&x821, x815, x808, x791); + fiat_sm2_scalar_cmovznz_u32(&x822, x815, x810, x793); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_square(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_scalar_uint1 x26; + uint32_t x27; + fiat_sm2_scalar_uint1 x28; + uint32_t x29; + fiat_sm2_scalar_uint1 x30; + uint32_t x31; + fiat_sm2_scalar_uint1 x32; + uint32_t x33; + fiat_sm2_scalar_uint1 x34; + uint32_t x35; + fiat_sm2_scalar_uint1 x36; + uint32_t x37; + fiat_sm2_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_sm2_scalar_uint1 x59; + uint32_t x60; + fiat_sm2_scalar_uint1 x61; + uint32_t x62; + fiat_sm2_scalar_uint1 x63; + uint32_t x64; + fiat_sm2_scalar_uint1 x65; + uint32_t x66; + fiat_sm2_scalar_uint1 x67; + uint32_t x68; + fiat_sm2_scalar_uint1 x69; + uint32_t x70; + fiat_sm2_scalar_uint1 x71; + uint32_t x72; + uint32_t x73; + fiat_sm2_scalar_uint1 x74; + uint32_t x75; + fiat_sm2_scalar_uint1 x76; + uint32_t x77; + fiat_sm2_scalar_uint1 x78; + uint32_t x79; + fiat_sm2_scalar_uint1 x80; + uint32_t x81; + fiat_sm2_scalar_uint1 x82; + uint32_t x83; + fiat_sm2_scalar_uint1 x84; + uint32_t x85; + fiat_sm2_scalar_uint1 x86; + uint32_t x87; + fiat_sm2_scalar_uint1 x88; + uint32_t x89; + fiat_sm2_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_sm2_scalar_uint1 x108; + uint32_t x109; + fiat_sm2_scalar_uint1 x110; + uint32_t x111; + fiat_sm2_scalar_uint1 x112; + uint32_t x113; + fiat_sm2_scalar_uint1 x114; + uint32_t x115; + fiat_sm2_scalar_uint1 x116; + uint32_t x117; + fiat_sm2_scalar_uint1 x118; + uint32_t x119; + fiat_sm2_scalar_uint1 x120; + uint32_t x121; + uint32_t x122; + fiat_sm2_scalar_uint1 x123; + uint32_t x124; + fiat_sm2_scalar_uint1 x125; + uint32_t x126; + fiat_sm2_scalar_uint1 x127; + uint32_t x128; + fiat_sm2_scalar_uint1 x129; + uint32_t x130; + fiat_sm2_scalar_uint1 x131; + uint32_t x132; + fiat_sm2_scalar_uint1 x133; + uint32_t x134; + fiat_sm2_scalar_uint1 x135; + uint32_t x136; + fiat_sm2_scalar_uint1 x137; + uint32_t x138; + fiat_sm2_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_sm2_scalar_uint1 x159; + uint32_t x160; + fiat_sm2_scalar_uint1 x161; + uint32_t x162; + fiat_sm2_scalar_uint1 x163; + uint32_t x164; + fiat_sm2_scalar_uint1 x165; + uint32_t x166; + fiat_sm2_scalar_uint1 x167; + uint32_t x168; + fiat_sm2_scalar_uint1 x169; + uint32_t x170; + fiat_sm2_scalar_uint1 x171; + uint32_t x172; + uint32_t x173; + fiat_sm2_scalar_uint1 x174; + uint32_t x175; + fiat_sm2_scalar_uint1 x176; + uint32_t x177; + fiat_sm2_scalar_uint1 x178; + uint32_t x179; + fiat_sm2_scalar_uint1 x180; + uint32_t x181; + fiat_sm2_scalar_uint1 x182; + uint32_t x183; + fiat_sm2_scalar_uint1 x184; + uint32_t x185; + fiat_sm2_scalar_uint1 x186; + uint32_t x187; + fiat_sm2_scalar_uint1 x188; + uint32_t x189; + fiat_sm2_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_sm2_scalar_uint1 x209; + uint32_t x210; + fiat_sm2_scalar_uint1 x211; + uint32_t x212; + fiat_sm2_scalar_uint1 x213; + uint32_t x214; + fiat_sm2_scalar_uint1 x215; + uint32_t x216; + fiat_sm2_scalar_uint1 x217; + uint32_t x218; + fiat_sm2_scalar_uint1 x219; + uint32_t x220; + fiat_sm2_scalar_uint1 x221; + uint32_t x222; + uint32_t x223; + fiat_sm2_scalar_uint1 x224; + uint32_t x225; + fiat_sm2_scalar_uint1 x226; + uint32_t x227; + fiat_sm2_scalar_uint1 x228; + uint32_t x229; + fiat_sm2_scalar_uint1 x230; + uint32_t x231; + fiat_sm2_scalar_uint1 x232; + uint32_t x233; + fiat_sm2_scalar_uint1 x234; + uint32_t x235; + fiat_sm2_scalar_uint1 x236; + uint32_t x237; + fiat_sm2_scalar_uint1 x238; + uint32_t x239; + fiat_sm2_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_sm2_scalar_uint1 x260; + uint32_t x261; + fiat_sm2_scalar_uint1 x262; + uint32_t x263; + fiat_sm2_scalar_uint1 x264; + uint32_t x265; + fiat_sm2_scalar_uint1 x266; + uint32_t x267; + fiat_sm2_scalar_uint1 x268; + uint32_t x269; + fiat_sm2_scalar_uint1 x270; + uint32_t x271; + fiat_sm2_scalar_uint1 x272; + uint32_t x273; + uint32_t x274; + fiat_sm2_scalar_uint1 x275; + uint32_t x276; + fiat_sm2_scalar_uint1 x277; + uint32_t x278; + fiat_sm2_scalar_uint1 x279; + uint32_t x280; + fiat_sm2_scalar_uint1 x281; + uint32_t x282; + fiat_sm2_scalar_uint1 x283; + uint32_t x284; + fiat_sm2_scalar_uint1 x285; + uint32_t x286; + fiat_sm2_scalar_uint1 x287; + uint32_t x288; + fiat_sm2_scalar_uint1 x289; + uint32_t x290; + fiat_sm2_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_sm2_scalar_uint1 x310; + uint32_t x311; + fiat_sm2_scalar_uint1 x312; + uint32_t x313; + fiat_sm2_scalar_uint1 x314; + uint32_t x315; + fiat_sm2_scalar_uint1 x316; + uint32_t x317; + fiat_sm2_scalar_uint1 x318; + uint32_t x319; + fiat_sm2_scalar_uint1 x320; + uint32_t x321; + fiat_sm2_scalar_uint1 x322; + uint32_t x323; + uint32_t x324; + fiat_sm2_scalar_uint1 x325; + uint32_t x326; + fiat_sm2_scalar_uint1 x327; + uint32_t x328; + fiat_sm2_scalar_uint1 x329; + uint32_t x330; + fiat_sm2_scalar_uint1 x331; + uint32_t x332; + fiat_sm2_scalar_uint1 x333; + uint32_t x334; + fiat_sm2_scalar_uint1 x335; + uint32_t x336; + fiat_sm2_scalar_uint1 x337; + uint32_t x338; + fiat_sm2_scalar_uint1 x339; + uint32_t x340; + fiat_sm2_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_sm2_scalar_uint1 x361; + uint32_t x362; + fiat_sm2_scalar_uint1 x363; + uint32_t x364; + fiat_sm2_scalar_uint1 x365; + uint32_t x366; + fiat_sm2_scalar_uint1 x367; + uint32_t x368; + fiat_sm2_scalar_uint1 x369; + uint32_t x370; + fiat_sm2_scalar_uint1 x371; + uint32_t x372; + fiat_sm2_scalar_uint1 x373; + uint32_t x374; + uint32_t x375; + fiat_sm2_scalar_uint1 x376; + uint32_t x377; + fiat_sm2_scalar_uint1 x378; + uint32_t x379; + fiat_sm2_scalar_uint1 x380; + uint32_t x381; + fiat_sm2_scalar_uint1 x382; + uint32_t x383; + fiat_sm2_scalar_uint1 x384; + uint32_t x385; + fiat_sm2_scalar_uint1 x386; + uint32_t x387; + fiat_sm2_scalar_uint1 x388; + uint32_t x389; + fiat_sm2_scalar_uint1 x390; + uint32_t x391; + fiat_sm2_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_sm2_scalar_uint1 x411; + uint32_t x412; + fiat_sm2_scalar_uint1 x413; + uint32_t x414; + fiat_sm2_scalar_uint1 x415; + uint32_t x416; + fiat_sm2_scalar_uint1 x417; + uint32_t x418; + fiat_sm2_scalar_uint1 x419; + uint32_t x420; + fiat_sm2_scalar_uint1 x421; + uint32_t x422; + fiat_sm2_scalar_uint1 x423; + uint32_t x424; + uint32_t x425; + fiat_sm2_scalar_uint1 x426; + uint32_t x427; + fiat_sm2_scalar_uint1 x428; + uint32_t x429; + fiat_sm2_scalar_uint1 x430; + uint32_t x431; + fiat_sm2_scalar_uint1 x432; + uint32_t x433; + fiat_sm2_scalar_uint1 x434; + uint32_t x435; + fiat_sm2_scalar_uint1 x436; + uint32_t x437; + fiat_sm2_scalar_uint1 x438; + uint32_t x439; + fiat_sm2_scalar_uint1 x440; + uint32_t x441; + fiat_sm2_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_sm2_scalar_uint1 x462; + uint32_t x463; + fiat_sm2_scalar_uint1 x464; + uint32_t x465; + fiat_sm2_scalar_uint1 x466; + uint32_t x467; + fiat_sm2_scalar_uint1 x468; + uint32_t x469; + fiat_sm2_scalar_uint1 x470; + uint32_t x471; + fiat_sm2_scalar_uint1 x472; + uint32_t x473; + fiat_sm2_scalar_uint1 x474; + uint32_t x475; + uint32_t x476; + fiat_sm2_scalar_uint1 x477; + uint32_t x478; + fiat_sm2_scalar_uint1 x479; + uint32_t x480; + fiat_sm2_scalar_uint1 x481; + uint32_t x482; + fiat_sm2_scalar_uint1 x483; + uint32_t x484; + fiat_sm2_scalar_uint1 x485; + uint32_t x486; + fiat_sm2_scalar_uint1 x487; + uint32_t x488; + fiat_sm2_scalar_uint1 x489; + uint32_t x490; + fiat_sm2_scalar_uint1 x491; + uint32_t x492; + fiat_sm2_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_sm2_scalar_uint1 x512; + uint32_t x513; + fiat_sm2_scalar_uint1 x514; + uint32_t x515; + fiat_sm2_scalar_uint1 x516; + uint32_t x517; + fiat_sm2_scalar_uint1 x518; + uint32_t x519; + fiat_sm2_scalar_uint1 x520; + uint32_t x521; + fiat_sm2_scalar_uint1 x522; + uint32_t x523; + fiat_sm2_scalar_uint1 x524; + uint32_t x525; + uint32_t x526; + fiat_sm2_scalar_uint1 x527; + uint32_t x528; + fiat_sm2_scalar_uint1 x529; + uint32_t x530; + fiat_sm2_scalar_uint1 x531; + uint32_t x532; + fiat_sm2_scalar_uint1 x533; + uint32_t x534; + fiat_sm2_scalar_uint1 x535; + uint32_t x536; + fiat_sm2_scalar_uint1 x537; + uint32_t x538; + fiat_sm2_scalar_uint1 x539; + uint32_t x540; + fiat_sm2_scalar_uint1 x541; + uint32_t x542; + fiat_sm2_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_sm2_scalar_uint1 x563; + uint32_t x564; + fiat_sm2_scalar_uint1 x565; + uint32_t x566; + fiat_sm2_scalar_uint1 x567; + uint32_t x568; + fiat_sm2_scalar_uint1 x569; + uint32_t x570; + fiat_sm2_scalar_uint1 x571; + uint32_t x572; + fiat_sm2_scalar_uint1 x573; + uint32_t x574; + fiat_sm2_scalar_uint1 x575; + uint32_t x576; + uint32_t x577; + fiat_sm2_scalar_uint1 x578; + uint32_t x579; + fiat_sm2_scalar_uint1 x580; + uint32_t x581; + fiat_sm2_scalar_uint1 x582; + uint32_t x583; + fiat_sm2_scalar_uint1 x584; + uint32_t x585; + fiat_sm2_scalar_uint1 x586; + uint32_t x587; + fiat_sm2_scalar_uint1 x588; + uint32_t x589; + fiat_sm2_scalar_uint1 x590; + uint32_t x591; + fiat_sm2_scalar_uint1 x592; + uint32_t x593; + fiat_sm2_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_sm2_scalar_uint1 x613; + uint32_t x614; + fiat_sm2_scalar_uint1 x615; + uint32_t x616; + fiat_sm2_scalar_uint1 x617; + uint32_t x618; + fiat_sm2_scalar_uint1 x619; + uint32_t x620; + fiat_sm2_scalar_uint1 x621; + uint32_t x622; + fiat_sm2_scalar_uint1 x623; + uint32_t x624; + fiat_sm2_scalar_uint1 x625; + uint32_t x626; + uint32_t x627; + fiat_sm2_scalar_uint1 x628; + uint32_t x629; + fiat_sm2_scalar_uint1 x630; + uint32_t x631; + fiat_sm2_scalar_uint1 x632; + uint32_t x633; + fiat_sm2_scalar_uint1 x634; + uint32_t x635; + fiat_sm2_scalar_uint1 x636; + uint32_t x637; + fiat_sm2_scalar_uint1 x638; + uint32_t x639; + fiat_sm2_scalar_uint1 x640; + uint32_t x641; + fiat_sm2_scalar_uint1 x642; + uint32_t x643; + fiat_sm2_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_sm2_scalar_uint1 x664; + uint32_t x665; + fiat_sm2_scalar_uint1 x666; + uint32_t x667; + fiat_sm2_scalar_uint1 x668; + uint32_t x669; + fiat_sm2_scalar_uint1 x670; + uint32_t x671; + fiat_sm2_scalar_uint1 x672; + uint32_t x673; + fiat_sm2_scalar_uint1 x674; + uint32_t x675; + fiat_sm2_scalar_uint1 x676; + uint32_t x677; + uint32_t x678; + fiat_sm2_scalar_uint1 x679; + uint32_t x680; + fiat_sm2_scalar_uint1 x681; + uint32_t x682; + fiat_sm2_scalar_uint1 x683; + uint32_t x684; + fiat_sm2_scalar_uint1 x685; + uint32_t x686; + fiat_sm2_scalar_uint1 x687; + uint32_t x688; + fiat_sm2_scalar_uint1 x689; + uint32_t x690; + fiat_sm2_scalar_uint1 x691; + uint32_t x692; + fiat_sm2_scalar_uint1 x693; + uint32_t x694; + fiat_sm2_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_sm2_scalar_uint1 x714; + uint32_t x715; + fiat_sm2_scalar_uint1 x716; + uint32_t x717; + fiat_sm2_scalar_uint1 x718; + uint32_t x719; + fiat_sm2_scalar_uint1 x720; + uint32_t x721; + fiat_sm2_scalar_uint1 x722; + uint32_t x723; + fiat_sm2_scalar_uint1 x724; + uint32_t x725; + fiat_sm2_scalar_uint1 x726; + uint32_t x727; + uint32_t x728; + fiat_sm2_scalar_uint1 x729; + uint32_t x730; + fiat_sm2_scalar_uint1 x731; + uint32_t x732; + fiat_sm2_scalar_uint1 x733; + uint32_t x734; + fiat_sm2_scalar_uint1 x735; + uint32_t x736; + fiat_sm2_scalar_uint1 x737; + uint32_t x738; + fiat_sm2_scalar_uint1 x739; + uint32_t x740; + fiat_sm2_scalar_uint1 x741; + uint32_t x742; + fiat_sm2_scalar_uint1 x743; + uint32_t x744; + fiat_sm2_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_sm2_scalar_uint1 x765; + uint32_t x766; + fiat_sm2_scalar_uint1 x767; + uint32_t x768; + fiat_sm2_scalar_uint1 x769; + uint32_t x770; + fiat_sm2_scalar_uint1 x771; + uint32_t x772; + fiat_sm2_scalar_uint1 x773; + uint32_t x774; + fiat_sm2_scalar_uint1 x775; + uint32_t x776; + fiat_sm2_scalar_uint1 x777; + uint32_t x778; + uint32_t x779; + fiat_sm2_scalar_uint1 x780; + uint32_t x781; + fiat_sm2_scalar_uint1 x782; + uint32_t x783; + fiat_sm2_scalar_uint1 x784; + uint32_t x785; + fiat_sm2_scalar_uint1 x786; + uint32_t x787; + fiat_sm2_scalar_uint1 x788; + uint32_t x789; + fiat_sm2_scalar_uint1 x790; + uint32_t x791; + fiat_sm2_scalar_uint1 x792; + uint32_t x793; + fiat_sm2_scalar_uint1 x794; + uint32_t x795; + fiat_sm2_scalar_uint1 x796; + uint32_t x797; + uint32_t x798; + fiat_sm2_scalar_uint1 x799; + uint32_t x800; + fiat_sm2_scalar_uint1 x801; + uint32_t x802; + fiat_sm2_scalar_uint1 x803; + uint32_t x804; + fiat_sm2_scalar_uint1 x805; + uint32_t x806; + fiat_sm2_scalar_uint1 x807; + uint32_t x808; + fiat_sm2_scalar_uint1 x809; + uint32_t x810; + fiat_sm2_scalar_uint1 x811; + uint32_t x812; + fiat_sm2_scalar_uint1 x813; + uint32_t x814; + fiat_sm2_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_sm2_scalar_mulx_u32(&x9, &x10, x8, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x11, &x12, x8, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x13, &x14, x8, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x15, &x16, x8, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x17, &x18, x8, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x19, &x20, x8, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x21, &x22, x8, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x23, &x24, x8, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_sm2_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_sm2_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_sm2_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_sm2_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_sm2_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_sm2_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + x39 = (x38 + x10); + fiat_sm2_scalar_mulx_u32(&x40, &x41, x23, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x42, &x43, x40, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x44, &x45, x40, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x46, &x47, x40, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x48, &x49, x40, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x50, &x51, x40, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x52, &x53, x40, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x54, &x55, x40, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x56, &x57, x40, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x58, &x59, 0x0, x57, x54); + fiat_sm2_scalar_addcarryx_u32(&x60, &x61, x59, x55, x52); + fiat_sm2_scalar_addcarryx_u32(&x62, &x63, x61, x53, x50); + fiat_sm2_scalar_addcarryx_u32(&x64, &x65, x63, x51, x48); + fiat_sm2_scalar_addcarryx_u32(&x66, &x67, x65, x49, x46); + fiat_sm2_scalar_addcarryx_u32(&x68, &x69, x67, x47, x44); + fiat_sm2_scalar_addcarryx_u32(&x70, &x71, x69, x45, x42); + x72 = (x71 + x43); + fiat_sm2_scalar_addcarryx_u32(&x73, &x74, 0x0, x23, x56); + fiat_sm2_scalar_addcarryx_u32(&x75, &x76, x74, x25, x58); + fiat_sm2_scalar_addcarryx_u32(&x77, &x78, x76, x27, x60); + fiat_sm2_scalar_addcarryx_u32(&x79, &x80, x78, x29, x62); + fiat_sm2_scalar_addcarryx_u32(&x81, &x82, x80, x31, x64); + fiat_sm2_scalar_addcarryx_u32(&x83, &x84, x82, x33, x66); + fiat_sm2_scalar_addcarryx_u32(&x85, &x86, x84, x35, x68); + fiat_sm2_scalar_addcarryx_u32(&x87, &x88, x86, x37, x70); + fiat_sm2_scalar_addcarryx_u32(&x89, &x90, x88, x39, x72); + fiat_sm2_scalar_mulx_u32(&x91, &x92, x1, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x93, &x94, x1, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x95, &x96, x1, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x97, &x98, x1, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x99, &x100, x1, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x101, &x102, x1, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x103, &x104, x1, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x105, &x106, x1, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x107, &x108, 0x0, x106, x103); + fiat_sm2_scalar_addcarryx_u32(&x109, &x110, x108, x104, x101); + fiat_sm2_scalar_addcarryx_u32(&x111, &x112, x110, x102, x99); + fiat_sm2_scalar_addcarryx_u32(&x113, &x114, x112, x100, x97); + fiat_sm2_scalar_addcarryx_u32(&x115, &x116, x114, x98, x95); + fiat_sm2_scalar_addcarryx_u32(&x117, &x118, x116, x96, x93); + fiat_sm2_scalar_addcarryx_u32(&x119, &x120, x118, x94, x91); + x121 = (x120 + x92); + fiat_sm2_scalar_addcarryx_u32(&x122, &x123, 0x0, x75, x105); + fiat_sm2_scalar_addcarryx_u32(&x124, &x125, x123, x77, x107); + fiat_sm2_scalar_addcarryx_u32(&x126, &x127, x125, x79, x109); + fiat_sm2_scalar_addcarryx_u32(&x128, &x129, x127, x81, x111); + fiat_sm2_scalar_addcarryx_u32(&x130, &x131, x129, x83, x113); + fiat_sm2_scalar_addcarryx_u32(&x132, &x133, x131, x85, x115); + fiat_sm2_scalar_addcarryx_u32(&x134, &x135, x133, x87, x117); + fiat_sm2_scalar_addcarryx_u32(&x136, &x137, x135, x89, x119); + fiat_sm2_scalar_addcarryx_u32(&x138, &x139, x137, x90, x121); + fiat_sm2_scalar_mulx_u32(&x140, &x141, x122, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x142, &x143, x140, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x144, &x145, x140, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x146, &x147, x140, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x148, &x149, x140, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x150, &x151, x140, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x152, &x153, x140, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x154, &x155, x140, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x156, &x157, x140, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x158, &x159, 0x0, x157, x154); + fiat_sm2_scalar_addcarryx_u32(&x160, &x161, x159, x155, x152); + fiat_sm2_scalar_addcarryx_u32(&x162, &x163, x161, x153, x150); + fiat_sm2_scalar_addcarryx_u32(&x164, &x165, x163, x151, x148); + fiat_sm2_scalar_addcarryx_u32(&x166, &x167, x165, x149, x146); + fiat_sm2_scalar_addcarryx_u32(&x168, &x169, x167, x147, x144); + fiat_sm2_scalar_addcarryx_u32(&x170, &x171, x169, x145, x142); + x172 = (x171 + x143); + fiat_sm2_scalar_addcarryx_u32(&x173, &x174, 0x0, x122, x156); + fiat_sm2_scalar_addcarryx_u32(&x175, &x176, x174, x124, x158); + fiat_sm2_scalar_addcarryx_u32(&x177, &x178, x176, x126, x160); + fiat_sm2_scalar_addcarryx_u32(&x179, &x180, x178, x128, x162); + fiat_sm2_scalar_addcarryx_u32(&x181, &x182, x180, x130, x164); + fiat_sm2_scalar_addcarryx_u32(&x183, &x184, x182, x132, x166); + fiat_sm2_scalar_addcarryx_u32(&x185, &x186, x184, x134, x168); + fiat_sm2_scalar_addcarryx_u32(&x187, &x188, x186, x136, x170); + fiat_sm2_scalar_addcarryx_u32(&x189, &x190, x188, x138, x172); + x191 = ((uint32_t)x190 + x139); + fiat_sm2_scalar_mulx_u32(&x192, &x193, x2, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x194, &x195, x2, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x196, &x197, x2, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x198, &x199, x2, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x200, &x201, x2, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x202, &x203, x2, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x204, &x205, x2, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x206, &x207, x2, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x208, &x209, 0x0, x207, x204); + fiat_sm2_scalar_addcarryx_u32(&x210, &x211, x209, x205, x202); + fiat_sm2_scalar_addcarryx_u32(&x212, &x213, x211, x203, x200); + fiat_sm2_scalar_addcarryx_u32(&x214, &x215, x213, x201, x198); + fiat_sm2_scalar_addcarryx_u32(&x216, &x217, x215, x199, x196); + fiat_sm2_scalar_addcarryx_u32(&x218, &x219, x217, x197, x194); + fiat_sm2_scalar_addcarryx_u32(&x220, &x221, x219, x195, x192); + x222 = (x221 + x193); + fiat_sm2_scalar_addcarryx_u32(&x223, &x224, 0x0, x175, x206); + fiat_sm2_scalar_addcarryx_u32(&x225, &x226, x224, x177, x208); + fiat_sm2_scalar_addcarryx_u32(&x227, &x228, x226, x179, x210); + fiat_sm2_scalar_addcarryx_u32(&x229, &x230, x228, x181, x212); + fiat_sm2_scalar_addcarryx_u32(&x231, &x232, x230, x183, x214); + fiat_sm2_scalar_addcarryx_u32(&x233, &x234, x232, x185, x216); + fiat_sm2_scalar_addcarryx_u32(&x235, &x236, x234, x187, x218); + fiat_sm2_scalar_addcarryx_u32(&x237, &x238, x236, x189, x220); + fiat_sm2_scalar_addcarryx_u32(&x239, &x240, x238, x191, x222); + fiat_sm2_scalar_mulx_u32(&x241, &x242, x223, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x243, &x244, x241, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x245, &x246, x241, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x247, &x248, x241, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x249, &x250, x241, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x251, &x252, x241, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x253, &x254, x241, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x255, &x256, x241, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x257, &x258, x241, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x259, &x260, 0x0, x258, x255); + fiat_sm2_scalar_addcarryx_u32(&x261, &x262, x260, x256, x253); + fiat_sm2_scalar_addcarryx_u32(&x263, &x264, x262, x254, x251); + fiat_sm2_scalar_addcarryx_u32(&x265, &x266, x264, x252, x249); + fiat_sm2_scalar_addcarryx_u32(&x267, &x268, x266, x250, x247); + fiat_sm2_scalar_addcarryx_u32(&x269, &x270, x268, x248, x245); + fiat_sm2_scalar_addcarryx_u32(&x271, &x272, x270, x246, x243); + x273 = (x272 + x244); + fiat_sm2_scalar_addcarryx_u32(&x274, &x275, 0x0, x223, x257); + fiat_sm2_scalar_addcarryx_u32(&x276, &x277, x275, x225, x259); + fiat_sm2_scalar_addcarryx_u32(&x278, &x279, x277, x227, x261); + fiat_sm2_scalar_addcarryx_u32(&x280, &x281, x279, x229, x263); + fiat_sm2_scalar_addcarryx_u32(&x282, &x283, x281, x231, x265); + fiat_sm2_scalar_addcarryx_u32(&x284, &x285, x283, x233, x267); + fiat_sm2_scalar_addcarryx_u32(&x286, &x287, x285, x235, x269); + fiat_sm2_scalar_addcarryx_u32(&x288, &x289, x287, x237, x271); + fiat_sm2_scalar_addcarryx_u32(&x290, &x291, x289, x239, x273); + x292 = ((uint32_t)x291 + x240); + fiat_sm2_scalar_mulx_u32(&x293, &x294, x3, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x295, &x296, x3, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x297, &x298, x3, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x299, &x300, x3, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x301, &x302, x3, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x303, &x304, x3, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x305, &x306, x3, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x307, &x308, x3, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x309, &x310, 0x0, x308, x305); + fiat_sm2_scalar_addcarryx_u32(&x311, &x312, x310, x306, x303); + fiat_sm2_scalar_addcarryx_u32(&x313, &x314, x312, x304, x301); + fiat_sm2_scalar_addcarryx_u32(&x315, &x316, x314, x302, x299); + fiat_sm2_scalar_addcarryx_u32(&x317, &x318, x316, x300, x297); + fiat_sm2_scalar_addcarryx_u32(&x319, &x320, x318, x298, x295); + fiat_sm2_scalar_addcarryx_u32(&x321, &x322, x320, x296, x293); + x323 = (x322 + x294); + fiat_sm2_scalar_addcarryx_u32(&x324, &x325, 0x0, x276, x307); + fiat_sm2_scalar_addcarryx_u32(&x326, &x327, x325, x278, x309); + fiat_sm2_scalar_addcarryx_u32(&x328, &x329, x327, x280, x311); + fiat_sm2_scalar_addcarryx_u32(&x330, &x331, x329, x282, x313); + fiat_sm2_scalar_addcarryx_u32(&x332, &x333, x331, x284, x315); + fiat_sm2_scalar_addcarryx_u32(&x334, &x335, x333, x286, x317); + fiat_sm2_scalar_addcarryx_u32(&x336, &x337, x335, x288, x319); + fiat_sm2_scalar_addcarryx_u32(&x338, &x339, x337, x290, x321); + fiat_sm2_scalar_addcarryx_u32(&x340, &x341, x339, x292, x323); + fiat_sm2_scalar_mulx_u32(&x342, &x343, x324, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x344, &x345, x342, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x346, &x347, x342, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x348, &x349, x342, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x350, &x351, x342, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x352, &x353, x342, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x354, &x355, x342, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x356, &x357, x342, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x358, &x359, x342, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x360, &x361, 0x0, x359, x356); + fiat_sm2_scalar_addcarryx_u32(&x362, &x363, x361, x357, x354); + fiat_sm2_scalar_addcarryx_u32(&x364, &x365, x363, x355, x352); + fiat_sm2_scalar_addcarryx_u32(&x366, &x367, x365, x353, x350); + fiat_sm2_scalar_addcarryx_u32(&x368, &x369, x367, x351, x348); + fiat_sm2_scalar_addcarryx_u32(&x370, &x371, x369, x349, x346); + fiat_sm2_scalar_addcarryx_u32(&x372, &x373, x371, x347, x344); + x374 = (x373 + x345); + fiat_sm2_scalar_addcarryx_u32(&x375, &x376, 0x0, x324, x358); + fiat_sm2_scalar_addcarryx_u32(&x377, &x378, x376, x326, x360); + fiat_sm2_scalar_addcarryx_u32(&x379, &x380, x378, x328, x362); + fiat_sm2_scalar_addcarryx_u32(&x381, &x382, x380, x330, x364); + fiat_sm2_scalar_addcarryx_u32(&x383, &x384, x382, x332, x366); + fiat_sm2_scalar_addcarryx_u32(&x385, &x386, x384, x334, x368); + fiat_sm2_scalar_addcarryx_u32(&x387, &x388, x386, x336, x370); + fiat_sm2_scalar_addcarryx_u32(&x389, &x390, x388, x338, x372); + fiat_sm2_scalar_addcarryx_u32(&x391, &x392, x390, x340, x374); + x393 = ((uint32_t)x392 + x341); + fiat_sm2_scalar_mulx_u32(&x394, &x395, x4, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x396, &x397, x4, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x398, &x399, x4, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x400, &x401, x4, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x402, &x403, x4, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x404, &x405, x4, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x406, &x407, x4, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x408, &x409, x4, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x410, &x411, 0x0, x409, x406); + fiat_sm2_scalar_addcarryx_u32(&x412, &x413, x411, x407, x404); + fiat_sm2_scalar_addcarryx_u32(&x414, &x415, x413, x405, x402); + fiat_sm2_scalar_addcarryx_u32(&x416, &x417, x415, x403, x400); + fiat_sm2_scalar_addcarryx_u32(&x418, &x419, x417, x401, x398); + fiat_sm2_scalar_addcarryx_u32(&x420, &x421, x419, x399, x396); + fiat_sm2_scalar_addcarryx_u32(&x422, &x423, x421, x397, x394); + x424 = (x423 + x395); + fiat_sm2_scalar_addcarryx_u32(&x425, &x426, 0x0, x377, x408); + fiat_sm2_scalar_addcarryx_u32(&x427, &x428, x426, x379, x410); + fiat_sm2_scalar_addcarryx_u32(&x429, &x430, x428, x381, x412); + fiat_sm2_scalar_addcarryx_u32(&x431, &x432, x430, x383, x414); + fiat_sm2_scalar_addcarryx_u32(&x433, &x434, x432, x385, x416); + fiat_sm2_scalar_addcarryx_u32(&x435, &x436, x434, x387, x418); + fiat_sm2_scalar_addcarryx_u32(&x437, &x438, x436, x389, x420); + fiat_sm2_scalar_addcarryx_u32(&x439, &x440, x438, x391, x422); + fiat_sm2_scalar_addcarryx_u32(&x441, &x442, x440, x393, x424); + fiat_sm2_scalar_mulx_u32(&x443, &x444, x425, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x445, &x446, x443, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x447, &x448, x443, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x449, &x450, x443, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x451, &x452, x443, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x453, &x454, x443, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x455, &x456, x443, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x457, &x458, x443, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x459, &x460, x443, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x461, &x462, 0x0, x460, x457); + fiat_sm2_scalar_addcarryx_u32(&x463, &x464, x462, x458, x455); + fiat_sm2_scalar_addcarryx_u32(&x465, &x466, x464, x456, x453); + fiat_sm2_scalar_addcarryx_u32(&x467, &x468, x466, x454, x451); + fiat_sm2_scalar_addcarryx_u32(&x469, &x470, x468, x452, x449); + fiat_sm2_scalar_addcarryx_u32(&x471, &x472, x470, x450, x447); + fiat_sm2_scalar_addcarryx_u32(&x473, &x474, x472, x448, x445); + x475 = (x474 + x446); + fiat_sm2_scalar_addcarryx_u32(&x476, &x477, 0x0, x425, x459); + fiat_sm2_scalar_addcarryx_u32(&x478, &x479, x477, x427, x461); + fiat_sm2_scalar_addcarryx_u32(&x480, &x481, x479, x429, x463); + fiat_sm2_scalar_addcarryx_u32(&x482, &x483, x481, x431, x465); + fiat_sm2_scalar_addcarryx_u32(&x484, &x485, x483, x433, x467); + fiat_sm2_scalar_addcarryx_u32(&x486, &x487, x485, x435, x469); + fiat_sm2_scalar_addcarryx_u32(&x488, &x489, x487, x437, x471); + fiat_sm2_scalar_addcarryx_u32(&x490, &x491, x489, x439, x473); + fiat_sm2_scalar_addcarryx_u32(&x492, &x493, x491, x441, x475); + x494 = ((uint32_t)x493 + x442); + fiat_sm2_scalar_mulx_u32(&x495, &x496, x5, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x497, &x498, x5, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x499, &x500, x5, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x501, &x502, x5, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x503, &x504, x5, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x505, &x506, x5, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x507, &x508, x5, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x509, &x510, x5, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x511, &x512, 0x0, x510, x507); + fiat_sm2_scalar_addcarryx_u32(&x513, &x514, x512, x508, x505); + fiat_sm2_scalar_addcarryx_u32(&x515, &x516, x514, x506, x503); + fiat_sm2_scalar_addcarryx_u32(&x517, &x518, x516, x504, x501); + fiat_sm2_scalar_addcarryx_u32(&x519, &x520, x518, x502, x499); + fiat_sm2_scalar_addcarryx_u32(&x521, &x522, x520, x500, x497); + fiat_sm2_scalar_addcarryx_u32(&x523, &x524, x522, x498, x495); + x525 = (x524 + x496); + fiat_sm2_scalar_addcarryx_u32(&x526, &x527, 0x0, x478, x509); + fiat_sm2_scalar_addcarryx_u32(&x528, &x529, x527, x480, x511); + fiat_sm2_scalar_addcarryx_u32(&x530, &x531, x529, x482, x513); + fiat_sm2_scalar_addcarryx_u32(&x532, &x533, x531, x484, x515); + fiat_sm2_scalar_addcarryx_u32(&x534, &x535, x533, x486, x517); + fiat_sm2_scalar_addcarryx_u32(&x536, &x537, x535, x488, x519); + fiat_sm2_scalar_addcarryx_u32(&x538, &x539, x537, x490, x521); + fiat_sm2_scalar_addcarryx_u32(&x540, &x541, x539, x492, x523); + fiat_sm2_scalar_addcarryx_u32(&x542, &x543, x541, x494, x525); + fiat_sm2_scalar_mulx_u32(&x544, &x545, x526, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x546, &x547, x544, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x548, &x549, x544, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x550, &x551, x544, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x552, &x553, x544, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x554, &x555, x544, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x556, &x557, x544, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x558, &x559, x544, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x560, &x561, x544, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x562, &x563, 0x0, x561, x558); + fiat_sm2_scalar_addcarryx_u32(&x564, &x565, x563, x559, x556); + fiat_sm2_scalar_addcarryx_u32(&x566, &x567, x565, x557, x554); + fiat_sm2_scalar_addcarryx_u32(&x568, &x569, x567, x555, x552); + fiat_sm2_scalar_addcarryx_u32(&x570, &x571, x569, x553, x550); + fiat_sm2_scalar_addcarryx_u32(&x572, &x573, x571, x551, x548); + fiat_sm2_scalar_addcarryx_u32(&x574, &x575, x573, x549, x546); + x576 = (x575 + x547); + fiat_sm2_scalar_addcarryx_u32(&x577, &x578, 0x0, x526, x560); + fiat_sm2_scalar_addcarryx_u32(&x579, &x580, x578, x528, x562); + fiat_sm2_scalar_addcarryx_u32(&x581, &x582, x580, x530, x564); + fiat_sm2_scalar_addcarryx_u32(&x583, &x584, x582, x532, x566); + fiat_sm2_scalar_addcarryx_u32(&x585, &x586, x584, x534, x568); + fiat_sm2_scalar_addcarryx_u32(&x587, &x588, x586, x536, x570); + fiat_sm2_scalar_addcarryx_u32(&x589, &x590, x588, x538, x572); + fiat_sm2_scalar_addcarryx_u32(&x591, &x592, x590, x540, x574); + fiat_sm2_scalar_addcarryx_u32(&x593, &x594, x592, x542, x576); + x595 = ((uint32_t)x594 + x543); + fiat_sm2_scalar_mulx_u32(&x596, &x597, x6, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x598, &x599, x6, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x600, &x601, x6, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x602, &x603, x6, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x604, &x605, x6, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x606, &x607, x6, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x608, &x609, x6, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x610, &x611, x6, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x612, &x613, 0x0, x611, x608); + fiat_sm2_scalar_addcarryx_u32(&x614, &x615, x613, x609, x606); + fiat_sm2_scalar_addcarryx_u32(&x616, &x617, x615, x607, x604); + fiat_sm2_scalar_addcarryx_u32(&x618, &x619, x617, x605, x602); + fiat_sm2_scalar_addcarryx_u32(&x620, &x621, x619, x603, x600); + fiat_sm2_scalar_addcarryx_u32(&x622, &x623, x621, x601, x598); + fiat_sm2_scalar_addcarryx_u32(&x624, &x625, x623, x599, x596); + x626 = (x625 + x597); + fiat_sm2_scalar_addcarryx_u32(&x627, &x628, 0x0, x579, x610); + fiat_sm2_scalar_addcarryx_u32(&x629, &x630, x628, x581, x612); + fiat_sm2_scalar_addcarryx_u32(&x631, &x632, x630, x583, x614); + fiat_sm2_scalar_addcarryx_u32(&x633, &x634, x632, x585, x616); + fiat_sm2_scalar_addcarryx_u32(&x635, &x636, x634, x587, x618); + fiat_sm2_scalar_addcarryx_u32(&x637, &x638, x636, x589, x620); + fiat_sm2_scalar_addcarryx_u32(&x639, &x640, x638, x591, x622); + fiat_sm2_scalar_addcarryx_u32(&x641, &x642, x640, x593, x624); + fiat_sm2_scalar_addcarryx_u32(&x643, &x644, x642, x595, x626); + fiat_sm2_scalar_mulx_u32(&x645, &x646, x627, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x647, &x648, x645, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x649, &x650, x645, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x651, &x652, x645, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x653, &x654, x645, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x655, &x656, x645, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x657, &x658, x645, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x659, &x660, x645, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x661, &x662, x645, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x663, &x664, 0x0, x662, x659); + fiat_sm2_scalar_addcarryx_u32(&x665, &x666, x664, x660, x657); + fiat_sm2_scalar_addcarryx_u32(&x667, &x668, x666, x658, x655); + fiat_sm2_scalar_addcarryx_u32(&x669, &x670, x668, x656, x653); + fiat_sm2_scalar_addcarryx_u32(&x671, &x672, x670, x654, x651); + fiat_sm2_scalar_addcarryx_u32(&x673, &x674, x672, x652, x649); + fiat_sm2_scalar_addcarryx_u32(&x675, &x676, x674, x650, x647); + x677 = (x676 + x648); + fiat_sm2_scalar_addcarryx_u32(&x678, &x679, 0x0, x627, x661); + fiat_sm2_scalar_addcarryx_u32(&x680, &x681, x679, x629, x663); + fiat_sm2_scalar_addcarryx_u32(&x682, &x683, x681, x631, x665); + fiat_sm2_scalar_addcarryx_u32(&x684, &x685, x683, x633, x667); + fiat_sm2_scalar_addcarryx_u32(&x686, &x687, x685, x635, x669); + fiat_sm2_scalar_addcarryx_u32(&x688, &x689, x687, x637, x671); + fiat_sm2_scalar_addcarryx_u32(&x690, &x691, x689, x639, x673); + fiat_sm2_scalar_addcarryx_u32(&x692, &x693, x691, x641, x675); + fiat_sm2_scalar_addcarryx_u32(&x694, &x695, x693, x643, x677); + x696 = ((uint32_t)x695 + x644); + fiat_sm2_scalar_mulx_u32(&x697, &x698, x7, (arg1[7])); + fiat_sm2_scalar_mulx_u32(&x699, &x700, x7, (arg1[6])); + fiat_sm2_scalar_mulx_u32(&x701, &x702, x7, (arg1[5])); + fiat_sm2_scalar_mulx_u32(&x703, &x704, x7, (arg1[4])); + fiat_sm2_scalar_mulx_u32(&x705, &x706, x7, (arg1[3])); + fiat_sm2_scalar_mulx_u32(&x707, &x708, x7, (arg1[2])); + fiat_sm2_scalar_mulx_u32(&x709, &x710, x7, (arg1[1])); + fiat_sm2_scalar_mulx_u32(&x711, &x712, x7, (arg1[0])); + fiat_sm2_scalar_addcarryx_u32(&x713, &x714, 0x0, x712, x709); + fiat_sm2_scalar_addcarryx_u32(&x715, &x716, x714, x710, x707); + fiat_sm2_scalar_addcarryx_u32(&x717, &x718, x716, x708, x705); + fiat_sm2_scalar_addcarryx_u32(&x719, &x720, x718, x706, x703); + fiat_sm2_scalar_addcarryx_u32(&x721, &x722, x720, x704, x701); + fiat_sm2_scalar_addcarryx_u32(&x723, &x724, x722, x702, x699); + fiat_sm2_scalar_addcarryx_u32(&x725, &x726, x724, x700, x697); + x727 = (x726 + x698); + fiat_sm2_scalar_addcarryx_u32(&x728, &x729, 0x0, x680, x711); + fiat_sm2_scalar_addcarryx_u32(&x730, &x731, x729, x682, x713); + fiat_sm2_scalar_addcarryx_u32(&x732, &x733, x731, x684, x715); + fiat_sm2_scalar_addcarryx_u32(&x734, &x735, x733, x686, x717); + fiat_sm2_scalar_addcarryx_u32(&x736, &x737, x735, x688, x719); + fiat_sm2_scalar_addcarryx_u32(&x738, &x739, x737, x690, x721); + fiat_sm2_scalar_addcarryx_u32(&x740, &x741, x739, x692, x723); + fiat_sm2_scalar_addcarryx_u32(&x742, &x743, x741, x694, x725); + fiat_sm2_scalar_addcarryx_u32(&x744, &x745, x743, x696, x727); + fiat_sm2_scalar_mulx_u32(&x746, &x747, x728, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x748, &x749, x746, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x750, &x751, x746, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x752, &x753, x746, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x754, &x755, x746, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x756, &x757, x746, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x758, &x759, x746, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x760, &x761, x746, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x762, &x763, x746, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x764, &x765, 0x0, x763, x760); + fiat_sm2_scalar_addcarryx_u32(&x766, &x767, x765, x761, x758); + fiat_sm2_scalar_addcarryx_u32(&x768, &x769, x767, x759, x756); + fiat_sm2_scalar_addcarryx_u32(&x770, &x771, x769, x757, x754); + fiat_sm2_scalar_addcarryx_u32(&x772, &x773, x771, x755, x752); + fiat_sm2_scalar_addcarryx_u32(&x774, &x775, x773, x753, x750); + fiat_sm2_scalar_addcarryx_u32(&x776, &x777, x775, x751, x748); + x778 = (x777 + x749); + fiat_sm2_scalar_addcarryx_u32(&x779, &x780, 0x0, x728, x762); + fiat_sm2_scalar_addcarryx_u32(&x781, &x782, x780, x730, x764); + fiat_sm2_scalar_addcarryx_u32(&x783, &x784, x782, x732, x766); + fiat_sm2_scalar_addcarryx_u32(&x785, &x786, x784, x734, x768); + fiat_sm2_scalar_addcarryx_u32(&x787, &x788, x786, x736, x770); + fiat_sm2_scalar_addcarryx_u32(&x789, &x790, x788, x738, x772); + fiat_sm2_scalar_addcarryx_u32(&x791, &x792, x790, x740, x774); + fiat_sm2_scalar_addcarryx_u32(&x793, &x794, x792, x742, x776); + fiat_sm2_scalar_addcarryx_u32(&x795, &x796, x794, x744, x778); + x797 = ((uint32_t)x796 + x745); + fiat_sm2_scalar_subborrowx_u32(&x798, &x799, 0x0, x781, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x800, &x801, x799, x783, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x802, &x803, x801, x785, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x804, &x805, x803, x787, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x806, &x807, x805, x789, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x808, &x809, x807, x791, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x810, &x811, x809, x793, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x812, &x813, x811, x795, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_subborrowx_u32(&x814, &x815, x813, x797, 0x0); + fiat_sm2_scalar_cmovznz_u32(&x816, x815, x798, x781); + fiat_sm2_scalar_cmovznz_u32(&x817, x815, x800, x783); + fiat_sm2_scalar_cmovznz_u32(&x818, x815, x802, x785); + fiat_sm2_scalar_cmovznz_u32(&x819, x815, x804, x787); + fiat_sm2_scalar_cmovznz_u32(&x820, x815, x806, x789); + fiat_sm2_scalar_cmovznz_u32(&x821, x815, x808, x791); + fiat_sm2_scalar_cmovznz_u32(&x822, x815, x810, x793); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_add(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1, const fiat_sm2_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_sm2_scalar_uint1 x2; + uint32_t x3; + fiat_sm2_scalar_uint1 x4; + uint32_t x5; + fiat_sm2_scalar_uint1 x6; + uint32_t x7; + fiat_sm2_scalar_uint1 x8; + uint32_t x9; + fiat_sm2_scalar_uint1 x10; + uint32_t x11; + fiat_sm2_scalar_uint1 x12; + uint32_t x13; + fiat_sm2_scalar_uint1 x14; + uint32_t x15; + fiat_sm2_scalar_uint1 x16; + uint32_t x17; + fiat_sm2_scalar_uint1 x18; + uint32_t x19; + fiat_sm2_scalar_uint1 x20; + uint32_t x21; + fiat_sm2_scalar_uint1 x22; + uint32_t x23; + fiat_sm2_scalar_uint1 x24; + uint32_t x25; + fiat_sm2_scalar_uint1 x26; + uint32_t x27; + fiat_sm2_scalar_uint1 x28; + uint32_t x29; + fiat_sm2_scalar_uint1 x30; + uint32_t x31; + fiat_sm2_scalar_uint1 x32; + uint32_t x33; + fiat_sm2_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_sm2_scalar_addcarryx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_scalar_addcarryx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_scalar_addcarryx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_scalar_addcarryx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_scalar_addcarryx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_sm2_scalar_addcarryx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_sm2_scalar_addcarryx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_sm2_scalar_addcarryx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_sm2_scalar_subborrowx_u32(&x17, &x18, 0x0, x1, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x19, &x20, x18, x3, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x21, &x22, x20, x5, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x23, &x24, x22, x7, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x25, &x26, x24, x9, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x27, &x28, x26, x11, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x29, &x30, x28, x13, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x31, &x32, x30, x15, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_subborrowx_u32(&x33, &x34, x32, x16, 0x0); + fiat_sm2_scalar_cmovznz_u32(&x35, x34, x17, x1); + fiat_sm2_scalar_cmovznz_u32(&x36, x34, x19, x3); + fiat_sm2_scalar_cmovznz_u32(&x37, x34, x21, x5); + fiat_sm2_scalar_cmovznz_u32(&x38, x34, x23, x7); + fiat_sm2_scalar_cmovznz_u32(&x39, x34, x25, x9); + fiat_sm2_scalar_cmovznz_u32(&x40, x34, x27, x11); + fiat_sm2_scalar_cmovznz_u32(&x41, x34, x29, x13); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_sub(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1, const fiat_sm2_scalar_montgomery_domain_field_element arg2) { + uint32_t x1; + fiat_sm2_scalar_uint1 x2; + uint32_t x3; + fiat_sm2_scalar_uint1 x4; + uint32_t x5; + fiat_sm2_scalar_uint1 x6; + uint32_t x7; + fiat_sm2_scalar_uint1 x8; + uint32_t x9; + fiat_sm2_scalar_uint1 x10; + uint32_t x11; + fiat_sm2_scalar_uint1 x12; + uint32_t x13; + fiat_sm2_scalar_uint1 x14; + uint32_t x15; + fiat_sm2_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_sm2_scalar_uint1 x19; + uint32_t x20; + fiat_sm2_scalar_uint1 x21; + uint32_t x22; + fiat_sm2_scalar_uint1 x23; + uint32_t x24; + fiat_sm2_scalar_uint1 x25; + uint32_t x26; + fiat_sm2_scalar_uint1 x27; + uint32_t x28; + fiat_sm2_scalar_uint1 x29; + uint32_t x30; + fiat_sm2_scalar_uint1 x31; + uint32_t x32; + fiat_sm2_scalar_uint1 x33; + fiat_sm2_scalar_subborrowx_u32(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_scalar_subborrowx_u32(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_scalar_subborrowx_u32(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_scalar_subborrowx_u32(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_scalar_subborrowx_u32(&x9, &x10, x8, (arg1[4]), (arg2[4])); + fiat_sm2_scalar_subborrowx_u32(&x11, &x12, x10, (arg1[5]), (arg2[5])); + fiat_sm2_scalar_subborrowx_u32(&x13, &x14, x12, (arg1[6]), (arg2[6])); + fiat_sm2_scalar_subborrowx_u32(&x15, &x16, x14, (arg1[7]), (arg2[7])); + fiat_sm2_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_sm2_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0x39d54123))); + fiat_sm2_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0x53bbf409))); + fiat_sm2_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0x21c6052b))); + fiat_sm2_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0x7203df6b))); + fiat_sm2_scalar_addcarryx_u32(&x26, &x27, x25, x9, x17); + fiat_sm2_scalar_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_sm2_scalar_addcarryx_u32(&x30, &x31, x29, x13, x17); + fiat_sm2_scalar_addcarryx_u32(&x32, &x33, x31, x15, (x17 & UINT32_C(0xfffffffe))); + 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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_opp(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1) { + uint32_t x1; + fiat_sm2_scalar_uint1 x2; + uint32_t x3; + fiat_sm2_scalar_uint1 x4; + uint32_t x5; + fiat_sm2_scalar_uint1 x6; + uint32_t x7; + fiat_sm2_scalar_uint1 x8; + uint32_t x9; + fiat_sm2_scalar_uint1 x10; + uint32_t x11; + fiat_sm2_scalar_uint1 x12; + uint32_t x13; + fiat_sm2_scalar_uint1 x14; + uint32_t x15; + fiat_sm2_scalar_uint1 x16; + uint32_t x17; + uint32_t x18; + fiat_sm2_scalar_uint1 x19; + uint32_t x20; + fiat_sm2_scalar_uint1 x21; + uint32_t x22; + fiat_sm2_scalar_uint1 x23; + uint32_t x24; + fiat_sm2_scalar_uint1 x25; + uint32_t x26; + fiat_sm2_scalar_uint1 x27; + uint32_t x28; + fiat_sm2_scalar_uint1 x29; + uint32_t x30; + fiat_sm2_scalar_uint1 x31; + uint32_t x32; + fiat_sm2_scalar_uint1 x33; + fiat_sm2_scalar_subborrowx_u32(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_sm2_scalar_subborrowx_u32(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_sm2_scalar_subborrowx_u32(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_sm2_scalar_subborrowx_u32(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_sm2_scalar_subborrowx_u32(&x9, &x10, x8, 0x0, (arg1[4])); + fiat_sm2_scalar_subborrowx_u32(&x11, &x12, x10, 0x0, (arg1[5])); + fiat_sm2_scalar_subborrowx_u32(&x13, &x14, x12, 0x0, (arg1[6])); + fiat_sm2_scalar_subborrowx_u32(&x15, &x16, x14, 0x0, (arg1[7])); + fiat_sm2_scalar_cmovznz_u32(&x17, x16, 0x0, UINT32_C(0xffffffff)); + fiat_sm2_scalar_addcarryx_u32(&x18, &x19, 0x0, x1, (x17 & UINT32_C(0x39d54123))); + fiat_sm2_scalar_addcarryx_u32(&x20, &x21, x19, x3, (x17 & UINT32_C(0x53bbf409))); + fiat_sm2_scalar_addcarryx_u32(&x22, &x23, x21, x5, (x17 & UINT32_C(0x21c6052b))); + fiat_sm2_scalar_addcarryx_u32(&x24, &x25, x23, x7, (x17 & UINT32_C(0x7203df6b))); + fiat_sm2_scalar_addcarryx_u32(&x26, &x27, x25, x9, x17); + fiat_sm2_scalar_addcarryx_u32(&x28, &x29, x27, x11, x17); + fiat_sm2_scalar_addcarryx_u32(&x30, &x31, x29, x13, x17); + fiat_sm2_scalar_addcarryx_u32(&x32, &x33, x31, x15, (x17 & UINT32_C(0xfffffffe))); + 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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_from_montgomery(fiat_sm2_scalar_non_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_scalar_uint1 x21; + uint32_t x22; + fiat_sm2_scalar_uint1 x23; + uint32_t x24; + fiat_sm2_scalar_uint1 x25; + uint32_t x26; + fiat_sm2_scalar_uint1 x27; + uint32_t x28; + fiat_sm2_scalar_uint1 x29; + uint32_t x30; + fiat_sm2_scalar_uint1 x31; + uint32_t x32; + fiat_sm2_scalar_uint1 x33; + uint32_t x34; + fiat_sm2_scalar_uint1 x35; + uint32_t x36; + fiat_sm2_scalar_uint1 x37; + uint32_t x38; + fiat_sm2_scalar_uint1 x39; + uint32_t x40; + fiat_sm2_scalar_uint1 x41; + uint32_t x42; + fiat_sm2_scalar_uint1 x43; + uint32_t x44; + fiat_sm2_scalar_uint1 x45; + uint32_t x46; + fiat_sm2_scalar_uint1 x47; + uint32_t x48; + fiat_sm2_scalar_uint1 x49; + uint32_t x50; + fiat_sm2_scalar_uint1 x51; + uint32_t x52; + fiat_sm2_scalar_uint1 x53; + uint32_t x54; + fiat_sm2_scalar_uint1 x55; + uint32_t x56; + fiat_sm2_scalar_uint1 x57; + uint32_t x58; + fiat_sm2_scalar_uint1 x59; + uint32_t x60; + fiat_sm2_scalar_uint1 x61; + uint32_t x62; + fiat_sm2_scalar_uint1 x63; + uint32_t x64; + fiat_sm2_scalar_uint1 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; + fiat_sm2_scalar_uint1 x85; + uint32_t x86; + fiat_sm2_scalar_uint1 x87; + uint32_t x88; + fiat_sm2_scalar_uint1 x89; + uint32_t x90; + fiat_sm2_scalar_uint1 x91; + uint32_t x92; + fiat_sm2_scalar_uint1 x93; + uint32_t x94; + fiat_sm2_scalar_uint1 x95; + uint32_t x96; + fiat_sm2_scalar_uint1 x97; + uint32_t x98; + fiat_sm2_scalar_uint1 x99; + uint32_t x100; + fiat_sm2_scalar_uint1 x101; + uint32_t x102; + fiat_sm2_scalar_uint1 x103; + uint32_t x104; + fiat_sm2_scalar_uint1 x105; + uint32_t x106; + fiat_sm2_scalar_uint1 x107; + uint32_t x108; + fiat_sm2_scalar_uint1 x109; + uint32_t x110; + fiat_sm2_scalar_uint1 x111; + uint32_t x112; + fiat_sm2_scalar_uint1 x113; + uint32_t x114; + fiat_sm2_scalar_uint1 x115; + uint32_t x116; + fiat_sm2_scalar_uint1 x117; + uint32_t x118; + fiat_sm2_scalar_uint1 x119; + uint32_t x120; + fiat_sm2_scalar_uint1 x121; + uint32_t x122; + fiat_sm2_scalar_uint1 x123; + uint32_t x124; + fiat_sm2_scalar_uint1 x125; + uint32_t x126; + fiat_sm2_scalar_uint1 x127; + uint32_t x128; + fiat_sm2_scalar_uint1 x129; + uint32_t x130; + fiat_sm2_scalar_uint1 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; + uint32_t x146; + uint32_t x147; + uint32_t x148; + uint32_t x149; + uint32_t x150; + fiat_sm2_scalar_uint1 x151; + uint32_t x152; + fiat_sm2_scalar_uint1 x153; + uint32_t x154; + fiat_sm2_scalar_uint1 x155; + uint32_t x156; + fiat_sm2_scalar_uint1 x157; + uint32_t x158; + fiat_sm2_scalar_uint1 x159; + uint32_t x160; + fiat_sm2_scalar_uint1 x161; + uint32_t x162; + fiat_sm2_scalar_uint1 x163; + uint32_t x164; + fiat_sm2_scalar_uint1 x165; + uint32_t x166; + fiat_sm2_scalar_uint1 x167; + uint32_t x168; + fiat_sm2_scalar_uint1 x169; + uint32_t x170; + fiat_sm2_scalar_uint1 x171; + uint32_t x172; + fiat_sm2_scalar_uint1 x173; + uint32_t x174; + fiat_sm2_scalar_uint1 x175; + uint32_t x176; + fiat_sm2_scalar_uint1 x177; + uint32_t x178; + fiat_sm2_scalar_uint1 x179; + uint32_t x180; + fiat_sm2_scalar_uint1 x181; + uint32_t x182; + fiat_sm2_scalar_uint1 x183; + uint32_t x184; + fiat_sm2_scalar_uint1 x185; + uint32_t x186; + fiat_sm2_scalar_uint1 x187; + uint32_t x188; + fiat_sm2_scalar_uint1 x189; + uint32_t x190; + fiat_sm2_scalar_uint1 x191; + uint32_t x192; + fiat_sm2_scalar_uint1 x193; + uint32_t x194; + fiat_sm2_scalar_uint1 x195; + uint32_t x196; + fiat_sm2_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; + fiat_sm2_scalar_uint1 x217; + uint32_t x218; + fiat_sm2_scalar_uint1 x219; + uint32_t x220; + fiat_sm2_scalar_uint1 x221; + uint32_t x222; + fiat_sm2_scalar_uint1 x223; + uint32_t x224; + fiat_sm2_scalar_uint1 x225; + uint32_t x226; + fiat_sm2_scalar_uint1 x227; + uint32_t x228; + fiat_sm2_scalar_uint1 x229; + uint32_t x230; + fiat_sm2_scalar_uint1 x231; + uint32_t x232; + fiat_sm2_scalar_uint1 x233; + uint32_t x234; + fiat_sm2_scalar_uint1 x235; + uint32_t x236; + fiat_sm2_scalar_uint1 x237; + uint32_t x238; + fiat_sm2_scalar_uint1 x239; + uint32_t x240; + fiat_sm2_scalar_uint1 x241; + uint32_t x242; + fiat_sm2_scalar_uint1 x243; + uint32_t x244; + fiat_sm2_scalar_uint1 x245; + uint32_t x246; + fiat_sm2_scalar_uint1 x247; + uint32_t x248; + fiat_sm2_scalar_uint1 x249; + uint32_t x250; + fiat_sm2_scalar_uint1 x251; + uint32_t x252; + fiat_sm2_scalar_uint1 x253; + uint32_t x254; + fiat_sm2_scalar_uint1 x255; + uint32_t x256; + fiat_sm2_scalar_uint1 x257; + uint32_t x258; + fiat_sm2_scalar_uint1 x259; + uint32_t x260; + fiat_sm2_scalar_uint1 x261; + uint32_t x262; + fiat_sm2_scalar_uint1 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; + uint32_t x280; + uint32_t x281; + uint32_t x282; + fiat_sm2_scalar_uint1 x283; + uint32_t x284; + fiat_sm2_scalar_uint1 x285; + uint32_t x286; + fiat_sm2_scalar_uint1 x287; + uint32_t x288; + fiat_sm2_scalar_uint1 x289; + uint32_t x290; + fiat_sm2_scalar_uint1 x291; + uint32_t x292; + fiat_sm2_scalar_uint1 x293; + uint32_t x294; + fiat_sm2_scalar_uint1 x295; + uint32_t x296; + fiat_sm2_scalar_uint1 x297; + uint32_t x298; + fiat_sm2_scalar_uint1 x299; + uint32_t x300; + fiat_sm2_scalar_uint1 x301; + uint32_t x302; + fiat_sm2_scalar_uint1 x303; + uint32_t x304; + fiat_sm2_scalar_uint1 x305; + uint32_t x306; + fiat_sm2_scalar_uint1 x307; + uint32_t x308; + fiat_sm2_scalar_uint1 x309; + uint32_t x310; + fiat_sm2_scalar_uint1 x311; + uint32_t x312; + fiat_sm2_scalar_uint1 x313; + uint32_t x314; + fiat_sm2_scalar_uint1 x315; + uint32_t x316; + fiat_sm2_scalar_uint1 x317; + uint32_t x318; + fiat_sm2_scalar_uint1 x319; + uint32_t x320; + fiat_sm2_scalar_uint1 x321; + uint32_t x322; + fiat_sm2_scalar_uint1 x323; + uint32_t x324; + fiat_sm2_scalar_uint1 x325; + uint32_t x326; + fiat_sm2_scalar_uint1 x327; + uint32_t x328; + fiat_sm2_scalar_uint1 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; + uint32_t x346; + uint32_t x347; + uint32_t x348; + fiat_sm2_scalar_uint1 x349; + uint32_t x350; + fiat_sm2_scalar_uint1 x351; + uint32_t x352; + fiat_sm2_scalar_uint1 x353; + uint32_t x354; + fiat_sm2_scalar_uint1 x355; + uint32_t x356; + fiat_sm2_scalar_uint1 x357; + uint32_t x358; + fiat_sm2_scalar_uint1 x359; + uint32_t x360; + fiat_sm2_scalar_uint1 x361; + uint32_t x362; + fiat_sm2_scalar_uint1 x363; + uint32_t x364; + fiat_sm2_scalar_uint1 x365; + uint32_t x366; + fiat_sm2_scalar_uint1 x367; + uint32_t x368; + fiat_sm2_scalar_uint1 x369; + uint32_t x370; + fiat_sm2_scalar_uint1 x371; + uint32_t x372; + fiat_sm2_scalar_uint1 x373; + uint32_t x374; + fiat_sm2_scalar_uint1 x375; + uint32_t x376; + fiat_sm2_scalar_uint1 x377; + uint32_t x378; + fiat_sm2_scalar_uint1 x379; + uint32_t x380; + fiat_sm2_scalar_uint1 x381; + uint32_t x382; + fiat_sm2_scalar_uint1 x383; + uint32_t x384; + fiat_sm2_scalar_uint1 x385; + uint32_t x386; + fiat_sm2_scalar_uint1 x387; + uint32_t x388; + fiat_sm2_scalar_uint1 x389; + uint32_t x390; + fiat_sm2_scalar_uint1 x391; + uint32_t x392; + fiat_sm2_scalar_uint1 x393; + uint32_t x394; + fiat_sm2_scalar_uint1 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; + fiat_sm2_scalar_uint1 x415; + uint32_t x416; + fiat_sm2_scalar_uint1 x417; + uint32_t x418; + fiat_sm2_scalar_uint1 x419; + uint32_t x420; + fiat_sm2_scalar_uint1 x421; + uint32_t x422; + fiat_sm2_scalar_uint1 x423; + uint32_t x424; + fiat_sm2_scalar_uint1 x425; + uint32_t x426; + fiat_sm2_scalar_uint1 x427; + uint32_t x428; + fiat_sm2_scalar_uint1 x429; + uint32_t x430; + fiat_sm2_scalar_uint1 x431; + uint32_t x432; + fiat_sm2_scalar_uint1 x433; + uint32_t x434; + fiat_sm2_scalar_uint1 x435; + uint32_t x436; + fiat_sm2_scalar_uint1 x437; + uint32_t x438; + fiat_sm2_scalar_uint1 x439; + uint32_t x440; + fiat_sm2_scalar_uint1 x441; + uint32_t x442; + fiat_sm2_scalar_uint1 x443; + uint32_t x444; + fiat_sm2_scalar_uint1 x445; + uint32_t x446; + fiat_sm2_scalar_uint1 x447; + uint32_t x448; + fiat_sm2_scalar_uint1 x449; + uint32_t x450; + fiat_sm2_scalar_uint1 x451; + uint32_t x452; + fiat_sm2_scalar_uint1 x453; + uint32_t x454; + fiat_sm2_scalar_uint1 x455; + uint32_t x456; + fiat_sm2_scalar_uint1 x457; + uint32_t x458; + fiat_sm2_scalar_uint1 x459; + uint32_t x460; + fiat_sm2_scalar_uint1 x461; + uint32_t x462; + uint32_t 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; + fiat_sm2_scalar_uint1 x481; + uint32_t x482; + fiat_sm2_scalar_uint1 x483; + uint32_t x484; + fiat_sm2_scalar_uint1 x485; + uint32_t x486; + fiat_sm2_scalar_uint1 x487; + uint32_t x488; + fiat_sm2_scalar_uint1 x489; + uint32_t x490; + fiat_sm2_scalar_uint1 x491; + uint32_t x492; + fiat_sm2_scalar_uint1 x493; + uint32_t x494; + fiat_sm2_scalar_uint1 x495; + uint32_t x496; + fiat_sm2_scalar_uint1 x497; + uint32_t x498; + fiat_sm2_scalar_uint1 x499; + uint32_t x500; + fiat_sm2_scalar_uint1 x501; + uint32_t x502; + fiat_sm2_scalar_uint1 x503; + uint32_t x504; + fiat_sm2_scalar_uint1 x505; + uint32_t x506; + fiat_sm2_scalar_uint1 x507; + uint32_t x508; + fiat_sm2_scalar_uint1 x509; + uint32_t x510; + fiat_sm2_scalar_uint1 x511; + uint32_t x512; + fiat_sm2_scalar_uint1 x513; + uint32_t x514; + fiat_sm2_scalar_uint1 x515; + uint32_t x516; + fiat_sm2_scalar_uint1 x517; + uint32_t x518; + fiat_sm2_scalar_uint1 x519; + uint32_t x520; + fiat_sm2_scalar_uint1 x521; + uint32_t x522; + fiat_sm2_scalar_uint1 x523; + uint32_t x524; + fiat_sm2_scalar_uint1 x525; + uint32_t x526; + fiat_sm2_scalar_uint1 x527; + uint32_t x528; + fiat_sm2_scalar_uint1 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; + x1 = (arg1[0]); + fiat_sm2_scalar_mulx_u32(&x2, &x3, x1, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x4, &x5, x2, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x6, &x7, x2, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x8, &x9, x2, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x10, &x11, x2, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x12, &x13, x2, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x14, &x15, x2, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x16, &x17, x2, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x18, &x19, x2, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x20, &x21, 0x0, x19, x16); + fiat_sm2_scalar_addcarryx_u32(&x22, &x23, x21, x17, x14); + fiat_sm2_scalar_addcarryx_u32(&x24, &x25, x23, x15, x12); + fiat_sm2_scalar_addcarryx_u32(&x26, &x27, x25, x13, x10); + fiat_sm2_scalar_addcarryx_u32(&x28, &x29, x27, x11, x8); + fiat_sm2_scalar_addcarryx_u32(&x30, &x31, x29, x9, x6); + fiat_sm2_scalar_addcarryx_u32(&x32, &x33, x31, x7, x4); + fiat_sm2_scalar_addcarryx_u32(&x34, &x35, 0x0, x1, x18); + fiat_sm2_scalar_addcarryx_u32(&x36, &x37, x35, 0x0, x20); + fiat_sm2_scalar_addcarryx_u32(&x38, &x39, x37, 0x0, x22); + fiat_sm2_scalar_addcarryx_u32(&x40, &x41, x39, 0x0, x24); + fiat_sm2_scalar_addcarryx_u32(&x42, &x43, x41, 0x0, x26); + fiat_sm2_scalar_addcarryx_u32(&x44, &x45, x43, 0x0, x28); + fiat_sm2_scalar_addcarryx_u32(&x46, &x47, x45, 0x0, x30); + fiat_sm2_scalar_addcarryx_u32(&x48, &x49, x47, 0x0, x32); + fiat_sm2_scalar_addcarryx_u32(&x50, &x51, 0x0, x36, (arg1[1])); + fiat_sm2_scalar_addcarryx_u32(&x52, &x53, x51, x38, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x54, &x55, x53, x40, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x56, &x57, x55, x42, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x58, &x59, x57, x44, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x60, &x61, x59, x46, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x62, &x63, x61, x48, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x64, &x65, x63, (x49 + (x33 + x5)), 0x0); + fiat_sm2_scalar_mulx_u32(&x66, &x67, x50, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x68, &x69, x66, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x70, &x71, x66, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x72, &x73, x66, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x74, &x75, x66, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x76, &x77, x66, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x78, &x79, x66, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x80, &x81, x66, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x82, &x83, x66, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x84, &x85, 0x0, x83, x80); + fiat_sm2_scalar_addcarryx_u32(&x86, &x87, x85, x81, x78); + fiat_sm2_scalar_addcarryx_u32(&x88, &x89, x87, x79, x76); + fiat_sm2_scalar_addcarryx_u32(&x90, &x91, x89, x77, x74); + fiat_sm2_scalar_addcarryx_u32(&x92, &x93, x91, x75, x72); + fiat_sm2_scalar_addcarryx_u32(&x94, &x95, x93, x73, x70); + fiat_sm2_scalar_addcarryx_u32(&x96, &x97, x95, x71, x68); + fiat_sm2_scalar_addcarryx_u32(&x98, &x99, 0x0, x50, x82); + fiat_sm2_scalar_addcarryx_u32(&x100, &x101, x99, x52, x84); + fiat_sm2_scalar_addcarryx_u32(&x102, &x103, x101, x54, x86); + fiat_sm2_scalar_addcarryx_u32(&x104, &x105, x103, x56, x88); + fiat_sm2_scalar_addcarryx_u32(&x106, &x107, x105, x58, x90); + fiat_sm2_scalar_addcarryx_u32(&x108, &x109, x107, x60, x92); + fiat_sm2_scalar_addcarryx_u32(&x110, &x111, x109, x62, x94); + fiat_sm2_scalar_addcarryx_u32(&x112, &x113, x111, x64, x96); + fiat_sm2_scalar_addcarryx_u32(&x114, &x115, x113, x65, (x97 + x69)); + fiat_sm2_scalar_addcarryx_u32(&x116, &x117, 0x0, x100, (arg1[2])); + fiat_sm2_scalar_addcarryx_u32(&x118, &x119, x117, x102, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x120, &x121, x119, x104, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x122, &x123, x121, x106, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x124, &x125, x123, x108, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x126, &x127, x125, x110, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x128, &x129, x127, x112, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x130, &x131, x129, x114, 0x0); + fiat_sm2_scalar_mulx_u32(&x132, &x133, x116, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x134, &x135, x132, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x136, &x137, x132, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x138, &x139, x132, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x140, &x141, x132, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x142, &x143, x132, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x144, &x145, x132, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x146, &x147, x132, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x148, &x149, x132, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x150, &x151, 0x0, x149, x146); + fiat_sm2_scalar_addcarryx_u32(&x152, &x153, x151, x147, x144); + fiat_sm2_scalar_addcarryx_u32(&x154, &x155, x153, x145, x142); + fiat_sm2_scalar_addcarryx_u32(&x156, &x157, x155, x143, x140); + fiat_sm2_scalar_addcarryx_u32(&x158, &x159, x157, x141, x138); + fiat_sm2_scalar_addcarryx_u32(&x160, &x161, x159, x139, x136); + fiat_sm2_scalar_addcarryx_u32(&x162, &x163, x161, x137, x134); + fiat_sm2_scalar_addcarryx_u32(&x164, &x165, 0x0, x116, x148); + fiat_sm2_scalar_addcarryx_u32(&x166, &x167, x165, x118, x150); + fiat_sm2_scalar_addcarryx_u32(&x168, &x169, x167, x120, x152); + fiat_sm2_scalar_addcarryx_u32(&x170, &x171, x169, x122, x154); + fiat_sm2_scalar_addcarryx_u32(&x172, &x173, x171, x124, x156); + fiat_sm2_scalar_addcarryx_u32(&x174, &x175, x173, x126, x158); + fiat_sm2_scalar_addcarryx_u32(&x176, &x177, x175, x128, x160); + fiat_sm2_scalar_addcarryx_u32(&x178, &x179, x177, x130, x162); + fiat_sm2_scalar_addcarryx_u32(&x180, &x181, x179, ((uint32_t)x131 + x115), (x163 + x135)); + fiat_sm2_scalar_addcarryx_u32(&x182, &x183, 0x0, x166, (arg1[3])); + fiat_sm2_scalar_addcarryx_u32(&x184, &x185, x183, x168, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x186, &x187, x185, x170, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x188, &x189, x187, x172, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x190, &x191, x189, x174, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x192, &x193, x191, x176, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x194, &x195, x193, x178, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x196, &x197, x195, x180, 0x0); + fiat_sm2_scalar_mulx_u32(&x198, &x199, x182, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x200, &x201, x198, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x202, &x203, x198, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x204, &x205, x198, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x206, &x207, x198, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x208, &x209, x198, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x210, &x211, x198, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x212, &x213, x198, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x214, &x215, x198, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x216, &x217, 0x0, x215, x212); + fiat_sm2_scalar_addcarryx_u32(&x218, &x219, x217, x213, x210); + fiat_sm2_scalar_addcarryx_u32(&x220, &x221, x219, x211, x208); + fiat_sm2_scalar_addcarryx_u32(&x222, &x223, x221, x209, x206); + fiat_sm2_scalar_addcarryx_u32(&x224, &x225, x223, x207, x204); + fiat_sm2_scalar_addcarryx_u32(&x226, &x227, x225, x205, x202); + fiat_sm2_scalar_addcarryx_u32(&x228, &x229, x227, x203, x200); + fiat_sm2_scalar_addcarryx_u32(&x230, &x231, 0x0, x182, x214); + fiat_sm2_scalar_addcarryx_u32(&x232, &x233, x231, x184, x216); + fiat_sm2_scalar_addcarryx_u32(&x234, &x235, x233, x186, x218); + fiat_sm2_scalar_addcarryx_u32(&x236, &x237, x235, x188, x220); + fiat_sm2_scalar_addcarryx_u32(&x238, &x239, x237, x190, x222); + fiat_sm2_scalar_addcarryx_u32(&x240, &x241, x239, x192, x224); + fiat_sm2_scalar_addcarryx_u32(&x242, &x243, x241, x194, x226); + fiat_sm2_scalar_addcarryx_u32(&x244, &x245, x243, x196, x228); + fiat_sm2_scalar_addcarryx_u32(&x246, &x247, x245, ((uint32_t)x197 + x181), (x229 + x201)); + fiat_sm2_scalar_addcarryx_u32(&x248, &x249, 0x0, x232, (arg1[4])); + fiat_sm2_scalar_addcarryx_u32(&x250, &x251, x249, x234, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x252, &x253, x251, x236, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x254, &x255, x253, x238, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x256, &x257, x255, x240, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x258, &x259, x257, x242, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x260, &x261, x259, x244, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x262, &x263, x261, x246, 0x0); + fiat_sm2_scalar_mulx_u32(&x264, &x265, x248, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x266, &x267, x264, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x268, &x269, x264, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x270, &x271, x264, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x272, &x273, x264, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x274, &x275, x264, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x276, &x277, x264, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x278, &x279, x264, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x280, &x281, x264, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x282, &x283, 0x0, x281, x278); + fiat_sm2_scalar_addcarryx_u32(&x284, &x285, x283, x279, x276); + fiat_sm2_scalar_addcarryx_u32(&x286, &x287, x285, x277, x274); + fiat_sm2_scalar_addcarryx_u32(&x288, &x289, x287, x275, x272); + fiat_sm2_scalar_addcarryx_u32(&x290, &x291, x289, x273, x270); + fiat_sm2_scalar_addcarryx_u32(&x292, &x293, x291, x271, x268); + fiat_sm2_scalar_addcarryx_u32(&x294, &x295, x293, x269, x266); + fiat_sm2_scalar_addcarryx_u32(&x296, &x297, 0x0, x248, x280); + fiat_sm2_scalar_addcarryx_u32(&x298, &x299, x297, x250, x282); + fiat_sm2_scalar_addcarryx_u32(&x300, &x301, x299, x252, x284); + fiat_sm2_scalar_addcarryx_u32(&x302, &x303, x301, x254, x286); + fiat_sm2_scalar_addcarryx_u32(&x304, &x305, x303, x256, x288); + fiat_sm2_scalar_addcarryx_u32(&x306, &x307, x305, x258, x290); + fiat_sm2_scalar_addcarryx_u32(&x308, &x309, x307, x260, x292); + fiat_sm2_scalar_addcarryx_u32(&x310, &x311, x309, x262, x294); + fiat_sm2_scalar_addcarryx_u32(&x312, &x313, x311, ((uint32_t)x263 + x247), (x295 + x267)); + fiat_sm2_scalar_addcarryx_u32(&x314, &x315, 0x0, x298, (arg1[5])); + fiat_sm2_scalar_addcarryx_u32(&x316, &x317, x315, x300, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x318, &x319, x317, x302, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x320, &x321, x319, x304, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x322, &x323, x321, x306, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x324, &x325, x323, x308, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x326, &x327, x325, x310, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x328, &x329, x327, x312, 0x0); + fiat_sm2_scalar_mulx_u32(&x330, &x331, x314, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x332, &x333, x330, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x334, &x335, x330, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x336, &x337, x330, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x338, &x339, x330, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x340, &x341, x330, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x342, &x343, x330, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x344, &x345, x330, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x346, &x347, x330, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x348, &x349, 0x0, x347, x344); + fiat_sm2_scalar_addcarryx_u32(&x350, &x351, x349, x345, x342); + fiat_sm2_scalar_addcarryx_u32(&x352, &x353, x351, x343, x340); + fiat_sm2_scalar_addcarryx_u32(&x354, &x355, x353, x341, x338); + fiat_sm2_scalar_addcarryx_u32(&x356, &x357, x355, x339, x336); + fiat_sm2_scalar_addcarryx_u32(&x358, &x359, x357, x337, x334); + fiat_sm2_scalar_addcarryx_u32(&x360, &x361, x359, x335, x332); + fiat_sm2_scalar_addcarryx_u32(&x362, &x363, 0x0, x314, x346); + fiat_sm2_scalar_addcarryx_u32(&x364, &x365, x363, x316, x348); + fiat_sm2_scalar_addcarryx_u32(&x366, &x367, x365, x318, x350); + fiat_sm2_scalar_addcarryx_u32(&x368, &x369, x367, x320, x352); + fiat_sm2_scalar_addcarryx_u32(&x370, &x371, x369, x322, x354); + fiat_sm2_scalar_addcarryx_u32(&x372, &x373, x371, x324, x356); + fiat_sm2_scalar_addcarryx_u32(&x374, &x375, x373, x326, x358); + fiat_sm2_scalar_addcarryx_u32(&x376, &x377, x375, x328, x360); + fiat_sm2_scalar_addcarryx_u32(&x378, &x379, x377, ((uint32_t)x329 + x313), (x361 + x333)); + fiat_sm2_scalar_addcarryx_u32(&x380, &x381, 0x0, x364, (arg1[6])); + fiat_sm2_scalar_addcarryx_u32(&x382, &x383, x381, x366, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x384, &x385, x383, x368, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x386, &x387, x385, x370, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x388, &x389, x387, x372, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x390, &x391, x389, x374, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x392, &x393, x391, x376, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x394, &x395, x393, x378, 0x0); + fiat_sm2_scalar_mulx_u32(&x396, &x397, x380, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x398, &x399, x396, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x400, &x401, x396, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x402, &x403, x396, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x404, &x405, x396, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x406, &x407, x396, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x408, &x409, x396, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x410, &x411, x396, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x412, &x413, x396, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x414, &x415, 0x0, x413, x410); + fiat_sm2_scalar_addcarryx_u32(&x416, &x417, x415, x411, x408); + fiat_sm2_scalar_addcarryx_u32(&x418, &x419, x417, x409, x406); + fiat_sm2_scalar_addcarryx_u32(&x420, &x421, x419, x407, x404); + fiat_sm2_scalar_addcarryx_u32(&x422, &x423, x421, x405, x402); + fiat_sm2_scalar_addcarryx_u32(&x424, &x425, x423, x403, x400); + fiat_sm2_scalar_addcarryx_u32(&x426, &x427, x425, x401, x398); + fiat_sm2_scalar_addcarryx_u32(&x428, &x429, 0x0, x380, x412); + fiat_sm2_scalar_addcarryx_u32(&x430, &x431, x429, x382, x414); + fiat_sm2_scalar_addcarryx_u32(&x432, &x433, x431, x384, x416); + fiat_sm2_scalar_addcarryx_u32(&x434, &x435, x433, x386, x418); + fiat_sm2_scalar_addcarryx_u32(&x436, &x437, x435, x388, x420); + fiat_sm2_scalar_addcarryx_u32(&x438, &x439, x437, x390, x422); + fiat_sm2_scalar_addcarryx_u32(&x440, &x441, x439, x392, x424); + fiat_sm2_scalar_addcarryx_u32(&x442, &x443, x441, x394, x426); + fiat_sm2_scalar_addcarryx_u32(&x444, &x445, x443, ((uint32_t)x395 + x379), (x427 + x399)); + fiat_sm2_scalar_addcarryx_u32(&x446, &x447, 0x0, x430, (arg1[7])); + fiat_sm2_scalar_addcarryx_u32(&x448, &x449, x447, x432, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x450, &x451, x449, x434, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x452, &x453, x451, x436, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x454, &x455, x453, x438, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x456, &x457, x455, x440, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x458, &x459, x457, x442, 0x0); + fiat_sm2_scalar_addcarryx_u32(&x460, &x461, x459, x444, 0x0); + fiat_sm2_scalar_mulx_u32(&x462, &x463, x446, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x464, &x465, x462, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x466, &x467, x462, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x468, &x469, x462, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x470, &x471, x462, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x472, &x473, x462, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x474, &x475, x462, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x476, &x477, x462, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x478, &x479, x462, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x480, &x481, 0x0, x479, x476); + fiat_sm2_scalar_addcarryx_u32(&x482, &x483, x481, x477, x474); + fiat_sm2_scalar_addcarryx_u32(&x484, &x485, x483, x475, x472); + fiat_sm2_scalar_addcarryx_u32(&x486, &x487, x485, x473, x470); + fiat_sm2_scalar_addcarryx_u32(&x488, &x489, x487, x471, x468); + fiat_sm2_scalar_addcarryx_u32(&x490, &x491, x489, x469, x466); + fiat_sm2_scalar_addcarryx_u32(&x492, &x493, x491, x467, x464); + fiat_sm2_scalar_addcarryx_u32(&x494, &x495, 0x0, x446, x478); + fiat_sm2_scalar_addcarryx_u32(&x496, &x497, x495, x448, x480); + fiat_sm2_scalar_addcarryx_u32(&x498, &x499, x497, x450, x482); + fiat_sm2_scalar_addcarryx_u32(&x500, &x501, x499, x452, x484); + fiat_sm2_scalar_addcarryx_u32(&x502, &x503, x501, x454, x486); + fiat_sm2_scalar_addcarryx_u32(&x504, &x505, x503, x456, x488); + fiat_sm2_scalar_addcarryx_u32(&x506, &x507, x505, x458, x490); + fiat_sm2_scalar_addcarryx_u32(&x508, &x509, x507, x460, x492); + fiat_sm2_scalar_addcarryx_u32(&x510, &x511, x509, ((uint32_t)x461 + x445), (x493 + x465)); + fiat_sm2_scalar_subborrowx_u32(&x512, &x513, 0x0, x496, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x514, &x515, x513, x498, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x516, &x517, x515, x500, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x518, &x519, x517, x502, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x520, &x521, x519, x504, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x522, &x523, x521, x506, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x524, &x525, x523, x508, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x526, &x527, x525, x510, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_subborrowx_u32(&x528, &x529, x527, x511, 0x0); + fiat_sm2_scalar_cmovznz_u32(&x530, x529, x512, x496); + fiat_sm2_scalar_cmovznz_u32(&x531, x529, x514, x498); + fiat_sm2_scalar_cmovznz_u32(&x532, x529, x516, x500); + fiat_sm2_scalar_cmovznz_u32(&x533, x529, x518, x502); + fiat_sm2_scalar_cmovznz_u32(&x534, x529, x520, x504); + fiat_sm2_scalar_cmovznz_u32(&x535, x529, x522, x506); + fiat_sm2_scalar_cmovznz_u32(&x536, x529, x524, x508); + fiat_sm2_scalar_cmovznz_u32(&x537, x529, x526, x510); + out1[0] = x530; + out1[1] = x531; + out1[2] = x532; + out1[3] = x533; + out1[4] = x534; + out1[5] = x535; + out1[6] = x536; + out1[7] = x537; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_to_montgomery(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_scalar_uint1 x26; + uint32_t x27; + fiat_sm2_scalar_uint1 x28; + uint32_t x29; + fiat_sm2_scalar_uint1 x30; + uint32_t x31; + fiat_sm2_scalar_uint1 x32; + uint32_t x33; + fiat_sm2_scalar_uint1 x34; + uint32_t x35; + fiat_sm2_scalar_uint1 x36; + uint32_t x37; + fiat_sm2_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_sm2_scalar_uint1 x58; + uint32_t x59; + fiat_sm2_scalar_uint1 x60; + uint32_t x61; + fiat_sm2_scalar_uint1 x62; + uint32_t x63; + fiat_sm2_scalar_uint1 x64; + uint32_t x65; + fiat_sm2_scalar_uint1 x66; + uint32_t x67; + fiat_sm2_scalar_uint1 x68; + uint32_t x69; + fiat_sm2_scalar_uint1 x70; + uint32_t x71; + fiat_sm2_scalar_uint1 x72; + uint32_t x73; + fiat_sm2_scalar_uint1 x74; + uint32_t x75; + fiat_sm2_scalar_uint1 x76; + uint32_t x77; + fiat_sm2_scalar_uint1 x78; + uint32_t x79; + fiat_sm2_scalar_uint1 x80; + uint32_t x81; + fiat_sm2_scalar_uint1 x82; + uint32_t x83; + fiat_sm2_scalar_uint1 x84; + uint32_t x85; + fiat_sm2_scalar_uint1 x86; + uint32_t x87; + fiat_sm2_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_sm2_scalar_uint1 x106; + uint32_t x107; + fiat_sm2_scalar_uint1 x108; + uint32_t x109; + fiat_sm2_scalar_uint1 x110; + uint32_t x111; + fiat_sm2_scalar_uint1 x112; + uint32_t x113; + fiat_sm2_scalar_uint1 x114; + uint32_t x115; + fiat_sm2_scalar_uint1 x116; + uint32_t x117; + fiat_sm2_scalar_uint1 x118; + uint32_t x119; + fiat_sm2_scalar_uint1 x120; + uint32_t x121; + fiat_sm2_scalar_uint1 x122; + uint32_t x123; + fiat_sm2_scalar_uint1 x124; + uint32_t x125; + fiat_sm2_scalar_uint1 x126; + uint32_t x127; + fiat_sm2_scalar_uint1 x128; + uint32_t x129; + fiat_sm2_scalar_uint1 x130; + uint32_t x131; + fiat_sm2_scalar_uint1 x132; + uint32_t x133; + fiat_sm2_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_sm2_scalar_uint1 x154; + uint32_t x155; + fiat_sm2_scalar_uint1 x156; + uint32_t x157; + fiat_sm2_scalar_uint1 x158; + uint32_t x159; + fiat_sm2_scalar_uint1 x160; + uint32_t x161; + fiat_sm2_scalar_uint1 x162; + uint32_t x163; + fiat_sm2_scalar_uint1 x164; + uint32_t x165; + fiat_sm2_scalar_uint1 x166; + uint32_t x167; + fiat_sm2_scalar_uint1 x168; + uint32_t x169; + fiat_sm2_scalar_uint1 x170; + uint32_t x171; + fiat_sm2_scalar_uint1 x172; + uint32_t x173; + fiat_sm2_scalar_uint1 x174; + uint32_t x175; + fiat_sm2_scalar_uint1 x176; + uint32_t x177; + fiat_sm2_scalar_uint1 x178; + uint32_t x179; + fiat_sm2_scalar_uint1 x180; + uint32_t x181; + fiat_sm2_scalar_uint1 x182; + uint32_t x183; + fiat_sm2_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_sm2_scalar_uint1 x202; + uint32_t x203; + fiat_sm2_scalar_uint1 x204; + uint32_t x205; + fiat_sm2_scalar_uint1 x206; + uint32_t x207; + fiat_sm2_scalar_uint1 x208; + uint32_t x209; + fiat_sm2_scalar_uint1 x210; + uint32_t x211; + fiat_sm2_scalar_uint1 x212; + uint32_t x213; + fiat_sm2_scalar_uint1 x214; + uint32_t x215; + fiat_sm2_scalar_uint1 x216; + uint32_t x217; + fiat_sm2_scalar_uint1 x218; + uint32_t x219; + fiat_sm2_scalar_uint1 x220; + uint32_t x221; + fiat_sm2_scalar_uint1 x222; + uint32_t x223; + fiat_sm2_scalar_uint1 x224; + uint32_t x225; + fiat_sm2_scalar_uint1 x226; + uint32_t x227; + fiat_sm2_scalar_uint1 x228; + uint32_t x229; + fiat_sm2_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_sm2_scalar_uint1 x250; + uint32_t x251; + fiat_sm2_scalar_uint1 x252; + uint32_t x253; + fiat_sm2_scalar_uint1 x254; + uint32_t x255; + fiat_sm2_scalar_uint1 x256; + uint32_t x257; + fiat_sm2_scalar_uint1 x258; + uint32_t x259; + fiat_sm2_scalar_uint1 x260; + uint32_t x261; + fiat_sm2_scalar_uint1 x262; + uint32_t x263; + fiat_sm2_scalar_uint1 x264; + uint32_t x265; + fiat_sm2_scalar_uint1 x266; + uint32_t x267; + fiat_sm2_scalar_uint1 x268; + uint32_t x269; + fiat_sm2_scalar_uint1 x270; + uint32_t x271; + fiat_sm2_scalar_uint1 x272; + uint32_t x273; + fiat_sm2_scalar_uint1 x274; + uint32_t x275; + fiat_sm2_scalar_uint1 x276; + uint32_t x277; + fiat_sm2_scalar_uint1 x278; + uint32_t x279; + fiat_sm2_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_sm2_scalar_uint1 x298; + uint32_t x299; + fiat_sm2_scalar_uint1 x300; + uint32_t x301; + fiat_sm2_scalar_uint1 x302; + uint32_t x303; + fiat_sm2_scalar_uint1 x304; + uint32_t x305; + fiat_sm2_scalar_uint1 x306; + uint32_t x307; + fiat_sm2_scalar_uint1 x308; + uint32_t x309; + fiat_sm2_scalar_uint1 x310; + uint32_t x311; + fiat_sm2_scalar_uint1 x312; + uint32_t x313; + fiat_sm2_scalar_uint1 x314; + uint32_t x315; + fiat_sm2_scalar_uint1 x316; + uint32_t x317; + fiat_sm2_scalar_uint1 x318; + uint32_t x319; + fiat_sm2_scalar_uint1 x320; + uint32_t x321; + fiat_sm2_scalar_uint1 x322; + uint32_t x323; + fiat_sm2_scalar_uint1 x324; + uint32_t x325; + fiat_sm2_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_sm2_scalar_uint1 x346; + uint32_t x347; + fiat_sm2_scalar_uint1 x348; + uint32_t x349; + fiat_sm2_scalar_uint1 x350; + uint32_t x351; + fiat_sm2_scalar_uint1 x352; + uint32_t x353; + fiat_sm2_scalar_uint1 x354; + uint32_t x355; + fiat_sm2_scalar_uint1 x356; + uint32_t x357; + fiat_sm2_scalar_uint1 x358; + uint32_t x359; + fiat_sm2_scalar_uint1 x360; + uint32_t x361; + fiat_sm2_scalar_uint1 x362; + uint32_t x363; + fiat_sm2_scalar_uint1 x364; + uint32_t x365; + fiat_sm2_scalar_uint1 x366; + uint32_t x367; + fiat_sm2_scalar_uint1 x368; + uint32_t x369; + fiat_sm2_scalar_uint1 x370; + uint32_t x371; + fiat_sm2_scalar_uint1 x372; + uint32_t x373; + fiat_sm2_scalar_uint1 x374; + uint32_t x375; + fiat_sm2_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_sm2_scalar_uint1 x394; + uint32_t x395; + fiat_sm2_scalar_uint1 x396; + uint32_t x397; + fiat_sm2_scalar_uint1 x398; + uint32_t x399; + fiat_sm2_scalar_uint1 x400; + uint32_t x401; + fiat_sm2_scalar_uint1 x402; + uint32_t x403; + fiat_sm2_scalar_uint1 x404; + uint32_t x405; + fiat_sm2_scalar_uint1 x406; + uint32_t x407; + fiat_sm2_scalar_uint1 x408; + uint32_t x409; + fiat_sm2_scalar_uint1 x410; + uint32_t x411; + fiat_sm2_scalar_uint1 x412; + uint32_t x413; + fiat_sm2_scalar_uint1 x414; + uint32_t x415; + fiat_sm2_scalar_uint1 x416; + uint32_t x417; + fiat_sm2_scalar_uint1 x418; + uint32_t x419; + fiat_sm2_scalar_uint1 x420; + uint32_t x421; + fiat_sm2_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_sm2_scalar_uint1 x442; + uint32_t x443; + fiat_sm2_scalar_uint1 x444; + uint32_t x445; + fiat_sm2_scalar_uint1 x446; + uint32_t x447; + fiat_sm2_scalar_uint1 x448; + uint32_t x449; + fiat_sm2_scalar_uint1 x450; + uint32_t x451; + fiat_sm2_scalar_uint1 x452; + uint32_t x453; + fiat_sm2_scalar_uint1 x454; + uint32_t x455; + fiat_sm2_scalar_uint1 x456; + uint32_t x457; + fiat_sm2_scalar_uint1 x458; + uint32_t x459; + fiat_sm2_scalar_uint1 x460; + uint32_t x461; + fiat_sm2_scalar_uint1 x462; + uint32_t x463; + fiat_sm2_scalar_uint1 x464; + uint32_t x465; + fiat_sm2_scalar_uint1 x466; + uint32_t x467; + fiat_sm2_scalar_uint1 x468; + uint32_t x469; + fiat_sm2_scalar_uint1 x470; + uint32_t x471; + fiat_sm2_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_sm2_scalar_uint1 x490; + uint32_t x491; + fiat_sm2_scalar_uint1 x492; + uint32_t x493; + fiat_sm2_scalar_uint1 x494; + uint32_t x495; + fiat_sm2_scalar_uint1 x496; + uint32_t x497; + fiat_sm2_scalar_uint1 x498; + uint32_t x499; + fiat_sm2_scalar_uint1 x500; + uint32_t x501; + fiat_sm2_scalar_uint1 x502; + uint32_t x503; + fiat_sm2_scalar_uint1 x504; + uint32_t x505; + fiat_sm2_scalar_uint1 x506; + uint32_t x507; + fiat_sm2_scalar_uint1 x508; + uint32_t x509; + fiat_sm2_scalar_uint1 x510; + uint32_t x511; + fiat_sm2_scalar_uint1 x512; + uint32_t x513; + fiat_sm2_scalar_uint1 x514; + uint32_t x515; + fiat_sm2_scalar_uint1 x516; + uint32_t x517; + fiat_sm2_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_sm2_scalar_uint1 x538; + uint32_t x539; + fiat_sm2_scalar_uint1 x540; + uint32_t x541; + fiat_sm2_scalar_uint1 x542; + uint32_t x543; + fiat_sm2_scalar_uint1 x544; + uint32_t x545; + fiat_sm2_scalar_uint1 x546; + uint32_t x547; + fiat_sm2_scalar_uint1 x548; + uint32_t x549; + fiat_sm2_scalar_uint1 x550; + uint32_t x551; + fiat_sm2_scalar_uint1 x552; + uint32_t x553; + fiat_sm2_scalar_uint1 x554; + uint32_t x555; + fiat_sm2_scalar_uint1 x556; + uint32_t x557; + fiat_sm2_scalar_uint1 x558; + uint32_t x559; + fiat_sm2_scalar_uint1 x560; + uint32_t x561; + fiat_sm2_scalar_uint1 x562; + uint32_t x563; + fiat_sm2_scalar_uint1 x564; + uint32_t x565; + fiat_sm2_scalar_uint1 x566; + uint32_t x567; + fiat_sm2_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_sm2_scalar_uint1 x586; + uint32_t x587; + fiat_sm2_scalar_uint1 x588; + uint32_t x589; + fiat_sm2_scalar_uint1 x590; + uint32_t x591; + fiat_sm2_scalar_uint1 x592; + uint32_t x593; + fiat_sm2_scalar_uint1 x594; + uint32_t x595; + fiat_sm2_scalar_uint1 x596; + uint32_t x597; + fiat_sm2_scalar_uint1 x598; + uint32_t x599; + fiat_sm2_scalar_uint1 x600; + uint32_t x601; + fiat_sm2_scalar_uint1 x602; + uint32_t x603; + fiat_sm2_scalar_uint1 x604; + uint32_t x605; + fiat_sm2_scalar_uint1 x606; + uint32_t x607; + fiat_sm2_scalar_uint1 x608; + uint32_t x609; + fiat_sm2_scalar_uint1 x610; + uint32_t x611; + fiat_sm2_scalar_uint1 x612; + uint32_t x613; + fiat_sm2_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_sm2_scalar_uint1 x634; + uint32_t x635; + fiat_sm2_scalar_uint1 x636; + uint32_t x637; + fiat_sm2_scalar_uint1 x638; + uint32_t x639; + fiat_sm2_scalar_uint1 x640; + uint32_t x641; + fiat_sm2_scalar_uint1 x642; + uint32_t x643; + fiat_sm2_scalar_uint1 x644; + uint32_t x645; + fiat_sm2_scalar_uint1 x646; + uint32_t x647; + fiat_sm2_scalar_uint1 x648; + uint32_t x649; + fiat_sm2_scalar_uint1 x650; + uint32_t x651; + fiat_sm2_scalar_uint1 x652; + uint32_t x653; + fiat_sm2_scalar_uint1 x654; + uint32_t x655; + fiat_sm2_scalar_uint1 x656; + uint32_t x657; + fiat_sm2_scalar_uint1 x658; + uint32_t x659; + fiat_sm2_scalar_uint1 x660; + uint32_t x661; + fiat_sm2_scalar_uint1 x662; + uint32_t x663; + fiat_sm2_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_sm2_scalar_uint1 x682; + uint32_t x683; + fiat_sm2_scalar_uint1 x684; + uint32_t x685; + fiat_sm2_scalar_uint1 x686; + uint32_t x687; + fiat_sm2_scalar_uint1 x688; + uint32_t x689; + fiat_sm2_scalar_uint1 x690; + uint32_t x691; + fiat_sm2_scalar_uint1 x692; + uint32_t x693; + fiat_sm2_scalar_uint1 x694; + uint32_t x695; + fiat_sm2_scalar_uint1 x696; + uint32_t x697; + fiat_sm2_scalar_uint1 x698; + uint32_t x699; + fiat_sm2_scalar_uint1 x700; + uint32_t x701; + fiat_sm2_scalar_uint1 x702; + uint32_t x703; + fiat_sm2_scalar_uint1 x704; + uint32_t x705; + fiat_sm2_scalar_uint1 x706; + uint32_t x707; + fiat_sm2_scalar_uint1 x708; + uint32_t x709; + fiat_sm2_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_sm2_scalar_uint1 x730; + uint32_t x731; + fiat_sm2_scalar_uint1 x732; + uint32_t x733; + fiat_sm2_scalar_uint1 x734; + uint32_t x735; + fiat_sm2_scalar_uint1 x736; + uint32_t x737; + fiat_sm2_scalar_uint1 x738; + uint32_t x739; + fiat_sm2_scalar_uint1 x740; + uint32_t x741; + fiat_sm2_scalar_uint1 x742; + uint32_t x743; + fiat_sm2_scalar_uint1 x744; + uint32_t x745; + fiat_sm2_scalar_uint1 x746; + uint32_t x747; + fiat_sm2_scalar_uint1 x748; + uint32_t x749; + fiat_sm2_scalar_uint1 x750; + uint32_t x751; + fiat_sm2_scalar_uint1 x752; + uint32_t x753; + fiat_sm2_scalar_uint1 x754; + uint32_t x755; + fiat_sm2_scalar_uint1 x756; + uint32_t x757; + fiat_sm2_scalar_uint1 x758; + uint32_t x759; + fiat_sm2_scalar_uint1 x760; + uint32_t x761; + fiat_sm2_scalar_uint1 x762; + uint32_t x763; + fiat_sm2_scalar_uint1 x764; + uint32_t x765; + fiat_sm2_scalar_uint1 x766; + uint32_t x767; + fiat_sm2_scalar_uint1 x768; + uint32_t x769; + fiat_sm2_scalar_uint1 x770; + uint32_t x771; + fiat_sm2_scalar_uint1 x772; + uint32_t x773; + fiat_sm2_scalar_uint1 x774; + uint32_t x775; + fiat_sm2_scalar_uint1 x776; + uint32_t x777; + fiat_sm2_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_sm2_scalar_mulx_u32(&x9, &x10, x8, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x11, &x12, x8, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x13, &x14, x8, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x15, &x16, x8, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x17, &x18, x8, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x19, &x20, x8, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x21, &x22, x8, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x23, &x24, x8, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x25, &x26, 0x0, x24, x21); + fiat_sm2_scalar_addcarryx_u32(&x27, &x28, x26, x22, x19); + fiat_sm2_scalar_addcarryx_u32(&x29, &x30, x28, x20, x17); + fiat_sm2_scalar_addcarryx_u32(&x31, &x32, x30, x18, x15); + fiat_sm2_scalar_addcarryx_u32(&x33, &x34, x32, x16, x13); + fiat_sm2_scalar_addcarryx_u32(&x35, &x36, x34, x14, x11); + fiat_sm2_scalar_addcarryx_u32(&x37, &x38, x36, x12, x9); + fiat_sm2_scalar_mulx_u32(&x39, &x40, x23, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x41, &x42, x39, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x43, &x44, x39, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x45, &x46, x39, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x47, &x48, x39, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x49, &x50, x39, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x51, &x52, x39, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x53, &x54, x39, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x55, &x56, x39, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x57, &x58, 0x0, x56, x53); + fiat_sm2_scalar_addcarryx_u32(&x59, &x60, x58, x54, x51); + fiat_sm2_scalar_addcarryx_u32(&x61, &x62, x60, x52, x49); + fiat_sm2_scalar_addcarryx_u32(&x63, &x64, x62, x50, x47); + fiat_sm2_scalar_addcarryx_u32(&x65, &x66, x64, x48, x45); + fiat_sm2_scalar_addcarryx_u32(&x67, &x68, x66, x46, x43); + fiat_sm2_scalar_addcarryx_u32(&x69, &x70, x68, x44, x41); + fiat_sm2_scalar_addcarryx_u32(&x71, &x72, 0x0, x23, x55); + fiat_sm2_scalar_addcarryx_u32(&x73, &x74, x72, x25, x57); + fiat_sm2_scalar_addcarryx_u32(&x75, &x76, x74, x27, x59); + fiat_sm2_scalar_addcarryx_u32(&x77, &x78, x76, x29, x61); + fiat_sm2_scalar_addcarryx_u32(&x79, &x80, x78, x31, x63); + fiat_sm2_scalar_addcarryx_u32(&x81, &x82, x80, x33, x65); + fiat_sm2_scalar_addcarryx_u32(&x83, &x84, x82, x35, x67); + fiat_sm2_scalar_addcarryx_u32(&x85, &x86, x84, x37, x69); + fiat_sm2_scalar_addcarryx_u32(&x87, &x88, x86, (x38 + x10), (x70 + x42)); + fiat_sm2_scalar_mulx_u32(&x89, &x90, x1, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x91, &x92, x1, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x93, &x94, x1, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x95, &x96, x1, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x97, &x98, x1, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x99, &x100, x1, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x101, &x102, x1, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x103, &x104, x1, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x105, &x106, 0x0, x104, x101); + fiat_sm2_scalar_addcarryx_u32(&x107, &x108, x106, x102, x99); + fiat_sm2_scalar_addcarryx_u32(&x109, &x110, x108, x100, x97); + fiat_sm2_scalar_addcarryx_u32(&x111, &x112, x110, x98, x95); + fiat_sm2_scalar_addcarryx_u32(&x113, &x114, x112, x96, x93); + fiat_sm2_scalar_addcarryx_u32(&x115, &x116, x114, x94, x91); + fiat_sm2_scalar_addcarryx_u32(&x117, &x118, x116, x92, x89); + fiat_sm2_scalar_addcarryx_u32(&x119, &x120, 0x0, x73, x103); + fiat_sm2_scalar_addcarryx_u32(&x121, &x122, x120, x75, x105); + fiat_sm2_scalar_addcarryx_u32(&x123, &x124, x122, x77, x107); + fiat_sm2_scalar_addcarryx_u32(&x125, &x126, x124, x79, x109); + fiat_sm2_scalar_addcarryx_u32(&x127, &x128, x126, x81, x111); + fiat_sm2_scalar_addcarryx_u32(&x129, &x130, x128, x83, x113); + fiat_sm2_scalar_addcarryx_u32(&x131, &x132, x130, x85, x115); + fiat_sm2_scalar_addcarryx_u32(&x133, &x134, x132, x87, x117); + fiat_sm2_scalar_mulx_u32(&x135, &x136, x119, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x137, &x138, x135, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x139, &x140, x135, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x141, &x142, x135, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x143, &x144, x135, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x145, &x146, x135, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x147, &x148, x135, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x149, &x150, x135, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x151, &x152, x135, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x153, &x154, 0x0, x152, x149); + fiat_sm2_scalar_addcarryx_u32(&x155, &x156, x154, x150, x147); + fiat_sm2_scalar_addcarryx_u32(&x157, &x158, x156, x148, x145); + fiat_sm2_scalar_addcarryx_u32(&x159, &x160, x158, x146, x143); + fiat_sm2_scalar_addcarryx_u32(&x161, &x162, x160, x144, x141); + fiat_sm2_scalar_addcarryx_u32(&x163, &x164, x162, x142, x139); + fiat_sm2_scalar_addcarryx_u32(&x165, &x166, x164, x140, x137); + fiat_sm2_scalar_addcarryx_u32(&x167, &x168, 0x0, x119, x151); + fiat_sm2_scalar_addcarryx_u32(&x169, &x170, x168, x121, x153); + fiat_sm2_scalar_addcarryx_u32(&x171, &x172, x170, x123, x155); + fiat_sm2_scalar_addcarryx_u32(&x173, &x174, x172, x125, x157); + fiat_sm2_scalar_addcarryx_u32(&x175, &x176, x174, x127, x159); + fiat_sm2_scalar_addcarryx_u32(&x177, &x178, x176, x129, x161); + fiat_sm2_scalar_addcarryx_u32(&x179, &x180, x178, x131, x163); + fiat_sm2_scalar_addcarryx_u32(&x181, &x182, x180, x133, x165); + fiat_sm2_scalar_addcarryx_u32(&x183, &x184, x182, (((uint32_t)x134 + x88) + (x118 + x90)), (x166 + x138)); + fiat_sm2_scalar_mulx_u32(&x185, &x186, x2, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x187, &x188, x2, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x189, &x190, x2, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x191, &x192, x2, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x193, &x194, x2, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x195, &x196, x2, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x197, &x198, x2, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x199, &x200, x2, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x201, &x202, 0x0, x200, x197); + fiat_sm2_scalar_addcarryx_u32(&x203, &x204, x202, x198, x195); + fiat_sm2_scalar_addcarryx_u32(&x205, &x206, x204, x196, x193); + fiat_sm2_scalar_addcarryx_u32(&x207, &x208, x206, x194, x191); + fiat_sm2_scalar_addcarryx_u32(&x209, &x210, x208, x192, x189); + fiat_sm2_scalar_addcarryx_u32(&x211, &x212, x210, x190, x187); + fiat_sm2_scalar_addcarryx_u32(&x213, &x214, x212, x188, x185); + fiat_sm2_scalar_addcarryx_u32(&x215, &x216, 0x0, x169, x199); + fiat_sm2_scalar_addcarryx_u32(&x217, &x218, x216, x171, x201); + fiat_sm2_scalar_addcarryx_u32(&x219, &x220, x218, x173, x203); + fiat_sm2_scalar_addcarryx_u32(&x221, &x222, x220, x175, x205); + fiat_sm2_scalar_addcarryx_u32(&x223, &x224, x222, x177, x207); + fiat_sm2_scalar_addcarryx_u32(&x225, &x226, x224, x179, x209); + fiat_sm2_scalar_addcarryx_u32(&x227, &x228, x226, x181, x211); + fiat_sm2_scalar_addcarryx_u32(&x229, &x230, x228, x183, x213); + fiat_sm2_scalar_mulx_u32(&x231, &x232, x215, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x233, &x234, x231, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x235, &x236, x231, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x237, &x238, x231, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x239, &x240, x231, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x241, &x242, x231, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x243, &x244, x231, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x245, &x246, x231, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x247, &x248, x231, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x249, &x250, 0x0, x248, x245); + fiat_sm2_scalar_addcarryx_u32(&x251, &x252, x250, x246, x243); + fiat_sm2_scalar_addcarryx_u32(&x253, &x254, x252, x244, x241); + fiat_sm2_scalar_addcarryx_u32(&x255, &x256, x254, x242, x239); + fiat_sm2_scalar_addcarryx_u32(&x257, &x258, x256, x240, x237); + fiat_sm2_scalar_addcarryx_u32(&x259, &x260, x258, x238, x235); + fiat_sm2_scalar_addcarryx_u32(&x261, &x262, x260, x236, x233); + fiat_sm2_scalar_addcarryx_u32(&x263, &x264, 0x0, x215, x247); + fiat_sm2_scalar_addcarryx_u32(&x265, &x266, x264, x217, x249); + fiat_sm2_scalar_addcarryx_u32(&x267, &x268, x266, x219, x251); + fiat_sm2_scalar_addcarryx_u32(&x269, &x270, x268, x221, x253); + fiat_sm2_scalar_addcarryx_u32(&x271, &x272, x270, x223, x255); + fiat_sm2_scalar_addcarryx_u32(&x273, &x274, x272, x225, x257); + fiat_sm2_scalar_addcarryx_u32(&x275, &x276, x274, x227, x259); + fiat_sm2_scalar_addcarryx_u32(&x277, &x278, x276, x229, x261); + fiat_sm2_scalar_addcarryx_u32(&x279, &x280, x278, (((uint32_t)x230 + x184) + (x214 + x186)), (x262 + x234)); + fiat_sm2_scalar_mulx_u32(&x281, &x282, x3, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x283, &x284, x3, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x285, &x286, x3, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x287, &x288, x3, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x289, &x290, x3, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x291, &x292, x3, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x293, &x294, x3, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x295, &x296, x3, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x297, &x298, 0x0, x296, x293); + fiat_sm2_scalar_addcarryx_u32(&x299, &x300, x298, x294, x291); + fiat_sm2_scalar_addcarryx_u32(&x301, &x302, x300, x292, x289); + fiat_sm2_scalar_addcarryx_u32(&x303, &x304, x302, x290, x287); + fiat_sm2_scalar_addcarryx_u32(&x305, &x306, x304, x288, x285); + fiat_sm2_scalar_addcarryx_u32(&x307, &x308, x306, x286, x283); + fiat_sm2_scalar_addcarryx_u32(&x309, &x310, x308, x284, x281); + fiat_sm2_scalar_addcarryx_u32(&x311, &x312, 0x0, x265, x295); + fiat_sm2_scalar_addcarryx_u32(&x313, &x314, x312, x267, x297); + fiat_sm2_scalar_addcarryx_u32(&x315, &x316, x314, x269, x299); + fiat_sm2_scalar_addcarryx_u32(&x317, &x318, x316, x271, x301); + fiat_sm2_scalar_addcarryx_u32(&x319, &x320, x318, x273, x303); + fiat_sm2_scalar_addcarryx_u32(&x321, &x322, x320, x275, x305); + fiat_sm2_scalar_addcarryx_u32(&x323, &x324, x322, x277, x307); + fiat_sm2_scalar_addcarryx_u32(&x325, &x326, x324, x279, x309); + fiat_sm2_scalar_mulx_u32(&x327, &x328, x311, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x329, &x330, x327, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x331, &x332, x327, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x333, &x334, x327, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x335, &x336, x327, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x337, &x338, x327, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x339, &x340, x327, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x341, &x342, x327, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x343, &x344, x327, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x345, &x346, 0x0, x344, x341); + fiat_sm2_scalar_addcarryx_u32(&x347, &x348, x346, x342, x339); + fiat_sm2_scalar_addcarryx_u32(&x349, &x350, x348, x340, x337); + fiat_sm2_scalar_addcarryx_u32(&x351, &x352, x350, x338, x335); + fiat_sm2_scalar_addcarryx_u32(&x353, &x354, x352, x336, x333); + fiat_sm2_scalar_addcarryx_u32(&x355, &x356, x354, x334, x331); + fiat_sm2_scalar_addcarryx_u32(&x357, &x358, x356, x332, x329); + fiat_sm2_scalar_addcarryx_u32(&x359, &x360, 0x0, x311, x343); + fiat_sm2_scalar_addcarryx_u32(&x361, &x362, x360, x313, x345); + fiat_sm2_scalar_addcarryx_u32(&x363, &x364, x362, x315, x347); + fiat_sm2_scalar_addcarryx_u32(&x365, &x366, x364, x317, x349); + fiat_sm2_scalar_addcarryx_u32(&x367, &x368, x366, x319, x351); + fiat_sm2_scalar_addcarryx_u32(&x369, &x370, x368, x321, x353); + fiat_sm2_scalar_addcarryx_u32(&x371, &x372, x370, x323, x355); + fiat_sm2_scalar_addcarryx_u32(&x373, &x374, x372, x325, x357); + fiat_sm2_scalar_addcarryx_u32(&x375, &x376, x374, (((uint32_t)x326 + x280) + (x310 + x282)), (x358 + x330)); + fiat_sm2_scalar_mulx_u32(&x377, &x378, x4, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x379, &x380, x4, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x381, &x382, x4, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x383, &x384, x4, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x385, &x386, x4, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x387, &x388, x4, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x389, &x390, x4, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x391, &x392, x4, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x393, &x394, 0x0, x392, x389); + fiat_sm2_scalar_addcarryx_u32(&x395, &x396, x394, x390, x387); + fiat_sm2_scalar_addcarryx_u32(&x397, &x398, x396, x388, x385); + fiat_sm2_scalar_addcarryx_u32(&x399, &x400, x398, x386, x383); + fiat_sm2_scalar_addcarryx_u32(&x401, &x402, x400, x384, x381); + fiat_sm2_scalar_addcarryx_u32(&x403, &x404, x402, x382, x379); + fiat_sm2_scalar_addcarryx_u32(&x405, &x406, x404, x380, x377); + fiat_sm2_scalar_addcarryx_u32(&x407, &x408, 0x0, x361, x391); + fiat_sm2_scalar_addcarryx_u32(&x409, &x410, x408, x363, x393); + fiat_sm2_scalar_addcarryx_u32(&x411, &x412, x410, x365, x395); + fiat_sm2_scalar_addcarryx_u32(&x413, &x414, x412, x367, x397); + fiat_sm2_scalar_addcarryx_u32(&x415, &x416, x414, x369, x399); + fiat_sm2_scalar_addcarryx_u32(&x417, &x418, x416, x371, x401); + fiat_sm2_scalar_addcarryx_u32(&x419, &x420, x418, x373, x403); + fiat_sm2_scalar_addcarryx_u32(&x421, &x422, x420, x375, x405); + fiat_sm2_scalar_mulx_u32(&x423, &x424, x407, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x425, &x426, x423, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x427, &x428, x423, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x429, &x430, x423, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x431, &x432, x423, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x433, &x434, x423, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x435, &x436, x423, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x437, &x438, x423, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x439, &x440, x423, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x441, &x442, 0x0, x440, x437); + fiat_sm2_scalar_addcarryx_u32(&x443, &x444, x442, x438, x435); + fiat_sm2_scalar_addcarryx_u32(&x445, &x446, x444, x436, x433); + fiat_sm2_scalar_addcarryx_u32(&x447, &x448, x446, x434, x431); + fiat_sm2_scalar_addcarryx_u32(&x449, &x450, x448, x432, x429); + fiat_sm2_scalar_addcarryx_u32(&x451, &x452, x450, x430, x427); + fiat_sm2_scalar_addcarryx_u32(&x453, &x454, x452, x428, x425); + fiat_sm2_scalar_addcarryx_u32(&x455, &x456, 0x0, x407, x439); + fiat_sm2_scalar_addcarryx_u32(&x457, &x458, x456, x409, x441); + fiat_sm2_scalar_addcarryx_u32(&x459, &x460, x458, x411, x443); + fiat_sm2_scalar_addcarryx_u32(&x461, &x462, x460, x413, x445); + fiat_sm2_scalar_addcarryx_u32(&x463, &x464, x462, x415, x447); + fiat_sm2_scalar_addcarryx_u32(&x465, &x466, x464, x417, x449); + fiat_sm2_scalar_addcarryx_u32(&x467, &x468, x466, x419, x451); + fiat_sm2_scalar_addcarryx_u32(&x469, &x470, x468, x421, x453); + fiat_sm2_scalar_addcarryx_u32(&x471, &x472, x470, (((uint32_t)x422 + x376) + (x406 + x378)), (x454 + x426)); + fiat_sm2_scalar_mulx_u32(&x473, &x474, x5, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x475, &x476, x5, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x477, &x478, x5, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x479, &x480, x5, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x481, &x482, x5, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x483, &x484, x5, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x485, &x486, x5, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x487, &x488, x5, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x489, &x490, 0x0, x488, x485); + fiat_sm2_scalar_addcarryx_u32(&x491, &x492, x490, x486, x483); + fiat_sm2_scalar_addcarryx_u32(&x493, &x494, x492, x484, x481); + fiat_sm2_scalar_addcarryx_u32(&x495, &x496, x494, x482, x479); + fiat_sm2_scalar_addcarryx_u32(&x497, &x498, x496, x480, x477); + fiat_sm2_scalar_addcarryx_u32(&x499, &x500, x498, x478, x475); + fiat_sm2_scalar_addcarryx_u32(&x501, &x502, x500, x476, x473); + fiat_sm2_scalar_addcarryx_u32(&x503, &x504, 0x0, x457, x487); + fiat_sm2_scalar_addcarryx_u32(&x505, &x506, x504, x459, x489); + fiat_sm2_scalar_addcarryx_u32(&x507, &x508, x506, x461, x491); + fiat_sm2_scalar_addcarryx_u32(&x509, &x510, x508, x463, x493); + fiat_sm2_scalar_addcarryx_u32(&x511, &x512, x510, x465, x495); + fiat_sm2_scalar_addcarryx_u32(&x513, &x514, x512, x467, x497); + fiat_sm2_scalar_addcarryx_u32(&x515, &x516, x514, x469, x499); + fiat_sm2_scalar_addcarryx_u32(&x517, &x518, x516, x471, x501); + fiat_sm2_scalar_mulx_u32(&x519, &x520, x503, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x521, &x522, x519, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x523, &x524, x519, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x525, &x526, x519, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x527, &x528, x519, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x529, &x530, x519, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x531, &x532, x519, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x533, &x534, x519, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x535, &x536, x519, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x537, &x538, 0x0, x536, x533); + fiat_sm2_scalar_addcarryx_u32(&x539, &x540, x538, x534, x531); + fiat_sm2_scalar_addcarryx_u32(&x541, &x542, x540, x532, x529); + fiat_sm2_scalar_addcarryx_u32(&x543, &x544, x542, x530, x527); + fiat_sm2_scalar_addcarryx_u32(&x545, &x546, x544, x528, x525); + fiat_sm2_scalar_addcarryx_u32(&x547, &x548, x546, x526, x523); + fiat_sm2_scalar_addcarryx_u32(&x549, &x550, x548, x524, x521); + fiat_sm2_scalar_addcarryx_u32(&x551, &x552, 0x0, x503, x535); + fiat_sm2_scalar_addcarryx_u32(&x553, &x554, x552, x505, x537); + fiat_sm2_scalar_addcarryx_u32(&x555, &x556, x554, x507, x539); + fiat_sm2_scalar_addcarryx_u32(&x557, &x558, x556, x509, x541); + fiat_sm2_scalar_addcarryx_u32(&x559, &x560, x558, x511, x543); + fiat_sm2_scalar_addcarryx_u32(&x561, &x562, x560, x513, x545); + fiat_sm2_scalar_addcarryx_u32(&x563, &x564, x562, x515, x547); + fiat_sm2_scalar_addcarryx_u32(&x565, &x566, x564, x517, x549); + fiat_sm2_scalar_addcarryx_u32(&x567, &x568, x566, (((uint32_t)x518 + x472) + (x502 + x474)), (x550 + x522)); + fiat_sm2_scalar_mulx_u32(&x569, &x570, x6, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x571, &x572, x6, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x573, &x574, x6, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x575, &x576, x6, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x577, &x578, x6, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x579, &x580, x6, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x581, &x582, x6, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x583, &x584, x6, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x585, &x586, 0x0, x584, x581); + fiat_sm2_scalar_addcarryx_u32(&x587, &x588, x586, x582, x579); + fiat_sm2_scalar_addcarryx_u32(&x589, &x590, x588, x580, x577); + fiat_sm2_scalar_addcarryx_u32(&x591, &x592, x590, x578, x575); + fiat_sm2_scalar_addcarryx_u32(&x593, &x594, x592, x576, x573); + fiat_sm2_scalar_addcarryx_u32(&x595, &x596, x594, x574, x571); + fiat_sm2_scalar_addcarryx_u32(&x597, &x598, x596, x572, x569); + fiat_sm2_scalar_addcarryx_u32(&x599, &x600, 0x0, x553, x583); + fiat_sm2_scalar_addcarryx_u32(&x601, &x602, x600, x555, x585); + fiat_sm2_scalar_addcarryx_u32(&x603, &x604, x602, x557, x587); + fiat_sm2_scalar_addcarryx_u32(&x605, &x606, x604, x559, x589); + fiat_sm2_scalar_addcarryx_u32(&x607, &x608, x606, x561, x591); + fiat_sm2_scalar_addcarryx_u32(&x609, &x610, x608, x563, x593); + fiat_sm2_scalar_addcarryx_u32(&x611, &x612, x610, x565, x595); + fiat_sm2_scalar_addcarryx_u32(&x613, &x614, x612, x567, x597); + fiat_sm2_scalar_mulx_u32(&x615, &x616, x599, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x617, &x618, x615, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x619, &x620, x615, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x621, &x622, x615, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x623, &x624, x615, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x625, &x626, x615, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x627, &x628, x615, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x629, &x630, x615, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x631, &x632, x615, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x633, &x634, 0x0, x632, x629); + fiat_sm2_scalar_addcarryx_u32(&x635, &x636, x634, x630, x627); + fiat_sm2_scalar_addcarryx_u32(&x637, &x638, x636, x628, x625); + fiat_sm2_scalar_addcarryx_u32(&x639, &x640, x638, x626, x623); + fiat_sm2_scalar_addcarryx_u32(&x641, &x642, x640, x624, x621); + fiat_sm2_scalar_addcarryx_u32(&x643, &x644, x642, x622, x619); + fiat_sm2_scalar_addcarryx_u32(&x645, &x646, x644, x620, x617); + fiat_sm2_scalar_addcarryx_u32(&x647, &x648, 0x0, x599, x631); + fiat_sm2_scalar_addcarryx_u32(&x649, &x650, x648, x601, x633); + fiat_sm2_scalar_addcarryx_u32(&x651, &x652, x650, x603, x635); + fiat_sm2_scalar_addcarryx_u32(&x653, &x654, x652, x605, x637); + fiat_sm2_scalar_addcarryx_u32(&x655, &x656, x654, x607, x639); + fiat_sm2_scalar_addcarryx_u32(&x657, &x658, x656, x609, x641); + fiat_sm2_scalar_addcarryx_u32(&x659, &x660, x658, x611, x643); + fiat_sm2_scalar_addcarryx_u32(&x661, &x662, x660, x613, x645); + fiat_sm2_scalar_addcarryx_u32(&x663, &x664, x662, (((uint32_t)x614 + x568) + (x598 + x570)), (x646 + x618)); + fiat_sm2_scalar_mulx_u32(&x665, &x666, x7, UINT32_C(0x1eb5e412)); + fiat_sm2_scalar_mulx_u32(&x667, &x668, x7, UINT32_C(0xa22b3d3b)); + fiat_sm2_scalar_mulx_u32(&x669, &x670, x7, UINT32_C(0x620fc84c)); + fiat_sm2_scalar_mulx_u32(&x671, &x672, x7, UINT32_C(0x3affe0d4)); + fiat_sm2_scalar_mulx_u32(&x673, &x674, x7, UINT32_C(0x3464504a)); + fiat_sm2_scalar_mulx_u32(&x675, &x676, x7, UINT32_C(0xde6fa2fa)); + fiat_sm2_scalar_mulx_u32(&x677, &x678, x7, UINT32_C(0x901192af)); + fiat_sm2_scalar_mulx_u32(&x679, &x680, x7, UINT32_C(0x7c114f20)); + fiat_sm2_scalar_addcarryx_u32(&x681, &x682, 0x0, x680, x677); + fiat_sm2_scalar_addcarryx_u32(&x683, &x684, x682, x678, x675); + fiat_sm2_scalar_addcarryx_u32(&x685, &x686, x684, x676, x673); + fiat_sm2_scalar_addcarryx_u32(&x687, &x688, x686, x674, x671); + fiat_sm2_scalar_addcarryx_u32(&x689, &x690, x688, x672, x669); + fiat_sm2_scalar_addcarryx_u32(&x691, &x692, x690, x670, x667); + fiat_sm2_scalar_addcarryx_u32(&x693, &x694, x692, x668, x665); + fiat_sm2_scalar_addcarryx_u32(&x695, &x696, 0x0, x649, x679); + fiat_sm2_scalar_addcarryx_u32(&x697, &x698, x696, x651, x681); + fiat_sm2_scalar_addcarryx_u32(&x699, &x700, x698, x653, x683); + fiat_sm2_scalar_addcarryx_u32(&x701, &x702, x700, x655, x685); + fiat_sm2_scalar_addcarryx_u32(&x703, &x704, x702, x657, x687); + fiat_sm2_scalar_addcarryx_u32(&x705, &x706, x704, x659, x689); + fiat_sm2_scalar_addcarryx_u32(&x707, &x708, x706, x661, x691); + fiat_sm2_scalar_addcarryx_u32(&x709, &x710, x708, x663, x693); + fiat_sm2_scalar_mulx_u32(&x711, &x712, x695, UINT32_C(0x72350975)); + fiat_sm2_scalar_mulx_u32(&x713, &x714, x711, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_mulx_u32(&x715, &x716, x711, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x717, &x718, x711, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x719, &x720, x711, UINT32_C(0xffffffff)); + fiat_sm2_scalar_mulx_u32(&x721, &x722, x711, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_mulx_u32(&x723, &x724, x711, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_mulx_u32(&x725, &x726, x711, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_mulx_u32(&x727, &x728, x711, UINT32_C(0x39d54123)); + fiat_sm2_scalar_addcarryx_u32(&x729, &x730, 0x0, x728, x725); + fiat_sm2_scalar_addcarryx_u32(&x731, &x732, x730, x726, x723); + fiat_sm2_scalar_addcarryx_u32(&x733, &x734, x732, x724, x721); + fiat_sm2_scalar_addcarryx_u32(&x735, &x736, x734, x722, x719); + fiat_sm2_scalar_addcarryx_u32(&x737, &x738, x736, x720, x717); + fiat_sm2_scalar_addcarryx_u32(&x739, &x740, x738, x718, x715); + fiat_sm2_scalar_addcarryx_u32(&x741, &x742, x740, x716, x713); + fiat_sm2_scalar_addcarryx_u32(&x743, &x744, 0x0, x695, x727); + fiat_sm2_scalar_addcarryx_u32(&x745, &x746, x744, x697, x729); + fiat_sm2_scalar_addcarryx_u32(&x747, &x748, x746, x699, x731); + fiat_sm2_scalar_addcarryx_u32(&x749, &x750, x748, x701, x733); + fiat_sm2_scalar_addcarryx_u32(&x751, &x752, x750, x703, x735); + fiat_sm2_scalar_addcarryx_u32(&x753, &x754, x752, x705, x737); + fiat_sm2_scalar_addcarryx_u32(&x755, &x756, x754, x707, x739); + fiat_sm2_scalar_addcarryx_u32(&x757, &x758, x756, x709, x741); + fiat_sm2_scalar_addcarryx_u32(&x759, &x760, x758, (((uint32_t)x710 + x664) + (x694 + x666)), (x742 + x714)); + fiat_sm2_scalar_subborrowx_u32(&x761, &x762, 0x0, x745, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x763, &x764, x762, x747, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x765, &x766, x764, x749, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x767, &x768, x766, x751, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x769, &x770, x768, x753, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x771, &x772, x770, x755, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x773, &x774, x772, x757, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x775, &x776, x774, x759, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_subborrowx_u32(&x777, &x778, x776, x760, 0x0); + fiat_sm2_scalar_cmovznz_u32(&x779, x778, x761, x745); + fiat_sm2_scalar_cmovznz_u32(&x780, x778, x763, x747); + fiat_sm2_scalar_cmovznz_u32(&x781, x778, x765, x749); + fiat_sm2_scalar_cmovznz_u32(&x782, x778, x767, x751); + fiat_sm2_scalar_cmovznz_u32(&x783, x778, x769, x753); + fiat_sm2_scalar_cmovznz_u32(&x784, x778, x771, x755); + fiat_sm2_scalar_cmovznz_u32(&x785, x778, x773, x757); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_selectznz(uint32_t out1[8], fiat_sm2_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_sm2_scalar_cmovznz_u32(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_sm2_scalar_cmovznz_u32(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_sm2_scalar_cmovznz_u32(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_sm2_scalar_cmovznz_u32(&x4, arg1, (arg2[3]), (arg3[3])); + fiat_sm2_scalar_cmovznz_u32(&x5, arg1, (arg2[4]), (arg3[4])); + fiat_sm2_scalar_cmovznz_u32(&x6, arg1, (arg2[5]), (arg3[5])); + fiat_sm2_scalar_cmovznz_u32(&x7, arg1, (arg2[6]), (arg3[6])); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_set_one(fiat_sm2_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT32_C(0xc62abedd); + out1[1] = UINT32_C(0xac440bf6); + out1[2] = UINT32_C(0xde39fad4); + out1[3] = UINT32_C(0x8dfc2094); + out1[4] = 0x0; + out1[5] = 0x0; + out1[6] = 0x0; + out1[7] = 0x1; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_msat(uint32_t out1[9]) { + out1[0] = UINT32_C(0x39d54123); + out1[1] = UINT32_C(0x53bbf409); + out1[2] = UINT32_C(0x21c6052b); + out1[3] = UINT32_C(0x7203df6b); + out1[4] = UINT32_C(0xffffffff); + out1[5] = UINT32_C(0xffffffff); + out1[6] = UINT32_C(0xffffffff); + out1[7] = UINT32_C(0xfffffffe); + out1[8] = 0x0; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_scalar_uint1 x2; + fiat_sm2_scalar_uint1 x3; + uint32_t x4; + fiat_sm2_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_sm2_scalar_uint1 x17; + uint32_t x18; + fiat_sm2_scalar_uint1 x19; + uint32_t x20; + fiat_sm2_scalar_uint1 x21; + uint32_t x22; + fiat_sm2_scalar_uint1 x23; + uint32_t x24; + fiat_sm2_scalar_uint1 x25; + uint32_t x26; + fiat_sm2_scalar_uint1 x27; + uint32_t x28; + fiat_sm2_scalar_uint1 x29; + uint32_t x30; + fiat_sm2_scalar_uint1 x31; + uint32_t x32; + fiat_sm2_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_sm2_scalar_uint1 x52; + uint32_t x53; + fiat_sm2_scalar_uint1 x54; + uint32_t x55; + fiat_sm2_scalar_uint1 x56; + uint32_t x57; + fiat_sm2_scalar_uint1 x58; + uint32_t x59; + fiat_sm2_scalar_uint1 x60; + uint32_t x61; + fiat_sm2_scalar_uint1 x62; + uint32_t x63; + fiat_sm2_scalar_uint1 x64; + uint32_t x65; + fiat_sm2_scalar_uint1 x66; + uint32_t x67; + fiat_sm2_scalar_uint1 x68; + uint32_t x69; + fiat_sm2_scalar_uint1 x70; + uint32_t x71; + fiat_sm2_scalar_uint1 x72; + uint32_t x73; + fiat_sm2_scalar_uint1 x74; + uint32_t x75; + fiat_sm2_scalar_uint1 x76; + uint32_t x77; + fiat_sm2_scalar_uint1 x78; + uint32_t x79; + fiat_sm2_scalar_uint1 x80; + uint32_t x81; + fiat_sm2_scalar_uint1 x82; + uint32_t x83; + fiat_sm2_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_sm2_scalar_uint1 x94; + uint32_t x95; + fiat_sm2_scalar_uint1 x96; + uint32_t x97; + fiat_sm2_scalar_uint1 x98; + uint32_t x99; + fiat_sm2_scalar_uint1 x100; + uint32_t x101; + fiat_sm2_scalar_uint1 x102; + uint32_t x103; + fiat_sm2_scalar_uint1 x104; + uint32_t x105; + fiat_sm2_scalar_uint1 x106; + uint32_t x107; + fiat_sm2_scalar_uint1 x108; + uint32_t x109; + uint32_t x110; + fiat_sm2_scalar_uint1 x111; + uint32_t x112; + fiat_sm2_scalar_uint1 x113; + uint32_t x114; + fiat_sm2_scalar_uint1 x115; + uint32_t x116; + fiat_sm2_scalar_uint1 x117; + uint32_t x118; + fiat_sm2_scalar_uint1 x119; + uint32_t x120; + fiat_sm2_scalar_uint1 x121; + uint32_t x122; + fiat_sm2_scalar_uint1 x123; + uint32_t x124; + fiat_sm2_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_sm2_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_sm2_scalar_uint1 x145; + uint32_t x146; + fiat_sm2_scalar_uint1 x147; + uint32_t x148; + fiat_sm2_scalar_uint1 x149; + uint32_t x150; + fiat_sm2_scalar_uint1 x151; + uint32_t x152; + fiat_sm2_scalar_uint1 x153; + uint32_t x154; + fiat_sm2_scalar_uint1 x155; + uint32_t x156; + fiat_sm2_scalar_uint1 x157; + uint32_t x158; + fiat_sm2_scalar_uint1 x159; + uint32_t x160; + fiat_sm2_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_sm2_scalar_uint1 x171; + uint32_t x172; + fiat_sm2_scalar_uint1 x173; + uint32_t x174; + fiat_sm2_scalar_uint1 x175; + uint32_t x176; + fiat_sm2_scalar_uint1 x177; + uint32_t x178; + fiat_sm2_scalar_uint1 x179; + uint32_t x180; + fiat_sm2_scalar_uint1 x181; + uint32_t x182; + fiat_sm2_scalar_uint1 x183; + uint32_t x184; + fiat_sm2_scalar_uint1 x185; + uint32_t x186; + fiat_sm2_scalar_uint1 x187; + uint32_t x188; + fiat_sm2_scalar_uint1 x189; + uint32_t x190; + fiat_sm2_scalar_uint1 x191; + uint32_t x192; + fiat_sm2_scalar_uint1 x193; + uint32_t x194; + fiat_sm2_scalar_uint1 x195; + uint32_t x196; + fiat_sm2_scalar_uint1 x197; + uint32_t x198; + fiat_sm2_scalar_uint1 x199; + uint32_t x200; + fiat_sm2_scalar_uint1 x201; + uint32_t x202; + fiat_sm2_scalar_uint1 x203; + uint32_t x204; + fiat_sm2_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_sm2_scalar_addcarryx_u32(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_sm2_scalar_uint1)((fiat_sm2_scalar_uint1)(x1 >> 31) & (fiat_sm2_scalar_uint1)((arg3[0]) & 0x1)); + fiat_sm2_scalar_addcarryx_u32(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_sm2_scalar_cmovznz_u32(&x6, x3, arg1, x4); + fiat_sm2_scalar_cmovznz_u32(&x7, x3, (arg2[0]), (arg3[0])); + fiat_sm2_scalar_cmovznz_u32(&x8, x3, (arg2[1]), (arg3[1])); + fiat_sm2_scalar_cmovznz_u32(&x9, x3, (arg2[2]), (arg3[2])); + fiat_sm2_scalar_cmovznz_u32(&x10, x3, (arg2[3]), (arg3[3])); + fiat_sm2_scalar_cmovznz_u32(&x11, x3, (arg2[4]), (arg3[4])); + fiat_sm2_scalar_cmovznz_u32(&x12, x3, (arg2[5]), (arg3[5])); + fiat_sm2_scalar_cmovznz_u32(&x13, x3, (arg2[6]), (arg3[6])); + fiat_sm2_scalar_cmovznz_u32(&x14, x3, (arg2[7]), (arg3[7])); + fiat_sm2_scalar_cmovznz_u32(&x15, x3, (arg2[8]), (arg3[8])); + fiat_sm2_scalar_addcarryx_u32(&x16, &x17, 0x0, 0x1, (~(arg2[0]))); + fiat_sm2_scalar_addcarryx_u32(&x18, &x19, x17, 0x0, (~(arg2[1]))); + fiat_sm2_scalar_addcarryx_u32(&x20, &x21, x19, 0x0, (~(arg2[2]))); + fiat_sm2_scalar_addcarryx_u32(&x22, &x23, x21, 0x0, (~(arg2[3]))); + fiat_sm2_scalar_addcarryx_u32(&x24, &x25, x23, 0x0, (~(arg2[4]))); + fiat_sm2_scalar_addcarryx_u32(&x26, &x27, x25, 0x0, (~(arg2[5]))); + fiat_sm2_scalar_addcarryx_u32(&x28, &x29, x27, 0x0, (~(arg2[6]))); + fiat_sm2_scalar_addcarryx_u32(&x30, &x31, x29, 0x0, (~(arg2[7]))); + fiat_sm2_scalar_addcarryx_u32(&x32, &x33, x31, 0x0, (~(arg2[8]))); + fiat_sm2_scalar_cmovznz_u32(&x34, x3, (arg3[0]), x16); + fiat_sm2_scalar_cmovznz_u32(&x35, x3, (arg3[1]), x18); + fiat_sm2_scalar_cmovznz_u32(&x36, x3, (arg3[2]), x20); + fiat_sm2_scalar_cmovznz_u32(&x37, x3, (arg3[3]), x22); + fiat_sm2_scalar_cmovznz_u32(&x38, x3, (arg3[4]), x24); + fiat_sm2_scalar_cmovznz_u32(&x39, x3, (arg3[5]), x26); + fiat_sm2_scalar_cmovznz_u32(&x40, x3, (arg3[6]), x28); + fiat_sm2_scalar_cmovznz_u32(&x41, x3, (arg3[7]), x30); + fiat_sm2_scalar_cmovznz_u32(&x42, x3, (arg3[8]), x32); + fiat_sm2_scalar_cmovznz_u32(&x43, x3, (arg4[0]), (arg5[0])); + fiat_sm2_scalar_cmovznz_u32(&x44, x3, (arg4[1]), (arg5[1])); + fiat_sm2_scalar_cmovznz_u32(&x45, x3, (arg4[2]), (arg5[2])); + fiat_sm2_scalar_cmovznz_u32(&x46, x3, (arg4[3]), (arg5[3])); + fiat_sm2_scalar_cmovznz_u32(&x47, x3, (arg4[4]), (arg5[4])); + fiat_sm2_scalar_cmovznz_u32(&x48, x3, (arg4[5]), (arg5[5])); + fiat_sm2_scalar_cmovznz_u32(&x49, x3, (arg4[6]), (arg5[6])); + fiat_sm2_scalar_cmovznz_u32(&x50, x3, (arg4[7]), (arg5[7])); + fiat_sm2_scalar_addcarryx_u32(&x51, &x52, 0x0, x43, x43); + fiat_sm2_scalar_addcarryx_u32(&x53, &x54, x52, x44, x44); + fiat_sm2_scalar_addcarryx_u32(&x55, &x56, x54, x45, x45); + fiat_sm2_scalar_addcarryx_u32(&x57, &x58, x56, x46, x46); + fiat_sm2_scalar_addcarryx_u32(&x59, &x60, x58, x47, x47); + fiat_sm2_scalar_addcarryx_u32(&x61, &x62, x60, x48, x48); + fiat_sm2_scalar_addcarryx_u32(&x63, &x64, x62, x49, x49); + fiat_sm2_scalar_addcarryx_u32(&x65, &x66, x64, x50, x50); + fiat_sm2_scalar_subborrowx_u32(&x67, &x68, 0x0, x51, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x69, &x70, x68, x53, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x71, &x72, x70, x55, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x73, &x74, x72, x57, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x75, &x76, x74, x59, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x77, &x78, x76, x61, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x79, &x80, x78, x63, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x81, &x82, x80, x65, UINT32_C(0xfffffffe)); + fiat_sm2_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_sm2_scalar_subborrowx_u32(&x93, &x94, 0x0, 0x0, x92); + fiat_sm2_scalar_subborrowx_u32(&x95, &x96, x94, 0x0, x91); + fiat_sm2_scalar_subborrowx_u32(&x97, &x98, x96, 0x0, x90); + fiat_sm2_scalar_subborrowx_u32(&x99, &x100, x98, 0x0, x89); + fiat_sm2_scalar_subborrowx_u32(&x101, &x102, x100, 0x0, x88); + fiat_sm2_scalar_subborrowx_u32(&x103, &x104, x102, 0x0, x87); + fiat_sm2_scalar_subborrowx_u32(&x105, &x106, x104, 0x0, x86); + fiat_sm2_scalar_subborrowx_u32(&x107, &x108, x106, 0x0, x85); + fiat_sm2_scalar_cmovznz_u32(&x109, x108, 0x0, UINT32_C(0xffffffff)); + fiat_sm2_scalar_addcarryx_u32(&x110, &x111, 0x0, x93, (x109 & UINT32_C(0x39d54123))); + fiat_sm2_scalar_addcarryx_u32(&x112, &x113, x111, x95, (x109 & UINT32_C(0x53bbf409))); + fiat_sm2_scalar_addcarryx_u32(&x114, &x115, x113, x97, (x109 & UINT32_C(0x21c6052b))); + fiat_sm2_scalar_addcarryx_u32(&x116, &x117, x115, x99, (x109 & UINT32_C(0x7203df6b))); + fiat_sm2_scalar_addcarryx_u32(&x118, &x119, x117, x101, x109); + fiat_sm2_scalar_addcarryx_u32(&x120, &x121, x119, x103, x109); + fiat_sm2_scalar_addcarryx_u32(&x122, &x123, x121, x105, x109); + fiat_sm2_scalar_addcarryx_u32(&x124, &x125, x123, x107, (x109 & UINT32_C(0xfffffffe))); + fiat_sm2_scalar_cmovznz_u32(&x126, x3, (arg5[0]), x110); + fiat_sm2_scalar_cmovznz_u32(&x127, x3, (arg5[1]), x112); + fiat_sm2_scalar_cmovznz_u32(&x128, x3, (arg5[2]), x114); + fiat_sm2_scalar_cmovznz_u32(&x129, x3, (arg5[3]), x116); + fiat_sm2_scalar_cmovznz_u32(&x130, x3, (arg5[4]), x118); + fiat_sm2_scalar_cmovznz_u32(&x131, x3, (arg5[5]), x120); + fiat_sm2_scalar_cmovznz_u32(&x132, x3, (arg5[6]), x122); + fiat_sm2_scalar_cmovznz_u32(&x133, x3, (arg5[7]), x124); + x134 = (fiat_sm2_scalar_uint1)(x34 & 0x1); + fiat_sm2_scalar_cmovznz_u32(&x135, x134, 0x0, x7); + fiat_sm2_scalar_cmovznz_u32(&x136, x134, 0x0, x8); + fiat_sm2_scalar_cmovznz_u32(&x137, x134, 0x0, x9); + fiat_sm2_scalar_cmovznz_u32(&x138, x134, 0x0, x10); + fiat_sm2_scalar_cmovznz_u32(&x139, x134, 0x0, x11); + fiat_sm2_scalar_cmovznz_u32(&x140, x134, 0x0, x12); + fiat_sm2_scalar_cmovznz_u32(&x141, x134, 0x0, x13); + fiat_sm2_scalar_cmovznz_u32(&x142, x134, 0x0, x14); + fiat_sm2_scalar_cmovznz_u32(&x143, x134, 0x0, x15); + fiat_sm2_scalar_addcarryx_u32(&x144, &x145, 0x0, x34, x135); + fiat_sm2_scalar_addcarryx_u32(&x146, &x147, x145, x35, x136); + fiat_sm2_scalar_addcarryx_u32(&x148, &x149, x147, x36, x137); + fiat_sm2_scalar_addcarryx_u32(&x150, &x151, x149, x37, x138); + fiat_sm2_scalar_addcarryx_u32(&x152, &x153, x151, x38, x139); + fiat_sm2_scalar_addcarryx_u32(&x154, &x155, x153, x39, x140); + fiat_sm2_scalar_addcarryx_u32(&x156, &x157, x155, x40, x141); + fiat_sm2_scalar_addcarryx_u32(&x158, &x159, x157, x41, x142); + fiat_sm2_scalar_addcarryx_u32(&x160, &x161, x159, x42, x143); + fiat_sm2_scalar_cmovznz_u32(&x162, x134, 0x0, x43); + fiat_sm2_scalar_cmovznz_u32(&x163, x134, 0x0, x44); + fiat_sm2_scalar_cmovznz_u32(&x164, x134, 0x0, x45); + fiat_sm2_scalar_cmovznz_u32(&x165, x134, 0x0, x46); + fiat_sm2_scalar_cmovznz_u32(&x166, x134, 0x0, x47); + fiat_sm2_scalar_cmovznz_u32(&x167, x134, 0x0, x48); + fiat_sm2_scalar_cmovznz_u32(&x168, x134, 0x0, x49); + fiat_sm2_scalar_cmovznz_u32(&x169, x134, 0x0, x50); + fiat_sm2_scalar_addcarryx_u32(&x170, &x171, 0x0, x126, x162); + fiat_sm2_scalar_addcarryx_u32(&x172, &x173, x171, x127, x163); + fiat_sm2_scalar_addcarryx_u32(&x174, &x175, x173, x128, x164); + fiat_sm2_scalar_addcarryx_u32(&x176, &x177, x175, x129, x165); + fiat_sm2_scalar_addcarryx_u32(&x178, &x179, x177, x130, x166); + fiat_sm2_scalar_addcarryx_u32(&x180, &x181, x179, x131, x167); + fiat_sm2_scalar_addcarryx_u32(&x182, &x183, x181, x132, x168); + fiat_sm2_scalar_addcarryx_u32(&x184, &x185, x183, x133, x169); + fiat_sm2_scalar_subborrowx_u32(&x186, &x187, 0x0, x170, UINT32_C(0x39d54123)); + fiat_sm2_scalar_subborrowx_u32(&x188, &x189, x187, x172, UINT32_C(0x53bbf409)); + fiat_sm2_scalar_subborrowx_u32(&x190, &x191, x189, x174, UINT32_C(0x21c6052b)); + fiat_sm2_scalar_subborrowx_u32(&x192, &x193, x191, x176, UINT32_C(0x7203df6b)); + fiat_sm2_scalar_subborrowx_u32(&x194, &x195, x193, x178, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x196, &x197, x195, x180, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x198, &x199, x197, x182, UINT32_C(0xffffffff)); + fiat_sm2_scalar_subborrowx_u32(&x200, &x201, x199, x184, UINT32_C(0xfffffffe)); + fiat_sm2_scalar_subborrowx_u32(&x202, &x203, x201, x185, 0x0); + fiat_sm2_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_sm2_scalar_cmovznz_u32(&x215, x84, x67, x51); + fiat_sm2_scalar_cmovznz_u32(&x216, x84, x69, x53); + fiat_sm2_scalar_cmovznz_u32(&x217, x84, x71, x55); + fiat_sm2_scalar_cmovznz_u32(&x218, x84, x73, x57); + fiat_sm2_scalar_cmovznz_u32(&x219, x84, x75, x59); + fiat_sm2_scalar_cmovznz_u32(&x220, x84, x77, x61); + fiat_sm2_scalar_cmovznz_u32(&x221, x84, x79, x63); + fiat_sm2_scalar_cmovznz_u32(&x222, x84, x81, x65); + fiat_sm2_scalar_cmovznz_u32(&x223, x203, x186, x170); + fiat_sm2_scalar_cmovznz_u32(&x224, x203, x188, x172); + fiat_sm2_scalar_cmovznz_u32(&x225, x203, x190, x174); + fiat_sm2_scalar_cmovznz_u32(&x226, x203, x192, x176); + fiat_sm2_scalar_cmovznz_u32(&x227, x203, x194, x178); + fiat_sm2_scalar_cmovznz_u32(&x228, x203, x196, x180); + fiat_sm2_scalar_cmovznz_u32(&x229, x203, x198, x182); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_divstep_precomp(uint32_t out1[8]) { + out1[0] = UINT32_C(0xb351756d); + out1[1] = UINT32_C(0x1aa32707); + out1[2] = UINT32_C(0x1e2a62fa); + out1[3] = UINT32_C(0xabdd67); + out1[4] = UINT32_C(0xd4009a81); + out1[5] = UINT32_C(0x49280d7d); + out1[6] = UINT32_C(0xe6bb86e8); + out1[7] = UINT32_C(0xd730336e); +} diff --git a/fiat-c/src/sm2_scalar_64.c b/fiat-c/src/sm2_scalar_64.c new file mode 100644 index 00000000000..d97a6faa3bc --- /dev/null +++ b/fiat-c/src/sm2_scalar_64.c @@ -0,0 +1,2215 @@ +/* Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --inline --static --use-value-barrier sm2_scalar 64 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") */ +/* */ +/* 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_sm2_scalar_uint1; +typedef signed char fiat_sm2_scalar_int1; +#if defined(__GNUC__) || defined(__clang__) +# define FIAT_SM2_SCALAR_FIAT_EXTENSION __extension__ +# define FIAT_SM2_SCALAR_FIAT_INLINE __inline__ +#else +# define FIAT_SM2_SCALAR_FIAT_EXTENSION +# define FIAT_SM2_SCALAR_FIAT_INLINE +#endif + +FIAT_SM2_SCALAR_FIAT_EXTENSION typedef signed __int128 fiat_sm2_scalar_int128; +FIAT_SM2_SCALAR_FIAT_EXTENSION typedef unsigned __int128 fiat_sm2_scalar_uint128; + +/* The type fiat_sm2_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_sm2_scalar_montgomery_domain_field_element[4]; + +/* The type fiat_sm2_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_sm2_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_SM2_SCALAR_NO_ASM) && (defined(__GNUC__) || defined(__clang__)) +static __inline__ uint64_t fiat_sm2_scalar_value_barrier_u64(uint64_t a) { + __asm__("" : "+r"(a) : /* no inputs */); + return a; +} +#else +# define fiat_sm2_scalar_value_barrier_u64(x) (x) +#endif + + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_addcarryx_u64(uint64_t* out1, fiat_sm2_scalar_uint1* out2, fiat_sm2_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_sm2_scalar_uint128 x1; + uint64_t x2; + fiat_sm2_scalar_uint1 x3; + x1 = ((arg1 + (fiat_sm2_scalar_uint128)arg2) + arg3); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (fiat_sm2_scalar_uint1)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_subborrowx_u64(uint64_t* out1, fiat_sm2_scalar_uint1* out2, fiat_sm2_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_sm2_scalar_int128 x1; + fiat_sm2_scalar_int1 x2; + uint64_t x3; + x1 = ((arg2 - (fiat_sm2_scalar_int128)arg1) - arg3); + x2 = (fiat_sm2_scalar_int1)(x1 >> 64); + x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + *out1 = x3; + *out2 = (fiat_sm2_scalar_uint1)(0x0 - x2); +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) { + fiat_sm2_scalar_uint128 x1; + uint64_t x2; + uint64_t x3; + x1 = ((fiat_sm2_scalar_uint128)arg1 * arg2); + x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff)); + x3 = (uint64_t)(x1 >> 64); + *out1 = x2; + *out2 = x3; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_cmovznz_u64(uint64_t* out1, fiat_sm2_scalar_uint1 arg1, uint64_t arg2, uint64_t arg3) { + fiat_sm2_scalar_uint1 x1; + uint64_t x2; + uint64_t x3; + x1 = (!(!arg1)); + x2 = ((fiat_sm2_scalar_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff)); + x3 = ((fiat_sm2_scalar_value_barrier_u64(x2) & arg3) | (fiat_sm2_scalar_value_barrier_u64((~x2)) & arg2)); + *out1 = x3; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_mul(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1, const fiat_sm2_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_sm2_scalar_uint1 x14; + uint64_t x15; + fiat_sm2_scalar_uint1 x16; + uint64_t x17; + fiat_sm2_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_sm2_scalar_uint1 x31; + uint64_t x32; + fiat_sm2_scalar_uint1 x33; + uint64_t x34; + fiat_sm2_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_sm2_scalar_uint1 x38; + uint64_t x39; + fiat_sm2_scalar_uint1 x40; + uint64_t x41; + fiat_sm2_scalar_uint1 x42; + uint64_t x43; + fiat_sm2_scalar_uint1 x44; + uint64_t x45; + fiat_sm2_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_sm2_scalar_uint1 x56; + uint64_t x57; + fiat_sm2_scalar_uint1 x58; + uint64_t x59; + fiat_sm2_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_sm2_scalar_uint1 x63; + uint64_t x64; + fiat_sm2_scalar_uint1 x65; + uint64_t x66; + fiat_sm2_scalar_uint1 x67; + uint64_t x68; + fiat_sm2_scalar_uint1 x69; + uint64_t x70; + fiat_sm2_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_sm2_scalar_uint1 x83; + uint64_t x84; + fiat_sm2_scalar_uint1 x85; + uint64_t x86; + fiat_sm2_scalar_uint1 x87; + uint64_t x88; + uint64_t x89; + fiat_sm2_scalar_uint1 x90; + uint64_t x91; + fiat_sm2_scalar_uint1 x92; + uint64_t x93; + fiat_sm2_scalar_uint1 x94; + uint64_t x95; + fiat_sm2_scalar_uint1 x96; + uint64_t x97; + fiat_sm2_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_sm2_scalar_uint1 x109; + uint64_t x110; + fiat_sm2_scalar_uint1 x111; + uint64_t x112; + fiat_sm2_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + fiat_sm2_scalar_uint1 x116; + uint64_t x117; + fiat_sm2_scalar_uint1 x118; + uint64_t x119; + fiat_sm2_scalar_uint1 x120; + uint64_t x121; + fiat_sm2_scalar_uint1 x122; + uint64_t x123; + fiat_sm2_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_sm2_scalar_uint1 x136; + uint64_t x137; + fiat_sm2_scalar_uint1 x138; + uint64_t x139; + fiat_sm2_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + fiat_sm2_scalar_uint1 x143; + uint64_t x144; + fiat_sm2_scalar_uint1 x145; + uint64_t x146; + fiat_sm2_scalar_uint1 x147; + uint64_t x148; + fiat_sm2_scalar_uint1 x149; + uint64_t x150; + fiat_sm2_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_sm2_scalar_uint1 x162; + uint64_t x163; + fiat_sm2_scalar_uint1 x164; + uint64_t x165; + fiat_sm2_scalar_uint1 x166; + uint64_t x167; + uint64_t x168; + fiat_sm2_scalar_uint1 x169; + uint64_t x170; + fiat_sm2_scalar_uint1 x171; + uint64_t x172; + fiat_sm2_scalar_uint1 x173; + uint64_t x174; + fiat_sm2_scalar_uint1 x175; + uint64_t x176; + fiat_sm2_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_sm2_scalar_uint1 x189; + uint64_t x190; + fiat_sm2_scalar_uint1 x191; + uint64_t x192; + fiat_sm2_scalar_uint1 x193; + uint64_t x194; + uint64_t x195; + fiat_sm2_scalar_uint1 x196; + uint64_t x197; + fiat_sm2_scalar_uint1 x198; + uint64_t x199; + fiat_sm2_scalar_uint1 x200; + uint64_t x201; + fiat_sm2_scalar_uint1 x202; + uint64_t x203; + fiat_sm2_scalar_uint1 x204; + uint64_t x205; + uint64_t x206; + fiat_sm2_scalar_uint1 x207; + uint64_t x208; + fiat_sm2_scalar_uint1 x209; + uint64_t x210; + fiat_sm2_scalar_uint1 x211; + uint64_t x212; + fiat_sm2_scalar_uint1 x213; + uint64_t x214; + fiat_sm2_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_sm2_scalar_mulx_u64(&x5, &x6, x4, (arg2[3])); + fiat_sm2_scalar_mulx_u64(&x7, &x8, x4, (arg2[2])); + fiat_sm2_scalar_mulx_u64(&x9, &x10, x4, (arg2[1])); + fiat_sm2_scalar_mulx_u64(&x11, &x12, x4, (arg2[0])); + fiat_sm2_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_sm2_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_sm2_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_sm2_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x28, &x29, x20, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x30, &x31, 0x0, x29, x26); + fiat_sm2_scalar_addcarryx_u64(&x32, &x33, x31, x27, x24); + fiat_sm2_scalar_addcarryx_u64(&x34, &x35, x33, x25, x22); + x36 = (x35 + x23); + fiat_sm2_scalar_addcarryx_u64(&x37, &x38, 0x0, x11, x28); + fiat_sm2_scalar_addcarryx_u64(&x39, &x40, x38, x13, x30); + fiat_sm2_scalar_addcarryx_u64(&x41, &x42, x40, x15, x32); + fiat_sm2_scalar_addcarryx_u64(&x43, &x44, x42, x17, x34); + fiat_sm2_scalar_addcarryx_u64(&x45, &x46, x44, x19, x36); + fiat_sm2_scalar_mulx_u64(&x47, &x48, x1, (arg2[3])); + fiat_sm2_scalar_mulx_u64(&x49, &x50, x1, (arg2[2])); + fiat_sm2_scalar_mulx_u64(&x51, &x52, x1, (arg2[1])); + fiat_sm2_scalar_mulx_u64(&x53, &x54, x1, (arg2[0])); + fiat_sm2_scalar_addcarryx_u64(&x55, &x56, 0x0, x54, x51); + fiat_sm2_scalar_addcarryx_u64(&x57, &x58, x56, x52, x49); + fiat_sm2_scalar_addcarryx_u64(&x59, &x60, x58, x50, x47); + x61 = (x60 + x48); + fiat_sm2_scalar_addcarryx_u64(&x62, &x63, 0x0, x39, x53); + fiat_sm2_scalar_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_sm2_scalar_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_sm2_scalar_addcarryx_u64(&x68, &x69, x67, x45, x59); + fiat_sm2_scalar_addcarryx_u64(&x70, &x71, x69, x46, x61); + fiat_sm2_scalar_mulx_u64(&x72, &x73, x62, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x74, &x75, x72, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x76, &x77, x72, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x78, &x79, x72, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x80, &x81, x72, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x82, &x83, 0x0, x81, x78); + fiat_sm2_scalar_addcarryx_u64(&x84, &x85, x83, x79, x76); + fiat_sm2_scalar_addcarryx_u64(&x86, &x87, x85, x77, x74); + x88 = (x87 + x75); + fiat_sm2_scalar_addcarryx_u64(&x89, &x90, 0x0, x62, x80); + fiat_sm2_scalar_addcarryx_u64(&x91, &x92, x90, x64, x82); + fiat_sm2_scalar_addcarryx_u64(&x93, &x94, x92, x66, x84); + fiat_sm2_scalar_addcarryx_u64(&x95, &x96, x94, x68, x86); + fiat_sm2_scalar_addcarryx_u64(&x97, &x98, x96, x70, x88); + x99 = ((uint64_t)x98 + x71); + fiat_sm2_scalar_mulx_u64(&x100, &x101, x2, (arg2[3])); + fiat_sm2_scalar_mulx_u64(&x102, &x103, x2, (arg2[2])); + fiat_sm2_scalar_mulx_u64(&x104, &x105, x2, (arg2[1])); + fiat_sm2_scalar_mulx_u64(&x106, &x107, x2, (arg2[0])); + fiat_sm2_scalar_addcarryx_u64(&x108, &x109, 0x0, x107, x104); + fiat_sm2_scalar_addcarryx_u64(&x110, &x111, x109, x105, x102); + fiat_sm2_scalar_addcarryx_u64(&x112, &x113, x111, x103, x100); + x114 = (x113 + x101); + fiat_sm2_scalar_addcarryx_u64(&x115, &x116, 0x0, x91, x106); + fiat_sm2_scalar_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_sm2_scalar_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_sm2_scalar_addcarryx_u64(&x121, &x122, x120, x97, x112); + fiat_sm2_scalar_addcarryx_u64(&x123, &x124, x122, x99, x114); + fiat_sm2_scalar_mulx_u64(&x125, &x126, x115, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x127, &x128, x125, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x129, &x130, x125, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x131, &x132, x125, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x133, &x134, x125, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x135, &x136, 0x0, x134, x131); + fiat_sm2_scalar_addcarryx_u64(&x137, &x138, x136, x132, x129); + fiat_sm2_scalar_addcarryx_u64(&x139, &x140, x138, x130, x127); + x141 = (x140 + x128); + fiat_sm2_scalar_addcarryx_u64(&x142, &x143, 0x0, x115, x133); + fiat_sm2_scalar_addcarryx_u64(&x144, &x145, x143, x117, x135); + fiat_sm2_scalar_addcarryx_u64(&x146, &x147, x145, x119, x137); + fiat_sm2_scalar_addcarryx_u64(&x148, &x149, x147, x121, x139); + fiat_sm2_scalar_addcarryx_u64(&x150, &x151, x149, x123, x141); + x152 = ((uint64_t)x151 + x124); + fiat_sm2_scalar_mulx_u64(&x153, &x154, x3, (arg2[3])); + fiat_sm2_scalar_mulx_u64(&x155, &x156, x3, (arg2[2])); + fiat_sm2_scalar_mulx_u64(&x157, &x158, x3, (arg2[1])); + fiat_sm2_scalar_mulx_u64(&x159, &x160, x3, (arg2[0])); + fiat_sm2_scalar_addcarryx_u64(&x161, &x162, 0x0, x160, x157); + fiat_sm2_scalar_addcarryx_u64(&x163, &x164, x162, x158, x155); + fiat_sm2_scalar_addcarryx_u64(&x165, &x166, x164, x156, x153); + x167 = (x166 + x154); + fiat_sm2_scalar_addcarryx_u64(&x168, &x169, 0x0, x144, x159); + fiat_sm2_scalar_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_sm2_scalar_addcarryx_u64(&x172, &x173, x171, x148, x163); + fiat_sm2_scalar_addcarryx_u64(&x174, &x175, x173, x150, x165); + fiat_sm2_scalar_addcarryx_u64(&x176, &x177, x175, x152, x167); + fiat_sm2_scalar_mulx_u64(&x178, &x179, x168, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x180, &x181, x178, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x182, &x183, x178, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x184, &x185, x178, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x186, &x187, x178, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x188, &x189, 0x0, x187, x184); + fiat_sm2_scalar_addcarryx_u64(&x190, &x191, x189, x185, x182); + fiat_sm2_scalar_addcarryx_u64(&x192, &x193, x191, x183, x180); + x194 = (x193 + x181); + fiat_sm2_scalar_addcarryx_u64(&x195, &x196, 0x0, x168, x186); + fiat_sm2_scalar_addcarryx_u64(&x197, &x198, x196, x170, x188); + fiat_sm2_scalar_addcarryx_u64(&x199, &x200, x198, x172, x190); + fiat_sm2_scalar_addcarryx_u64(&x201, &x202, x200, x174, x192); + fiat_sm2_scalar_addcarryx_u64(&x203, &x204, x202, x176, x194); + x205 = ((uint64_t)x204 + x177); + fiat_sm2_scalar_subborrowx_u64(&x206, &x207, 0x0, x197, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x208, &x209, x207, x199, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x210, &x211, x209, x201, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x212, &x213, x211, x203, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x214, &x215, x213, x205, 0x0); + fiat_sm2_scalar_cmovznz_u64(&x216, x215, x206, x197); + fiat_sm2_scalar_cmovznz_u64(&x217, x215, x208, x199); + fiat_sm2_scalar_cmovznz_u64(&x218, x215, x210, x201); + fiat_sm2_scalar_cmovznz_u64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_square(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_scalar_uint1 x14; + uint64_t x15; + fiat_sm2_scalar_uint1 x16; + uint64_t x17; + fiat_sm2_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_sm2_scalar_uint1 x31; + uint64_t x32; + fiat_sm2_scalar_uint1 x33; + uint64_t x34; + fiat_sm2_scalar_uint1 x35; + uint64_t x36; + uint64_t x37; + fiat_sm2_scalar_uint1 x38; + uint64_t x39; + fiat_sm2_scalar_uint1 x40; + uint64_t x41; + fiat_sm2_scalar_uint1 x42; + uint64_t x43; + fiat_sm2_scalar_uint1 x44; + uint64_t x45; + fiat_sm2_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_sm2_scalar_uint1 x56; + uint64_t x57; + fiat_sm2_scalar_uint1 x58; + uint64_t x59; + fiat_sm2_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_sm2_scalar_uint1 x63; + uint64_t x64; + fiat_sm2_scalar_uint1 x65; + uint64_t x66; + fiat_sm2_scalar_uint1 x67; + uint64_t x68; + fiat_sm2_scalar_uint1 x69; + uint64_t x70; + fiat_sm2_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_sm2_scalar_uint1 x83; + uint64_t x84; + fiat_sm2_scalar_uint1 x85; + uint64_t x86; + fiat_sm2_scalar_uint1 x87; + uint64_t x88; + uint64_t x89; + fiat_sm2_scalar_uint1 x90; + uint64_t x91; + fiat_sm2_scalar_uint1 x92; + uint64_t x93; + fiat_sm2_scalar_uint1 x94; + uint64_t x95; + fiat_sm2_scalar_uint1 x96; + uint64_t x97; + fiat_sm2_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_sm2_scalar_uint1 x109; + uint64_t x110; + fiat_sm2_scalar_uint1 x111; + uint64_t x112; + fiat_sm2_scalar_uint1 x113; + uint64_t x114; + uint64_t x115; + fiat_sm2_scalar_uint1 x116; + uint64_t x117; + fiat_sm2_scalar_uint1 x118; + uint64_t x119; + fiat_sm2_scalar_uint1 x120; + uint64_t x121; + fiat_sm2_scalar_uint1 x122; + uint64_t x123; + fiat_sm2_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_sm2_scalar_uint1 x136; + uint64_t x137; + fiat_sm2_scalar_uint1 x138; + uint64_t x139; + fiat_sm2_scalar_uint1 x140; + uint64_t x141; + uint64_t x142; + fiat_sm2_scalar_uint1 x143; + uint64_t x144; + fiat_sm2_scalar_uint1 x145; + uint64_t x146; + fiat_sm2_scalar_uint1 x147; + uint64_t x148; + fiat_sm2_scalar_uint1 x149; + uint64_t x150; + fiat_sm2_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_sm2_scalar_uint1 x162; + uint64_t x163; + fiat_sm2_scalar_uint1 x164; + uint64_t x165; + fiat_sm2_scalar_uint1 x166; + uint64_t x167; + uint64_t x168; + fiat_sm2_scalar_uint1 x169; + uint64_t x170; + fiat_sm2_scalar_uint1 x171; + uint64_t x172; + fiat_sm2_scalar_uint1 x173; + uint64_t x174; + fiat_sm2_scalar_uint1 x175; + uint64_t x176; + fiat_sm2_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_sm2_scalar_uint1 x189; + uint64_t x190; + fiat_sm2_scalar_uint1 x191; + uint64_t x192; + fiat_sm2_scalar_uint1 x193; + uint64_t x194; + uint64_t x195; + fiat_sm2_scalar_uint1 x196; + uint64_t x197; + fiat_sm2_scalar_uint1 x198; + uint64_t x199; + fiat_sm2_scalar_uint1 x200; + uint64_t x201; + fiat_sm2_scalar_uint1 x202; + uint64_t x203; + fiat_sm2_scalar_uint1 x204; + uint64_t x205; + uint64_t x206; + fiat_sm2_scalar_uint1 x207; + uint64_t x208; + fiat_sm2_scalar_uint1 x209; + uint64_t x210; + fiat_sm2_scalar_uint1 x211; + uint64_t x212; + fiat_sm2_scalar_uint1 x213; + uint64_t x214; + fiat_sm2_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_sm2_scalar_mulx_u64(&x5, &x6, x4, (arg1[3])); + fiat_sm2_scalar_mulx_u64(&x7, &x8, x4, (arg1[2])); + fiat_sm2_scalar_mulx_u64(&x9, &x10, x4, (arg1[1])); + fiat_sm2_scalar_mulx_u64(&x11, &x12, x4, (arg1[0])); + fiat_sm2_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_sm2_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_sm2_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + x19 = (x18 + x6); + fiat_sm2_scalar_mulx_u64(&x20, &x21, x11, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x22, &x23, x20, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x24, &x25, x20, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x26, &x27, x20, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x28, &x29, x20, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x30, &x31, 0x0, x29, x26); + fiat_sm2_scalar_addcarryx_u64(&x32, &x33, x31, x27, x24); + fiat_sm2_scalar_addcarryx_u64(&x34, &x35, x33, x25, x22); + x36 = (x35 + x23); + fiat_sm2_scalar_addcarryx_u64(&x37, &x38, 0x0, x11, x28); + fiat_sm2_scalar_addcarryx_u64(&x39, &x40, x38, x13, x30); + fiat_sm2_scalar_addcarryx_u64(&x41, &x42, x40, x15, x32); + fiat_sm2_scalar_addcarryx_u64(&x43, &x44, x42, x17, x34); + fiat_sm2_scalar_addcarryx_u64(&x45, &x46, x44, x19, x36); + fiat_sm2_scalar_mulx_u64(&x47, &x48, x1, (arg1[3])); + fiat_sm2_scalar_mulx_u64(&x49, &x50, x1, (arg1[2])); + fiat_sm2_scalar_mulx_u64(&x51, &x52, x1, (arg1[1])); + fiat_sm2_scalar_mulx_u64(&x53, &x54, x1, (arg1[0])); + fiat_sm2_scalar_addcarryx_u64(&x55, &x56, 0x0, x54, x51); + fiat_sm2_scalar_addcarryx_u64(&x57, &x58, x56, x52, x49); + fiat_sm2_scalar_addcarryx_u64(&x59, &x60, x58, x50, x47); + x61 = (x60 + x48); + fiat_sm2_scalar_addcarryx_u64(&x62, &x63, 0x0, x39, x53); + fiat_sm2_scalar_addcarryx_u64(&x64, &x65, x63, x41, x55); + fiat_sm2_scalar_addcarryx_u64(&x66, &x67, x65, x43, x57); + fiat_sm2_scalar_addcarryx_u64(&x68, &x69, x67, x45, x59); + fiat_sm2_scalar_addcarryx_u64(&x70, &x71, x69, x46, x61); + fiat_sm2_scalar_mulx_u64(&x72, &x73, x62, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x74, &x75, x72, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x76, &x77, x72, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x78, &x79, x72, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x80, &x81, x72, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x82, &x83, 0x0, x81, x78); + fiat_sm2_scalar_addcarryx_u64(&x84, &x85, x83, x79, x76); + fiat_sm2_scalar_addcarryx_u64(&x86, &x87, x85, x77, x74); + x88 = (x87 + x75); + fiat_sm2_scalar_addcarryx_u64(&x89, &x90, 0x0, x62, x80); + fiat_sm2_scalar_addcarryx_u64(&x91, &x92, x90, x64, x82); + fiat_sm2_scalar_addcarryx_u64(&x93, &x94, x92, x66, x84); + fiat_sm2_scalar_addcarryx_u64(&x95, &x96, x94, x68, x86); + fiat_sm2_scalar_addcarryx_u64(&x97, &x98, x96, x70, x88); + x99 = ((uint64_t)x98 + x71); + fiat_sm2_scalar_mulx_u64(&x100, &x101, x2, (arg1[3])); + fiat_sm2_scalar_mulx_u64(&x102, &x103, x2, (arg1[2])); + fiat_sm2_scalar_mulx_u64(&x104, &x105, x2, (arg1[1])); + fiat_sm2_scalar_mulx_u64(&x106, &x107, x2, (arg1[0])); + fiat_sm2_scalar_addcarryx_u64(&x108, &x109, 0x0, x107, x104); + fiat_sm2_scalar_addcarryx_u64(&x110, &x111, x109, x105, x102); + fiat_sm2_scalar_addcarryx_u64(&x112, &x113, x111, x103, x100); + x114 = (x113 + x101); + fiat_sm2_scalar_addcarryx_u64(&x115, &x116, 0x0, x91, x106); + fiat_sm2_scalar_addcarryx_u64(&x117, &x118, x116, x93, x108); + fiat_sm2_scalar_addcarryx_u64(&x119, &x120, x118, x95, x110); + fiat_sm2_scalar_addcarryx_u64(&x121, &x122, x120, x97, x112); + fiat_sm2_scalar_addcarryx_u64(&x123, &x124, x122, x99, x114); + fiat_sm2_scalar_mulx_u64(&x125, &x126, x115, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x127, &x128, x125, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x129, &x130, x125, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x131, &x132, x125, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x133, &x134, x125, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x135, &x136, 0x0, x134, x131); + fiat_sm2_scalar_addcarryx_u64(&x137, &x138, x136, x132, x129); + fiat_sm2_scalar_addcarryx_u64(&x139, &x140, x138, x130, x127); + x141 = (x140 + x128); + fiat_sm2_scalar_addcarryx_u64(&x142, &x143, 0x0, x115, x133); + fiat_sm2_scalar_addcarryx_u64(&x144, &x145, x143, x117, x135); + fiat_sm2_scalar_addcarryx_u64(&x146, &x147, x145, x119, x137); + fiat_sm2_scalar_addcarryx_u64(&x148, &x149, x147, x121, x139); + fiat_sm2_scalar_addcarryx_u64(&x150, &x151, x149, x123, x141); + x152 = ((uint64_t)x151 + x124); + fiat_sm2_scalar_mulx_u64(&x153, &x154, x3, (arg1[3])); + fiat_sm2_scalar_mulx_u64(&x155, &x156, x3, (arg1[2])); + fiat_sm2_scalar_mulx_u64(&x157, &x158, x3, (arg1[1])); + fiat_sm2_scalar_mulx_u64(&x159, &x160, x3, (arg1[0])); + fiat_sm2_scalar_addcarryx_u64(&x161, &x162, 0x0, x160, x157); + fiat_sm2_scalar_addcarryx_u64(&x163, &x164, x162, x158, x155); + fiat_sm2_scalar_addcarryx_u64(&x165, &x166, x164, x156, x153); + x167 = (x166 + x154); + fiat_sm2_scalar_addcarryx_u64(&x168, &x169, 0x0, x144, x159); + fiat_sm2_scalar_addcarryx_u64(&x170, &x171, x169, x146, x161); + fiat_sm2_scalar_addcarryx_u64(&x172, &x173, x171, x148, x163); + fiat_sm2_scalar_addcarryx_u64(&x174, &x175, x173, x150, x165); + fiat_sm2_scalar_addcarryx_u64(&x176, &x177, x175, x152, x167); + fiat_sm2_scalar_mulx_u64(&x178, &x179, x168, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x180, &x181, x178, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x182, &x183, x178, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x184, &x185, x178, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x186, &x187, x178, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x188, &x189, 0x0, x187, x184); + fiat_sm2_scalar_addcarryx_u64(&x190, &x191, x189, x185, x182); + fiat_sm2_scalar_addcarryx_u64(&x192, &x193, x191, x183, x180); + x194 = (x193 + x181); + fiat_sm2_scalar_addcarryx_u64(&x195, &x196, 0x0, x168, x186); + fiat_sm2_scalar_addcarryx_u64(&x197, &x198, x196, x170, x188); + fiat_sm2_scalar_addcarryx_u64(&x199, &x200, x198, x172, x190); + fiat_sm2_scalar_addcarryx_u64(&x201, &x202, x200, x174, x192); + fiat_sm2_scalar_addcarryx_u64(&x203, &x204, x202, x176, x194); + x205 = ((uint64_t)x204 + x177); + fiat_sm2_scalar_subborrowx_u64(&x206, &x207, 0x0, x197, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x208, &x209, x207, x199, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x210, &x211, x209, x201, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x212, &x213, x211, x203, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x214, &x215, x213, x205, 0x0); + fiat_sm2_scalar_cmovznz_u64(&x216, x215, x206, x197); + fiat_sm2_scalar_cmovznz_u64(&x217, x215, x208, x199); + fiat_sm2_scalar_cmovznz_u64(&x218, x215, x210, x201); + fiat_sm2_scalar_cmovznz_u64(&x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_add(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1, const fiat_sm2_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_sm2_scalar_uint1 x2; + uint64_t x3; + fiat_sm2_scalar_uint1 x4; + uint64_t x5; + fiat_sm2_scalar_uint1 x6; + uint64_t x7; + fiat_sm2_scalar_uint1 x8; + uint64_t x9; + fiat_sm2_scalar_uint1 x10; + uint64_t x11; + fiat_sm2_scalar_uint1 x12; + uint64_t x13; + fiat_sm2_scalar_uint1 x14; + uint64_t x15; + fiat_sm2_scalar_uint1 x16; + uint64_t x17; + fiat_sm2_scalar_uint1 x18; + uint64_t x19; + uint64_t x20; + uint64_t x21; + uint64_t x22; + fiat_sm2_scalar_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_scalar_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_scalar_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_scalar_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_scalar_subborrowx_u64(&x9, &x10, 0x0, x1, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x11, &x12, x10, x3, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x13, &x14, x12, x5, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x15, &x16, x14, x7, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x17, &x18, x16, x8, 0x0); + fiat_sm2_scalar_cmovznz_u64(&x19, x18, x9, x1); + fiat_sm2_scalar_cmovznz_u64(&x20, x18, x11, x3); + fiat_sm2_scalar_cmovznz_u64(&x21, x18, x13, x5); + fiat_sm2_scalar_cmovznz_u64(&x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_sub(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1, const fiat_sm2_scalar_montgomery_domain_field_element arg2) { + uint64_t x1; + fiat_sm2_scalar_uint1 x2; + uint64_t x3; + fiat_sm2_scalar_uint1 x4; + uint64_t x5; + fiat_sm2_scalar_uint1 x6; + uint64_t x7; + fiat_sm2_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_sm2_scalar_uint1 x11; + uint64_t x12; + fiat_sm2_scalar_uint1 x13; + uint64_t x14; + fiat_sm2_scalar_uint1 x15; + uint64_t x16; + fiat_sm2_scalar_uint1 x17; + fiat_sm2_scalar_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0])); + fiat_sm2_scalar_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1])); + fiat_sm2_scalar_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2])); + fiat_sm2_scalar_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3])); + fiat_sm2_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0x53bbf40939d54123))); + fiat_sm2_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0x7203df6b21c6052b))); + fiat_sm2_scalar_addcarryx_u64(&x14, &x15, x13, x5, x9); + fiat_sm2_scalar_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xfffffffeffffffff))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_opp(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_scalar_montgomery_domain_field_element arg1) { + uint64_t x1; + fiat_sm2_scalar_uint1 x2; + uint64_t x3; + fiat_sm2_scalar_uint1 x4; + uint64_t x5; + fiat_sm2_scalar_uint1 x6; + uint64_t x7; + fiat_sm2_scalar_uint1 x8; + uint64_t x9; + uint64_t x10; + fiat_sm2_scalar_uint1 x11; + uint64_t x12; + fiat_sm2_scalar_uint1 x13; + uint64_t x14; + fiat_sm2_scalar_uint1 x15; + uint64_t x16; + fiat_sm2_scalar_uint1 x17; + fiat_sm2_scalar_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0])); + fiat_sm2_scalar_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1])); + fiat_sm2_scalar_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2])); + fiat_sm2_scalar_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3])); + fiat_sm2_scalar_cmovznz_u64(&x9, x8, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_addcarryx_u64(&x10, &x11, 0x0, x1, (x9 & UINT64_C(0x53bbf40939d54123))); + fiat_sm2_scalar_addcarryx_u64(&x12, &x13, x11, x3, (x9 & UINT64_C(0x7203df6b21c6052b))); + fiat_sm2_scalar_addcarryx_u64(&x14, &x15, x13, x5, x9); + fiat_sm2_scalar_addcarryx_u64(&x16, &x17, x15, x7, (x9 & UINT64_C(0xfffffffeffffffff))); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_from_montgomery(fiat_sm2_scalar_non_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_scalar_uint1 x13; + uint64_t x14; + fiat_sm2_scalar_uint1 x15; + uint64_t x16; + fiat_sm2_scalar_uint1 x17; + uint64_t x18; + fiat_sm2_scalar_uint1 x19; + uint64_t x20; + fiat_sm2_scalar_uint1 x21; + uint64_t x22; + fiat_sm2_scalar_uint1 x23; + uint64_t x24; + fiat_sm2_scalar_uint1 x25; + uint64_t x26; + fiat_sm2_scalar_uint1 x27; + uint64_t x28; + fiat_sm2_scalar_uint1 x29; + uint64_t x30; + fiat_sm2_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_sm2_scalar_uint1 x43; + uint64_t x44; + fiat_sm2_scalar_uint1 x45; + uint64_t x46; + fiat_sm2_scalar_uint1 x47; + uint64_t x48; + fiat_sm2_scalar_uint1 x49; + uint64_t x50; + fiat_sm2_scalar_uint1 x51; + uint64_t x52; + fiat_sm2_scalar_uint1 x53; + uint64_t x54; + fiat_sm2_scalar_uint1 x55; + uint64_t x56; + fiat_sm2_scalar_uint1 x57; + uint64_t x58; + fiat_sm2_scalar_uint1 x59; + uint64_t x60; + fiat_sm2_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_sm2_scalar_uint1 x73; + uint64_t x74; + fiat_sm2_scalar_uint1 x75; + uint64_t x76; + fiat_sm2_scalar_uint1 x77; + uint64_t x78; + fiat_sm2_scalar_uint1 x79; + uint64_t x80; + fiat_sm2_scalar_uint1 x81; + uint64_t x82; + fiat_sm2_scalar_uint1 x83; + uint64_t x84; + fiat_sm2_scalar_uint1 x85; + uint64_t x86; + fiat_sm2_scalar_uint1 x87; + uint64_t x88; + fiat_sm2_scalar_uint1 x89; + uint64_t x90; + fiat_sm2_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_sm2_scalar_uint1 x103; + uint64_t x104; + fiat_sm2_scalar_uint1 x105; + uint64_t x106; + fiat_sm2_scalar_uint1 x107; + uint64_t x108; + fiat_sm2_scalar_uint1 x109; + uint64_t x110; + fiat_sm2_scalar_uint1 x111; + uint64_t x112; + fiat_sm2_scalar_uint1 x113; + uint64_t x114; + fiat_sm2_scalar_uint1 x115; + uint64_t x116; + uint64_t x117; + fiat_sm2_scalar_uint1 x118; + uint64_t x119; + fiat_sm2_scalar_uint1 x120; + uint64_t x121; + fiat_sm2_scalar_uint1 x122; + uint64_t x123; + fiat_sm2_scalar_uint1 x124; + uint64_t x125; + fiat_sm2_scalar_uint1 x126; + uint64_t x127; + uint64_t x128; + uint64_t x129; + uint64_t x130; + x1 = (arg1[0]); + fiat_sm2_scalar_mulx_u64(&x2, &x3, x1, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x4, &x5, x2, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x6, &x7, x2, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x8, &x9, x2, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x10, &x11, x2, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x12, &x13, 0x0, x11, x8); + fiat_sm2_scalar_addcarryx_u64(&x14, &x15, x13, x9, x6); + fiat_sm2_scalar_addcarryx_u64(&x16, &x17, x15, x7, x4); + fiat_sm2_scalar_addcarryx_u64(&x18, &x19, 0x0, x1, x10); + fiat_sm2_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, x12); + fiat_sm2_scalar_addcarryx_u64(&x22, &x23, x21, 0x0, x14); + fiat_sm2_scalar_addcarryx_u64(&x24, &x25, x23, 0x0, x16); + fiat_sm2_scalar_addcarryx_u64(&x26, &x27, 0x0, x20, (arg1[1])); + fiat_sm2_scalar_addcarryx_u64(&x28, &x29, x27, x22, 0x0); + fiat_sm2_scalar_addcarryx_u64(&x30, &x31, x29, x24, 0x0); + fiat_sm2_scalar_mulx_u64(&x32, &x33, x26, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x34, &x35, x32, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x36, &x37, x32, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x38, &x39, x32, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x40, &x41, x32, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x42, &x43, 0x0, x41, x38); + fiat_sm2_scalar_addcarryx_u64(&x44, &x45, x43, x39, x36); + fiat_sm2_scalar_addcarryx_u64(&x46, &x47, x45, x37, x34); + fiat_sm2_scalar_addcarryx_u64(&x48, &x49, 0x0, x26, x40); + fiat_sm2_scalar_addcarryx_u64(&x50, &x51, x49, x28, x42); + fiat_sm2_scalar_addcarryx_u64(&x52, &x53, x51, x30, x44); + fiat_sm2_scalar_addcarryx_u64(&x54, &x55, x53, (x31 + (x25 + (x17 + x5))), x46); + fiat_sm2_scalar_addcarryx_u64(&x56, &x57, 0x0, x50, (arg1[2])); + fiat_sm2_scalar_addcarryx_u64(&x58, &x59, x57, x52, 0x0); + fiat_sm2_scalar_addcarryx_u64(&x60, &x61, x59, x54, 0x0); + fiat_sm2_scalar_mulx_u64(&x62, &x63, x56, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x64, &x65, x62, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x66, &x67, x62, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x68, &x69, x62, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x70, &x71, x62, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x72, &x73, 0x0, x71, x68); + fiat_sm2_scalar_addcarryx_u64(&x74, &x75, x73, x69, x66); + fiat_sm2_scalar_addcarryx_u64(&x76, &x77, x75, x67, x64); + fiat_sm2_scalar_addcarryx_u64(&x78, &x79, 0x0, x56, x70); + fiat_sm2_scalar_addcarryx_u64(&x80, &x81, x79, x58, x72); + fiat_sm2_scalar_addcarryx_u64(&x82, &x83, x81, x60, x74); + fiat_sm2_scalar_addcarryx_u64(&x84, &x85, x83, (x61 + (x55 + (x47 + x35))), x76); + fiat_sm2_scalar_addcarryx_u64(&x86, &x87, 0x0, x80, (arg1[3])); + fiat_sm2_scalar_addcarryx_u64(&x88, &x89, x87, x82, 0x0); + fiat_sm2_scalar_addcarryx_u64(&x90, &x91, x89, x84, 0x0); + fiat_sm2_scalar_mulx_u64(&x92, &x93, x86, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x94, &x95, x92, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x96, &x97, x92, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x98, &x99, x92, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x100, &x101, x92, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x102, &x103, 0x0, x101, x98); + fiat_sm2_scalar_addcarryx_u64(&x104, &x105, x103, x99, x96); + fiat_sm2_scalar_addcarryx_u64(&x106, &x107, x105, x97, x94); + fiat_sm2_scalar_addcarryx_u64(&x108, &x109, 0x0, x86, x100); + fiat_sm2_scalar_addcarryx_u64(&x110, &x111, x109, x88, x102); + fiat_sm2_scalar_addcarryx_u64(&x112, &x113, x111, x90, x104); + fiat_sm2_scalar_addcarryx_u64(&x114, &x115, x113, (x91 + (x85 + (x77 + x65))), x106); + x116 = (x115 + (x107 + x95)); + fiat_sm2_scalar_subborrowx_u64(&x117, &x118, 0x0, x110, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x119, &x120, x118, x112, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x121, &x122, x120, x114, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x123, &x124, x122, x116, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x125, &x126, x124, 0x0, 0x0); + fiat_sm2_scalar_cmovznz_u64(&x127, x126, x117, x110); + fiat_sm2_scalar_cmovznz_u64(&x128, x126, x119, x112); + fiat_sm2_scalar_cmovznz_u64(&x129, x126, x121, x114); + fiat_sm2_scalar_cmovznz_u64(&x130, x126, x123, x116); + out1[0] = x127; + out1[1] = x128; + out1[2] = x129; + out1[3] = x130; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_to_montgomery(fiat_sm2_scalar_montgomery_domain_field_element out1, const fiat_sm2_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_sm2_scalar_uint1 x14; + uint64_t x15; + fiat_sm2_scalar_uint1 x16; + uint64_t x17; + fiat_sm2_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_sm2_scalar_uint1 x30; + uint64_t x31; + fiat_sm2_scalar_uint1 x32; + uint64_t x33; + fiat_sm2_scalar_uint1 x34; + uint64_t x35; + fiat_sm2_scalar_uint1 x36; + uint64_t x37; + fiat_sm2_scalar_uint1 x38; + uint64_t x39; + fiat_sm2_scalar_uint1 x40; + uint64_t x41; + fiat_sm2_scalar_uint1 x42; + uint64_t x43; + fiat_sm2_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_sm2_scalar_uint1 x54; + uint64_t x55; + fiat_sm2_scalar_uint1 x56; + uint64_t x57; + fiat_sm2_scalar_uint1 x58; + uint64_t x59; + fiat_sm2_scalar_uint1 x60; + uint64_t x61; + fiat_sm2_scalar_uint1 x62; + uint64_t x63; + fiat_sm2_scalar_uint1 x64; + uint64_t x65; + fiat_sm2_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_sm2_scalar_uint1 x78; + uint64_t x79; + fiat_sm2_scalar_uint1 x80; + uint64_t x81; + fiat_sm2_scalar_uint1 x82; + uint64_t x83; + fiat_sm2_scalar_uint1 x84; + uint64_t x85; + fiat_sm2_scalar_uint1 x86; + uint64_t x87; + fiat_sm2_scalar_uint1 x88; + uint64_t x89; + fiat_sm2_scalar_uint1 x90; + uint64_t x91; + fiat_sm2_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_sm2_scalar_uint1 x102; + uint64_t x103; + fiat_sm2_scalar_uint1 x104; + uint64_t x105; + fiat_sm2_scalar_uint1 x106; + uint64_t x107; + fiat_sm2_scalar_uint1 x108; + uint64_t x109; + fiat_sm2_scalar_uint1 x110; + uint64_t x111; + fiat_sm2_scalar_uint1 x112; + uint64_t x113; + fiat_sm2_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_sm2_scalar_uint1 x126; + uint64_t x127; + fiat_sm2_scalar_uint1 x128; + uint64_t x129; + fiat_sm2_scalar_uint1 x130; + uint64_t x131; + fiat_sm2_scalar_uint1 x132; + uint64_t x133; + fiat_sm2_scalar_uint1 x134; + uint64_t x135; + fiat_sm2_scalar_uint1 x136; + uint64_t x137; + fiat_sm2_scalar_uint1 x138; + uint64_t x139; + fiat_sm2_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_sm2_scalar_uint1 x150; + uint64_t x151; + fiat_sm2_scalar_uint1 x152; + uint64_t x153; + fiat_sm2_scalar_uint1 x154; + uint64_t x155; + fiat_sm2_scalar_uint1 x156; + uint64_t x157; + fiat_sm2_scalar_uint1 x158; + uint64_t x159; + fiat_sm2_scalar_uint1 x160; + uint64_t x161; + fiat_sm2_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_sm2_scalar_uint1 x174; + uint64_t x175; + fiat_sm2_scalar_uint1 x176; + uint64_t x177; + fiat_sm2_scalar_uint1 x178; + uint64_t x179; + fiat_sm2_scalar_uint1 x180; + uint64_t x181; + fiat_sm2_scalar_uint1 x182; + uint64_t x183; + fiat_sm2_scalar_uint1 x184; + uint64_t x185; + fiat_sm2_scalar_uint1 x186; + uint64_t x187; + fiat_sm2_scalar_uint1 x188; + uint64_t x189; + fiat_sm2_scalar_uint1 x190; + uint64_t x191; + fiat_sm2_scalar_uint1 x192; + uint64_t x193; + fiat_sm2_scalar_uint1 x194; + uint64_t x195; + fiat_sm2_scalar_uint1 x196; + uint64_t x197; + fiat_sm2_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_sm2_scalar_mulx_u64(&x5, &x6, x4, UINT64_C(0x1eb5e412a22b3d3b)); + fiat_sm2_scalar_mulx_u64(&x7, &x8, x4, UINT64_C(0x620fc84c3affe0d4)); + fiat_sm2_scalar_mulx_u64(&x9, &x10, x4, UINT64_C(0x3464504ade6fa2fa)); + fiat_sm2_scalar_mulx_u64(&x11, &x12, x4, UINT64_C(0x901192af7c114f20)); + fiat_sm2_scalar_addcarryx_u64(&x13, &x14, 0x0, x12, x9); + fiat_sm2_scalar_addcarryx_u64(&x15, &x16, x14, x10, x7); + fiat_sm2_scalar_addcarryx_u64(&x17, &x18, x16, x8, x5); + fiat_sm2_scalar_mulx_u64(&x19, &x20, x11, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x21, &x22, x19, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x23, &x24, x19, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x25, &x26, x19, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x27, &x28, x19, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x29, &x30, 0x0, x28, x25); + fiat_sm2_scalar_addcarryx_u64(&x31, &x32, x30, x26, x23); + fiat_sm2_scalar_addcarryx_u64(&x33, &x34, x32, x24, x21); + fiat_sm2_scalar_addcarryx_u64(&x35, &x36, 0x0, x11, x27); + fiat_sm2_scalar_addcarryx_u64(&x37, &x38, x36, x13, x29); + fiat_sm2_scalar_addcarryx_u64(&x39, &x40, x38, x15, x31); + fiat_sm2_scalar_addcarryx_u64(&x41, &x42, x40, x17, x33); + fiat_sm2_scalar_addcarryx_u64(&x43, &x44, x42, (x18 + x6), (x34 + x22)); + fiat_sm2_scalar_mulx_u64(&x45, &x46, x1, UINT64_C(0x1eb5e412a22b3d3b)); + fiat_sm2_scalar_mulx_u64(&x47, &x48, x1, UINT64_C(0x620fc84c3affe0d4)); + fiat_sm2_scalar_mulx_u64(&x49, &x50, x1, UINT64_C(0x3464504ade6fa2fa)); + fiat_sm2_scalar_mulx_u64(&x51, &x52, x1, UINT64_C(0x901192af7c114f20)); + fiat_sm2_scalar_addcarryx_u64(&x53, &x54, 0x0, x52, x49); + fiat_sm2_scalar_addcarryx_u64(&x55, &x56, x54, x50, x47); + fiat_sm2_scalar_addcarryx_u64(&x57, &x58, x56, x48, x45); + fiat_sm2_scalar_addcarryx_u64(&x59, &x60, 0x0, x37, x51); + fiat_sm2_scalar_addcarryx_u64(&x61, &x62, x60, x39, x53); + fiat_sm2_scalar_addcarryx_u64(&x63, &x64, x62, x41, x55); + fiat_sm2_scalar_addcarryx_u64(&x65, &x66, x64, x43, x57); + fiat_sm2_scalar_mulx_u64(&x67, &x68, x59, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x69, &x70, x67, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x71, &x72, x67, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x73, &x74, x67, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x75, &x76, x67, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x77, &x78, 0x0, x76, x73); + fiat_sm2_scalar_addcarryx_u64(&x79, &x80, x78, x74, x71); + fiat_sm2_scalar_addcarryx_u64(&x81, &x82, x80, x72, x69); + fiat_sm2_scalar_addcarryx_u64(&x83, &x84, 0x0, x59, x75); + fiat_sm2_scalar_addcarryx_u64(&x85, &x86, x84, x61, x77); + fiat_sm2_scalar_addcarryx_u64(&x87, &x88, x86, x63, x79); + fiat_sm2_scalar_addcarryx_u64(&x89, &x90, x88, x65, x81); + fiat_sm2_scalar_addcarryx_u64(&x91, &x92, x90, (((uint64_t)x66 + x44) + (x58 + x46)), (x82 + x70)); + fiat_sm2_scalar_mulx_u64(&x93, &x94, x2, UINT64_C(0x1eb5e412a22b3d3b)); + fiat_sm2_scalar_mulx_u64(&x95, &x96, x2, UINT64_C(0x620fc84c3affe0d4)); + fiat_sm2_scalar_mulx_u64(&x97, &x98, x2, UINT64_C(0x3464504ade6fa2fa)); + fiat_sm2_scalar_mulx_u64(&x99, &x100, x2, UINT64_C(0x901192af7c114f20)); + fiat_sm2_scalar_addcarryx_u64(&x101, &x102, 0x0, x100, x97); + fiat_sm2_scalar_addcarryx_u64(&x103, &x104, x102, x98, x95); + fiat_sm2_scalar_addcarryx_u64(&x105, &x106, x104, x96, x93); + fiat_sm2_scalar_addcarryx_u64(&x107, &x108, 0x0, x85, x99); + fiat_sm2_scalar_addcarryx_u64(&x109, &x110, x108, x87, x101); + fiat_sm2_scalar_addcarryx_u64(&x111, &x112, x110, x89, x103); + fiat_sm2_scalar_addcarryx_u64(&x113, &x114, x112, x91, x105); + fiat_sm2_scalar_mulx_u64(&x115, &x116, x107, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x117, &x118, x115, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x119, &x120, x115, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x121, &x122, x115, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x123, &x124, x115, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x125, &x126, 0x0, x124, x121); + fiat_sm2_scalar_addcarryx_u64(&x127, &x128, x126, x122, x119); + fiat_sm2_scalar_addcarryx_u64(&x129, &x130, x128, x120, x117); + fiat_sm2_scalar_addcarryx_u64(&x131, &x132, 0x0, x107, x123); + fiat_sm2_scalar_addcarryx_u64(&x133, &x134, x132, x109, x125); + fiat_sm2_scalar_addcarryx_u64(&x135, &x136, x134, x111, x127); + fiat_sm2_scalar_addcarryx_u64(&x137, &x138, x136, x113, x129); + fiat_sm2_scalar_addcarryx_u64(&x139, &x140, x138, (((uint64_t)x114 + x92) + (x106 + x94)), (x130 + x118)); + fiat_sm2_scalar_mulx_u64(&x141, &x142, x3, UINT64_C(0x1eb5e412a22b3d3b)); + fiat_sm2_scalar_mulx_u64(&x143, &x144, x3, UINT64_C(0x620fc84c3affe0d4)); + fiat_sm2_scalar_mulx_u64(&x145, &x146, x3, UINT64_C(0x3464504ade6fa2fa)); + fiat_sm2_scalar_mulx_u64(&x147, &x148, x3, UINT64_C(0x901192af7c114f20)); + fiat_sm2_scalar_addcarryx_u64(&x149, &x150, 0x0, x148, x145); + fiat_sm2_scalar_addcarryx_u64(&x151, &x152, x150, x146, x143); + fiat_sm2_scalar_addcarryx_u64(&x153, &x154, x152, x144, x141); + fiat_sm2_scalar_addcarryx_u64(&x155, &x156, 0x0, x133, x147); + fiat_sm2_scalar_addcarryx_u64(&x157, &x158, x156, x135, x149); + fiat_sm2_scalar_addcarryx_u64(&x159, &x160, x158, x137, x151); + fiat_sm2_scalar_addcarryx_u64(&x161, &x162, x160, x139, x153); + fiat_sm2_scalar_mulx_u64(&x163, &x164, x155, UINT64_C(0x327f9e8872350975)); + fiat_sm2_scalar_mulx_u64(&x165, &x166, x163, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_mulx_u64(&x167, &x168, x163, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_mulx_u64(&x169, &x170, x163, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_mulx_u64(&x171, &x172, x163, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_addcarryx_u64(&x173, &x174, 0x0, x172, x169); + fiat_sm2_scalar_addcarryx_u64(&x175, &x176, x174, x170, x167); + fiat_sm2_scalar_addcarryx_u64(&x177, &x178, x176, x168, x165); + fiat_sm2_scalar_addcarryx_u64(&x179, &x180, 0x0, x155, x171); + fiat_sm2_scalar_addcarryx_u64(&x181, &x182, x180, x157, x173); + fiat_sm2_scalar_addcarryx_u64(&x183, &x184, x182, x159, x175); + fiat_sm2_scalar_addcarryx_u64(&x185, &x186, x184, x161, x177); + fiat_sm2_scalar_addcarryx_u64(&x187, &x188, x186, (((uint64_t)x162 + x140) + (x154 + x142)), (x178 + x166)); + fiat_sm2_scalar_subborrowx_u64(&x189, &x190, 0x0, x181, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x191, &x192, x190, x183, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x193, &x194, x192, x185, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x195, &x196, x194, x187, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x197, &x198, x196, x188, 0x0); + fiat_sm2_scalar_cmovznz_u64(&x199, x198, x189, x181); + fiat_sm2_scalar_cmovznz_u64(&x200, x198, x191, x183); + fiat_sm2_scalar_cmovznz_u64(&x201, x198, x193, x185); + fiat_sm2_scalar_cmovznz_u64(&x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_selectznz(uint64_t out1[4], fiat_sm2_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_sm2_scalar_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0])); + fiat_sm2_scalar_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1])); + fiat_sm2_scalar_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2])); + fiat_sm2_scalar_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_set_one(fiat_sm2_scalar_montgomery_domain_field_element out1) { + out1[0] = UINT64_C(0xac440bf6c62abedd); + out1[1] = UINT64_C(0x8dfc2094de39fad4); + out1[2] = 0x0; + out1[3] = UINT64_C(0x100000000); +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_msat(uint64_t out1[5]) { + out1[0] = UINT64_C(0x53bbf40939d54123); + out1[1] = UINT64_C(0x7203df6b21c6052b); + out1[2] = UINT64_C(0xffffffffffffffff); + out1[3] = UINT64_C(0xfffffffeffffffff); + out1[4] = 0x0; +} + +/* + * The function fiat_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_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_sm2_scalar_uint1 x2; + fiat_sm2_scalar_uint1 x3; + uint64_t x4; + fiat_sm2_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_sm2_scalar_uint1 x13; + uint64_t x14; + fiat_sm2_scalar_uint1 x15; + uint64_t x16; + fiat_sm2_scalar_uint1 x17; + uint64_t x18; + fiat_sm2_scalar_uint1 x19; + uint64_t x20; + fiat_sm2_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_sm2_scalar_uint1 x32; + uint64_t x33; + fiat_sm2_scalar_uint1 x34; + uint64_t x35; + fiat_sm2_scalar_uint1 x36; + uint64_t x37; + fiat_sm2_scalar_uint1 x38; + uint64_t x39; + fiat_sm2_scalar_uint1 x40; + uint64_t x41; + fiat_sm2_scalar_uint1 x42; + uint64_t x43; + fiat_sm2_scalar_uint1 x44; + uint64_t x45; + fiat_sm2_scalar_uint1 x46; + uint64_t x47; + fiat_sm2_scalar_uint1 x48; + uint64_t x49; + uint64_t x50; + uint64_t x51; + uint64_t x52; + uint64_t x53; + fiat_sm2_scalar_uint1 x54; + uint64_t x55; + fiat_sm2_scalar_uint1 x56; + uint64_t x57; + fiat_sm2_scalar_uint1 x58; + uint64_t x59; + fiat_sm2_scalar_uint1 x60; + uint64_t x61; + uint64_t x62; + fiat_sm2_scalar_uint1 x63; + uint64_t x64; + fiat_sm2_scalar_uint1 x65; + uint64_t x66; + fiat_sm2_scalar_uint1 x67; + uint64_t x68; + fiat_sm2_scalar_uint1 x69; + uint64_t x70; + uint64_t x71; + uint64_t x72; + uint64_t x73; + fiat_sm2_scalar_uint1 x74; + uint64_t x75; + uint64_t x76; + uint64_t x77; + uint64_t x78; + uint64_t x79; + uint64_t x80; + fiat_sm2_scalar_uint1 x81; + uint64_t x82; + fiat_sm2_scalar_uint1 x83; + uint64_t x84; + fiat_sm2_scalar_uint1 x85; + uint64_t x86; + fiat_sm2_scalar_uint1 x87; + uint64_t x88; + fiat_sm2_scalar_uint1 x89; + uint64_t x90; + uint64_t x91; + uint64_t x92; + uint64_t x93; + uint64_t x94; + fiat_sm2_scalar_uint1 x95; + uint64_t x96; + fiat_sm2_scalar_uint1 x97; + uint64_t x98; + fiat_sm2_scalar_uint1 x99; + uint64_t x100; + fiat_sm2_scalar_uint1 x101; + uint64_t x102; + fiat_sm2_scalar_uint1 x103; + uint64_t x104; + fiat_sm2_scalar_uint1 x105; + uint64_t x106; + fiat_sm2_scalar_uint1 x107; + uint64_t x108; + fiat_sm2_scalar_uint1 x109; + uint64_t x110; + fiat_sm2_scalar_uint1 x111; + uint64_t x112; + fiat_sm2_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_sm2_scalar_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1); + x3 = (fiat_sm2_scalar_uint1)((fiat_sm2_scalar_uint1)(x1 >> 63) & (fiat_sm2_scalar_uint1)((arg3[0]) & 0x1)); + fiat_sm2_scalar_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1); + fiat_sm2_scalar_cmovznz_u64(&x6, x3, arg1, x4); + fiat_sm2_scalar_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0])); + fiat_sm2_scalar_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1])); + fiat_sm2_scalar_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2])); + fiat_sm2_scalar_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3])); + fiat_sm2_scalar_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4])); + fiat_sm2_scalar_addcarryx_u64(&x12, &x13, 0x0, 0x1, (~(arg2[0]))); + fiat_sm2_scalar_addcarryx_u64(&x14, &x15, x13, 0x0, (~(arg2[1]))); + fiat_sm2_scalar_addcarryx_u64(&x16, &x17, x15, 0x0, (~(arg2[2]))); + fiat_sm2_scalar_addcarryx_u64(&x18, &x19, x17, 0x0, (~(arg2[3]))); + fiat_sm2_scalar_addcarryx_u64(&x20, &x21, x19, 0x0, (~(arg2[4]))); + fiat_sm2_scalar_cmovznz_u64(&x22, x3, (arg3[0]), x12); + fiat_sm2_scalar_cmovznz_u64(&x23, x3, (arg3[1]), x14); + fiat_sm2_scalar_cmovznz_u64(&x24, x3, (arg3[2]), x16); + fiat_sm2_scalar_cmovznz_u64(&x25, x3, (arg3[3]), x18); + fiat_sm2_scalar_cmovznz_u64(&x26, x3, (arg3[4]), x20); + fiat_sm2_scalar_cmovznz_u64(&x27, x3, (arg4[0]), (arg5[0])); + fiat_sm2_scalar_cmovznz_u64(&x28, x3, (arg4[1]), (arg5[1])); + fiat_sm2_scalar_cmovznz_u64(&x29, x3, (arg4[2]), (arg5[2])); + fiat_sm2_scalar_cmovznz_u64(&x30, x3, (arg4[3]), (arg5[3])); + fiat_sm2_scalar_addcarryx_u64(&x31, &x32, 0x0, x27, x27); + fiat_sm2_scalar_addcarryx_u64(&x33, &x34, x32, x28, x28); + fiat_sm2_scalar_addcarryx_u64(&x35, &x36, x34, x29, x29); + fiat_sm2_scalar_addcarryx_u64(&x37, &x38, x36, x30, x30); + fiat_sm2_scalar_subborrowx_u64(&x39, &x40, 0x0, x31, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x41, &x42, x40, x33, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x43, &x44, x42, x35, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x45, &x46, x44, x37, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x47, &x48, x46, x38, 0x0); + x49 = (arg4[3]); + x50 = (arg4[2]); + x51 = (arg4[1]); + x52 = (arg4[0]); + fiat_sm2_scalar_subborrowx_u64(&x53, &x54, 0x0, 0x0, x52); + fiat_sm2_scalar_subborrowx_u64(&x55, &x56, x54, 0x0, x51); + fiat_sm2_scalar_subborrowx_u64(&x57, &x58, x56, 0x0, x50); + fiat_sm2_scalar_subborrowx_u64(&x59, &x60, x58, 0x0, x49); + fiat_sm2_scalar_cmovznz_u64(&x61, x60, 0x0, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_addcarryx_u64(&x62, &x63, 0x0, x53, (x61 & UINT64_C(0x53bbf40939d54123))); + fiat_sm2_scalar_addcarryx_u64(&x64, &x65, x63, x55, (x61 & UINT64_C(0x7203df6b21c6052b))); + fiat_sm2_scalar_addcarryx_u64(&x66, &x67, x65, x57, x61); + fiat_sm2_scalar_addcarryx_u64(&x68, &x69, x67, x59, (x61 & UINT64_C(0xfffffffeffffffff))); + fiat_sm2_scalar_cmovznz_u64(&x70, x3, (arg5[0]), x62); + fiat_sm2_scalar_cmovznz_u64(&x71, x3, (arg5[1]), x64); + fiat_sm2_scalar_cmovznz_u64(&x72, x3, (arg5[2]), x66); + fiat_sm2_scalar_cmovznz_u64(&x73, x3, (arg5[3]), x68); + x74 = (fiat_sm2_scalar_uint1)(x22 & 0x1); + fiat_sm2_scalar_cmovznz_u64(&x75, x74, 0x0, x7); + fiat_sm2_scalar_cmovznz_u64(&x76, x74, 0x0, x8); + fiat_sm2_scalar_cmovznz_u64(&x77, x74, 0x0, x9); + fiat_sm2_scalar_cmovznz_u64(&x78, x74, 0x0, x10); + fiat_sm2_scalar_cmovznz_u64(&x79, x74, 0x0, x11); + fiat_sm2_scalar_addcarryx_u64(&x80, &x81, 0x0, x22, x75); + fiat_sm2_scalar_addcarryx_u64(&x82, &x83, x81, x23, x76); + fiat_sm2_scalar_addcarryx_u64(&x84, &x85, x83, x24, x77); + fiat_sm2_scalar_addcarryx_u64(&x86, &x87, x85, x25, x78); + fiat_sm2_scalar_addcarryx_u64(&x88, &x89, x87, x26, x79); + fiat_sm2_scalar_cmovznz_u64(&x90, x74, 0x0, x27); + fiat_sm2_scalar_cmovznz_u64(&x91, x74, 0x0, x28); + fiat_sm2_scalar_cmovznz_u64(&x92, x74, 0x0, x29); + fiat_sm2_scalar_cmovznz_u64(&x93, x74, 0x0, x30); + fiat_sm2_scalar_addcarryx_u64(&x94, &x95, 0x0, x70, x90); + fiat_sm2_scalar_addcarryx_u64(&x96, &x97, x95, x71, x91); + fiat_sm2_scalar_addcarryx_u64(&x98, &x99, x97, x72, x92); + fiat_sm2_scalar_addcarryx_u64(&x100, &x101, x99, x73, x93); + fiat_sm2_scalar_subborrowx_u64(&x102, &x103, 0x0, x94, UINT64_C(0x53bbf40939d54123)); + fiat_sm2_scalar_subborrowx_u64(&x104, &x105, x103, x96, UINT64_C(0x7203df6b21c6052b)); + fiat_sm2_scalar_subborrowx_u64(&x106, &x107, x105, x98, UINT64_C(0xffffffffffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x108, &x109, x107, x100, UINT64_C(0xfffffffeffffffff)); + fiat_sm2_scalar_subborrowx_u64(&x110, &x111, x109, x101, 0x0); + fiat_sm2_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_sm2_scalar_cmovznz_u64(&x119, x48, x39, x31); + fiat_sm2_scalar_cmovznz_u64(&x120, x48, x41, x33); + fiat_sm2_scalar_cmovznz_u64(&x121, x48, x43, x35); + fiat_sm2_scalar_cmovznz_u64(&x122, x48, x45, x37); + fiat_sm2_scalar_cmovznz_u64(&x123, x111, x102, x94); + fiat_sm2_scalar_cmovznz_u64(&x124, x111, x104, x96); + fiat_sm2_scalar_cmovznz_u64(&x125, x111, x106, x98); + fiat_sm2_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_sm2_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_SM2_SCALAR_FIAT_INLINE void fiat_sm2_scalar_divstep_precomp(uint64_t out1[4]) { + out1[0] = UINT64_C(0x1aa32707b351756d); + out1[1] = UINT64_C(0xabdd671e2a62fa); + out1[2] = UINT64_C(0x49280d7dd4009a81); + out1[3] = UINT64_C(0xd730336ee6bb86e8); +} diff --git a/fiat-go/32/sm2/sm2.go b/fiat-go/32/sm2/sm2.go new file mode 100644 index 00000000000..1538c8b06fa --- /dev/null +++ b/fiat-go/32/sm2/sm2.go @@ -0,0 +1,5075 @@ +// 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 sm2 '' 32 '2^256 - 2^224 - 2^96 + 2^64 - 1' 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): sm2 +// +// 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") +// +// +// +// 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 sm2 + +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 + var x41 uint32 + x41, x40 = bits.Mul32(x23, 0xfffffffe) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x23, 0xffffffff) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x23, 0xffffffff) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x23, 0xffffffff) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x23, 0xffffffff) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x23, 0xffffffff) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x23, 0xffffffff) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x53, x50, uint32(0x0)) + x56 := (uint32(uint1(x55)) + x51) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x49, x46, uint32(0x0)) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x47, x44, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x45, x42, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x43, x40, uint32(uint1(x62))) + x65 := (uint32(uint1(x64)) + x41) + var x67 uint32 + _, x67 = bits.Add32(x23, x52, uint32(0x0)) + var x68 uint32 + var x69 uint32 + x68, x69 = bits.Add32(x25, x54, uint32(uint1(x67))) + var x70 uint32 + var x71 uint32 + x70, x71 = bits.Add32(x27, x56, uint32(uint1(x69))) + var x72 uint32 + var x73 uint32 + x72, x73 = bits.Add32(x29, x48, uint32(uint1(x71))) + var x74 uint32 + var x75 uint32 + x74, x75 = bits.Add32(x31, x57, uint32(uint1(x73))) + var x76 uint32 + var x77 uint32 + x76, x77 = bits.Add32(x33, x59, uint32(uint1(x75))) + var x78 uint32 + var x79 uint32 + x78, x79 = bits.Add32(x35, x61, uint32(uint1(x77))) + var x80 uint32 + var x81 uint32 + x80, x81 = bits.Add32(x37, x63, uint32(uint1(x79))) + var x82 uint32 + var x83 uint32 + x82, x83 = bits.Add32(x39, x65, uint32(uint1(x81))) + var x84 uint32 + var x85 uint32 + x85, x84 = bits.Mul32(x1, arg2[7]) + var x86 uint32 + var x87 uint32 + x87, x86 = bits.Mul32(x1, arg2[6]) + var x88 uint32 + var x89 uint32 + x89, x88 = bits.Mul32(x1, arg2[5]) + var x90 uint32 + var x91 uint32 + x91, x90 = bits.Mul32(x1, arg2[4]) + var x92 uint32 + var x93 uint32 + x93, x92 = bits.Mul32(x1, arg2[3]) + var x94 uint32 + var x95 uint32 + x95, x94 = bits.Mul32(x1, arg2[2]) + var x96 uint32 + var x97 uint32 + x97, x96 = bits.Mul32(x1, arg2[1]) + var x98 uint32 + var x99 uint32 + x99, x98 = bits.Mul32(x1, arg2[0]) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x99, x96, uint32(0x0)) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(x97, x94, uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x95, x92, uint32(uint1(x103))) + var x106 uint32 + var x107 uint32 + x106, x107 = bits.Add32(x93, x90, uint32(uint1(x105))) + var x108 uint32 + var x109 uint32 + x108, x109 = bits.Add32(x91, x88, uint32(uint1(x107))) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x89, x86, uint32(uint1(x109))) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x87, x84, uint32(uint1(x111))) + x114 := (uint32(uint1(x113)) + x85) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x68, x98, uint32(0x0)) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x70, x100, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x72, x102, uint32(uint1(x118))) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x74, x104, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x76, x106, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x78, x108, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x80, x110, uint32(uint1(x126))) + var x129 uint32 + var x130 uint32 + x129, x130 = bits.Add32(x82, x112, uint32(uint1(x128))) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32(uint32(uint1(x83)), x114, uint32(uint1(x130))) + var x133 uint32 + var x134 uint32 + x134, x133 = bits.Mul32(x115, 0xfffffffe) + var x135 uint32 + var x136 uint32 + x136, x135 = bits.Mul32(x115, 0xffffffff) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x115, 0xffffffff) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x115, 0xffffffff) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x115, 0xffffffff) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x115, 0xffffffff) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x115, 0xffffffff) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x146, x143, uint32(0x0)) + x149 := (uint32(uint1(x148)) + x144) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x142, x139, uint32(0x0)) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x140, x137, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x138, x135, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x136, x133, uint32(uint1(x155))) + x158 := (uint32(uint1(x157)) + x134) + var x160 uint32 + _, x160 = bits.Add32(x115, x145, uint32(0x0)) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x117, x147, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x119, x149, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x121, x141, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x123, x150, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x125, x152, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x127, x154, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x129, x156, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x131, x158, uint32(uint1(x174))) + x177 := (uint32(uint1(x176)) + uint32(uint1(x132))) + var x178 uint32 + var x179 uint32 + x179, x178 = bits.Mul32(x2, arg2[7]) + var x180 uint32 + var x181 uint32 + x181, x180 = bits.Mul32(x2, arg2[6]) + var x182 uint32 + var x183 uint32 + x183, x182 = bits.Mul32(x2, arg2[5]) + var x184 uint32 + var x185 uint32 + x185, x184 = bits.Mul32(x2, arg2[4]) + var x186 uint32 + var x187 uint32 + x187, x186 = bits.Mul32(x2, arg2[3]) + var x188 uint32 + var x189 uint32 + x189, x188 = bits.Mul32(x2, arg2[2]) + var x190 uint32 + var x191 uint32 + x191, x190 = bits.Mul32(x2, arg2[1]) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x2, arg2[0]) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x193, x190, uint32(0x0)) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x191, x188, uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x189, x186, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x187, x184, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x185, x182, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x183, x180, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(x181, x178, uint32(uint1(x205))) + x208 := (uint32(uint1(x207)) + x179) + var x209 uint32 + var x210 uint32 + x209, x210 = bits.Add32(x161, x192, uint32(0x0)) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x163, x194, uint32(uint1(x210))) + 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 + x228, x227 = bits.Mul32(x209, 0xfffffffe) + var x229 uint32 + var x230 uint32 + x230, x229 = bits.Mul32(x209, 0xffffffff) + var x231 uint32 + var x232 uint32 + x232, x231 = bits.Mul32(x209, 0xffffffff) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x209, 0xffffffff) + var x235 uint32 + var x236 uint32 + x236, x235 = bits.Mul32(x209, 0xffffffff) + var x237 uint32 + var x238 uint32 + x238, x237 = bits.Mul32(x209, 0xffffffff) + var x239 uint32 + var x240 uint32 + x240, x239 = bits.Mul32(x209, 0xffffffff) + var x241 uint32 + var x242 uint32 + x241, x242 = bits.Add32(x240, x237, uint32(0x0)) + x243 := (uint32(uint1(x242)) + x238) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x236, x233, uint32(0x0)) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x234, x231, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x232, x229, uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x230, x227, uint32(uint1(x249))) + x252 := (uint32(uint1(x251)) + x228) + var x254 uint32 + _, x254 = bits.Add32(x209, x239, uint32(0x0)) + var x255 uint32 + var x256 uint32 + x255, x256 = bits.Add32(x211, x241, uint32(uint1(x254))) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x213, x243, uint32(uint1(x256))) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x215, x235, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x217, x244, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x219, x246, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x221, x248, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x223, x250, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x225, x252, uint32(uint1(x268))) + x271 := (uint32(uint1(x270)) + uint32(uint1(x226))) + var x272 uint32 + var x273 uint32 + x273, x272 = bits.Mul32(x3, arg2[7]) + var x274 uint32 + var x275 uint32 + x275, x274 = bits.Mul32(x3, arg2[6]) + var x276 uint32 + var x277 uint32 + x277, x276 = bits.Mul32(x3, arg2[5]) + var x278 uint32 + var x279 uint32 + x279, x278 = bits.Mul32(x3, arg2[4]) + var x280 uint32 + var x281 uint32 + x281, x280 = bits.Mul32(x3, arg2[3]) + var x282 uint32 + var x283 uint32 + x283, x282 = bits.Mul32(x3, arg2[2]) + var x284 uint32 + var x285 uint32 + x285, x284 = bits.Mul32(x3, arg2[1]) + var x286 uint32 + var x287 uint32 + x287, x286 = bits.Mul32(x3, arg2[0]) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x287, x284, uint32(0x0)) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x285, x282, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x283, x280, uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x281, x278, uint32(uint1(x293))) + var x296 uint32 + var x297 uint32 + x296, x297 = bits.Add32(x279, x276, uint32(uint1(x295))) + var x298 uint32 + var x299 uint32 + x298, x299 = bits.Add32(x277, x274, uint32(uint1(x297))) + var x300 uint32 + var x301 uint32 + x300, x301 = bits.Add32(x275, x272, uint32(uint1(x299))) + x302 := (uint32(uint1(x301)) + x273) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x255, x286, uint32(0x0)) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x257, x288, uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x259, x290, uint32(uint1(x306))) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x261, x292, uint32(uint1(x308))) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x263, x294, uint32(uint1(x310))) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x265, x296, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x267, x298, uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x269, x300, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x271, x302, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x322, x321 = bits.Mul32(x303, 0xfffffffe) + var x323 uint32 + var x324 uint32 + x324, x323 = bits.Mul32(x303, 0xffffffff) + var x325 uint32 + var x326 uint32 + x326, x325 = bits.Mul32(x303, 0xffffffff) + var x327 uint32 + var x328 uint32 + x328, x327 = bits.Mul32(x303, 0xffffffff) + var x329 uint32 + var x330 uint32 + x330, x329 = bits.Mul32(x303, 0xffffffff) + var x331 uint32 + var x332 uint32 + x332, x331 = bits.Mul32(x303, 0xffffffff) + var x333 uint32 + var x334 uint32 + x334, x333 = bits.Mul32(x303, 0xffffffff) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x334, x331, uint32(0x0)) + x337 := (uint32(uint1(x336)) + x332) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x330, x327, uint32(0x0)) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x328, x325, uint32(uint1(x339))) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32(x326, x323, uint32(uint1(x341))) + var x344 uint32 + var x345 uint32 + x344, x345 = bits.Add32(x324, x321, uint32(uint1(x343))) + x346 := (uint32(uint1(x345)) + x322) + var x348 uint32 + _, x348 = bits.Add32(x303, x333, uint32(0x0)) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x305, x335, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(x307, x337, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x309, x329, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x311, x338, uint32(uint1(x354))) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(x313, x340, uint32(uint1(x356))) + var x359 uint32 + var x360 uint32 + x359, x360 = bits.Add32(x315, x342, uint32(uint1(x358))) + var x361 uint32 + var x362 uint32 + x361, x362 = bits.Add32(x317, x344, uint32(uint1(x360))) + var x363 uint32 + var x364 uint32 + x363, x364 = bits.Add32(x319, x346, uint32(uint1(x362))) + x365 := (uint32(uint1(x364)) + uint32(uint1(x320))) + var x366 uint32 + var x367 uint32 + x367, x366 = bits.Mul32(x4, arg2[7]) + var x368 uint32 + var x369 uint32 + x369, x368 = bits.Mul32(x4, arg2[6]) + var x370 uint32 + var x371 uint32 + x371, x370 = bits.Mul32(x4, arg2[5]) + var x372 uint32 + var x373 uint32 + x373, x372 = bits.Mul32(x4, arg2[4]) + var x374 uint32 + var x375 uint32 + x375, x374 = bits.Mul32(x4, arg2[3]) + var x376 uint32 + var x377 uint32 + x377, x376 = bits.Mul32(x4, arg2[2]) + var x378 uint32 + var x379 uint32 + x379, x378 = bits.Mul32(x4, arg2[1]) + var x380 uint32 + var x381 uint32 + x381, x380 = bits.Mul32(x4, arg2[0]) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x381, x378, uint32(0x0)) + var x384 uint32 + var x385 uint32 + x384, x385 = bits.Add32(x379, x376, uint32(uint1(x383))) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x377, x374, uint32(uint1(x385))) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x375, x372, uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x373, x370, uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x371, x368, uint32(uint1(x391))) + var x394 uint32 + var x395 uint32 + x394, x395 = bits.Add32(x369, x366, uint32(uint1(x393))) + x396 := (uint32(uint1(x395)) + x367) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x349, x380, uint32(0x0)) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x351, x382, uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x353, x384, uint32(uint1(x400))) + 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 + x416, x415 = bits.Mul32(x397, 0xfffffffe) + var x417 uint32 + var x418 uint32 + x418, x417 = bits.Mul32(x397, 0xffffffff) + var x419 uint32 + var x420 uint32 + x420, x419 = bits.Mul32(x397, 0xffffffff) + var x421 uint32 + var x422 uint32 + x422, x421 = bits.Mul32(x397, 0xffffffff) + var x423 uint32 + var x424 uint32 + x424, x423 = bits.Mul32(x397, 0xffffffff) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x397, 0xffffffff) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x397, 0xffffffff) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x428, x425, uint32(0x0)) + x431 := (uint32(uint1(x430)) + x426) + var x432 uint32 + var x433 uint32 + x432, x433 = bits.Add32(x424, x421, uint32(0x0)) + var x434 uint32 + var x435 uint32 + x434, x435 = bits.Add32(x422, x419, uint32(uint1(x433))) + var x436 uint32 + var x437 uint32 + x436, x437 = bits.Add32(x420, x417, uint32(uint1(x435))) + var x438 uint32 + var x439 uint32 + x438, x439 = bits.Add32(x418, x415, uint32(uint1(x437))) + x440 := (uint32(uint1(x439)) + x416) + var x442 uint32 + _, x442 = bits.Add32(x397, x427, uint32(0x0)) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x399, x429, uint32(uint1(x442))) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x401, x431, uint32(uint1(x444))) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x403, x423, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x405, x432, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x407, x434, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x409, x436, uint32(uint1(x452))) + var x455 uint32 + var x456 uint32 + x455, x456 = bits.Add32(x411, x438, uint32(uint1(x454))) + var x457 uint32 + var x458 uint32 + x457, x458 = bits.Add32(x413, x440, uint32(uint1(x456))) + x459 := (uint32(uint1(x458)) + uint32(uint1(x414))) + var x460 uint32 + var x461 uint32 + x461, x460 = bits.Mul32(x5, arg2[7]) + var x462 uint32 + var x463 uint32 + x463, x462 = bits.Mul32(x5, arg2[6]) + var x464 uint32 + var x465 uint32 + x465, x464 = bits.Mul32(x5, arg2[5]) + var x466 uint32 + var x467 uint32 + x467, x466 = bits.Mul32(x5, arg2[4]) + var x468 uint32 + var x469 uint32 + x469, x468 = bits.Mul32(x5, arg2[3]) + var x470 uint32 + var x471 uint32 + x471, x470 = bits.Mul32(x5, arg2[2]) + var x472 uint32 + var x473 uint32 + x473, x472 = bits.Mul32(x5, arg2[1]) + var x474 uint32 + var x475 uint32 + x475, x474 = bits.Mul32(x5, arg2[0]) + var x476 uint32 + var x477 uint32 + x476, x477 = bits.Add32(x475, x472, uint32(0x0)) + var x478 uint32 + var x479 uint32 + x478, x479 = bits.Add32(x473, x470, uint32(uint1(x477))) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x471, x468, uint32(uint1(x479))) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x469, x466, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x467, x464, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x465, x462, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x463, x460, uint32(uint1(x487))) + x490 := (uint32(uint1(x489)) + x461) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x443, x474, uint32(0x0)) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x445, x476, uint32(uint1(x492))) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(x447, x478, uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x497, x498 = bits.Add32(x449, x480, uint32(uint1(x496))) + var x499 uint32 + var x500 uint32 + x499, x500 = bits.Add32(x451, x482, uint32(uint1(x498))) + var x501 uint32 + var x502 uint32 + x501, x502 = bits.Add32(x453, x484, uint32(uint1(x500))) + var x503 uint32 + var x504 uint32 + x503, x504 = bits.Add32(x455, x486, uint32(uint1(x502))) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x457, x488, uint32(uint1(x504))) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x459, x490, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x510, x509 = bits.Mul32(x491, 0xfffffffe) + var x511 uint32 + var x512 uint32 + x512, x511 = bits.Mul32(x491, 0xffffffff) + var x513 uint32 + var x514 uint32 + x514, x513 = bits.Mul32(x491, 0xffffffff) + var x515 uint32 + var x516 uint32 + x516, x515 = bits.Mul32(x491, 0xffffffff) + var x517 uint32 + var x518 uint32 + x518, x517 = bits.Mul32(x491, 0xffffffff) + var x519 uint32 + var x520 uint32 + x520, x519 = bits.Mul32(x491, 0xffffffff) + var x521 uint32 + var x522 uint32 + x522, x521 = bits.Mul32(x491, 0xffffffff) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x522, x519, uint32(0x0)) + x525 := (uint32(uint1(x524)) + x520) + var x526 uint32 + var x527 uint32 + x526, x527 = bits.Add32(x518, x515, uint32(0x0)) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x516, x513, uint32(uint1(x527))) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x514, x511, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x512, x509, uint32(uint1(x531))) + x534 := (uint32(uint1(x533)) + x510) + var x536 uint32 + _, x536 = bits.Add32(x491, x521, uint32(0x0)) + var x537 uint32 + var x538 uint32 + x537, x538 = bits.Add32(x493, x523, uint32(uint1(x536))) + var x539 uint32 + var x540 uint32 + x539, x540 = bits.Add32(x495, x525, uint32(uint1(x538))) + var x541 uint32 + var x542 uint32 + x541, x542 = bits.Add32(x497, x517, uint32(uint1(x540))) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x499, x526, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x501, x528, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x503, x530, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x505, x532, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x507, x534, uint32(uint1(x550))) + x553 := (uint32(uint1(x552)) + uint32(uint1(x508))) + var x554 uint32 + var x555 uint32 + x555, x554 = bits.Mul32(x6, arg2[7]) + var x556 uint32 + var x557 uint32 + x557, x556 = bits.Mul32(x6, arg2[6]) + var x558 uint32 + var x559 uint32 + x559, x558 = bits.Mul32(x6, arg2[5]) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x6, arg2[4]) + var x562 uint32 + var x563 uint32 + x563, x562 = bits.Mul32(x6, arg2[3]) + var x564 uint32 + var x565 uint32 + x565, x564 = bits.Mul32(x6, arg2[2]) + var x566 uint32 + var x567 uint32 + x567, x566 = bits.Mul32(x6, arg2[1]) + var x568 uint32 + var x569 uint32 + x569, x568 = bits.Mul32(x6, arg2[0]) + var x570 uint32 + var x571 uint32 + x570, x571 = bits.Add32(x569, x566, uint32(0x0)) + var x572 uint32 + var x573 uint32 + x572, x573 = bits.Add32(x567, x564, uint32(uint1(x571))) + var x574 uint32 + var x575 uint32 + x574, x575 = bits.Add32(x565, x562, uint32(uint1(x573))) + var x576 uint32 + var x577 uint32 + x576, x577 = bits.Add32(x563, x560, uint32(uint1(x575))) + var x578 uint32 + var x579 uint32 + x578, x579 = bits.Add32(x561, x558, uint32(uint1(x577))) + var x580 uint32 + var x581 uint32 + x580, x581 = bits.Add32(x559, x556, uint32(uint1(x579))) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x557, x554, uint32(uint1(x581))) + x584 := (uint32(uint1(x583)) + x555) + var x585 uint32 + var x586 uint32 + x585, x586 = bits.Add32(x537, x568, uint32(0x0)) + var x587 uint32 + var x588 uint32 + x587, x588 = bits.Add32(x539, x570, uint32(uint1(x586))) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x541, x572, uint32(uint1(x588))) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x543, x574, uint32(uint1(x590))) + 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 + x604, x603 = bits.Mul32(x585, 0xfffffffe) + var x605 uint32 + var x606 uint32 + x606, x605 = bits.Mul32(x585, 0xffffffff) + var x607 uint32 + var x608 uint32 + x608, x607 = bits.Mul32(x585, 0xffffffff) + var x609 uint32 + var x610 uint32 + x610, x609 = bits.Mul32(x585, 0xffffffff) + var x611 uint32 + var x612 uint32 + x612, x611 = bits.Mul32(x585, 0xffffffff) + var x613 uint32 + var x614 uint32 + x614, x613 = bits.Mul32(x585, 0xffffffff) + var x615 uint32 + var x616 uint32 + x616, x615 = bits.Mul32(x585, 0xffffffff) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x616, x613, uint32(0x0)) + x619 := (uint32(uint1(x618)) + x614) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x612, x609, uint32(0x0)) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x610, x607, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x608, x605, uint32(uint1(x623))) + var x626 uint32 + var x627 uint32 + x626, x627 = bits.Add32(x606, x603, uint32(uint1(x625))) + x628 := (uint32(uint1(x627)) + x604) + var x630 uint32 + _, x630 = bits.Add32(x585, x615, uint32(0x0)) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x587, x617, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x589, x619, uint32(uint1(x632))) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x591, x611, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x593, x620, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x595, x622, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x597, x624, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x599, x626, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x601, x628, uint32(uint1(x644))) + x647 := (uint32(uint1(x646)) + uint32(uint1(x602))) + var x648 uint32 + var x649 uint32 + x649, x648 = bits.Mul32(x7, arg2[7]) + var x650 uint32 + var x651 uint32 + x651, x650 = bits.Mul32(x7, arg2[6]) + var x652 uint32 + var x653 uint32 + x653, x652 = bits.Mul32(x7, arg2[5]) + var x654 uint32 + var x655 uint32 + x655, x654 = bits.Mul32(x7, arg2[4]) + var x656 uint32 + var x657 uint32 + x657, x656 = bits.Mul32(x7, arg2[3]) + var x658 uint32 + var x659 uint32 + x659, x658 = bits.Mul32(x7, arg2[2]) + var x660 uint32 + var x661 uint32 + x661, x660 = bits.Mul32(x7, arg2[1]) + var x662 uint32 + var x663 uint32 + x663, x662 = bits.Mul32(x7, arg2[0]) + var x664 uint32 + var x665 uint32 + x664, x665 = bits.Add32(x663, x660, uint32(0x0)) + var x666 uint32 + var x667 uint32 + x666, x667 = bits.Add32(x661, x658, uint32(uint1(x665))) + var x668 uint32 + var x669 uint32 + x668, x669 = bits.Add32(x659, x656, uint32(uint1(x667))) + var x670 uint32 + var x671 uint32 + x670, x671 = bits.Add32(x657, x654, uint32(uint1(x669))) + var x672 uint32 + var x673 uint32 + x672, x673 = bits.Add32(x655, x652, uint32(uint1(x671))) + var x674 uint32 + var x675 uint32 + x674, x675 = bits.Add32(x653, x650, uint32(uint1(x673))) + var x676 uint32 + var x677 uint32 + x676, x677 = bits.Add32(x651, x648, uint32(uint1(x675))) + x678 := (uint32(uint1(x677)) + x649) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x631, x662, uint32(0x0)) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x633, x664, uint32(uint1(x680))) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x635, x666, uint32(uint1(x682))) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x637, x668, uint32(uint1(x684))) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x639, x670, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x641, x672, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x643, x674, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x645, x676, uint32(uint1(x692))) + var x695 uint32 + var x696 uint32 + x695, x696 = bits.Add32(x647, x678, uint32(uint1(x694))) + var x697 uint32 + var x698 uint32 + x698, x697 = bits.Mul32(x679, 0xfffffffe) + var x699 uint32 + var x700 uint32 + x700, x699 = bits.Mul32(x679, 0xffffffff) + var x701 uint32 + var x702 uint32 + x702, x701 = bits.Mul32(x679, 0xffffffff) + var x703 uint32 + var x704 uint32 + x704, x703 = bits.Mul32(x679, 0xffffffff) + var x705 uint32 + var x706 uint32 + x706, x705 = bits.Mul32(x679, 0xffffffff) + var x707 uint32 + var x708 uint32 + x708, x707 = bits.Mul32(x679, 0xffffffff) + var x709 uint32 + var x710 uint32 + x710, x709 = bits.Mul32(x679, 0xffffffff) + var x711 uint32 + var x712 uint32 + x711, x712 = bits.Add32(x710, x707, uint32(0x0)) + x713 := (uint32(uint1(x712)) + x708) + var x714 uint32 + var x715 uint32 + x714, x715 = bits.Add32(x706, x703, uint32(0x0)) + var x716 uint32 + var x717 uint32 + x716, x717 = bits.Add32(x704, x701, uint32(uint1(x715))) + var x718 uint32 + var x719 uint32 + x718, x719 = bits.Add32(x702, x699, uint32(uint1(x717))) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x700, x697, uint32(uint1(x719))) + x722 := (uint32(uint1(x721)) + x698) + var x724 uint32 + _, x724 = bits.Add32(x679, x709, uint32(0x0)) + var x725 uint32 + var x726 uint32 + x725, x726 = bits.Add32(x681, x711, uint32(uint1(x724))) + var x727 uint32 + var x728 uint32 + x727, x728 = bits.Add32(x683, x713, uint32(uint1(x726))) + var x729 uint32 + var x730 uint32 + x729, x730 = bits.Add32(x685, x705, uint32(uint1(x728))) + var x731 uint32 + var x732 uint32 + x731, x732 = bits.Add32(x687, x714, uint32(uint1(x730))) + var x733 uint32 + var x734 uint32 + x733, x734 = bits.Add32(x689, x716, uint32(uint1(x732))) + var x735 uint32 + var x736 uint32 + x735, x736 = bits.Add32(x691, x718, uint32(uint1(x734))) + var x737 uint32 + var x738 uint32 + x737, x738 = bits.Add32(x693, x720, uint32(uint1(x736))) + var x739 uint32 + var x740 uint32 + x739, x740 = bits.Add32(x695, x722, uint32(uint1(x738))) + x741 := (uint32(uint1(x740)) + uint32(uint1(x696))) + var x742 uint32 + var x743 uint32 + x742, x743 = bits.Sub32(x725, 0xffffffff, uint32(0x0)) + var x744 uint32 + var x745 uint32 + x744, x745 = bits.Sub32(x727, 0xffffffff, uint32(uint1(x743))) + var x746 uint32 + var x747 uint32 + x746, x747 = bits.Sub32(x729, uint32(0x0), uint32(uint1(x745))) + var x748 uint32 + var x749 uint32 + x748, x749 = bits.Sub32(x731, 0xffffffff, uint32(uint1(x747))) + var x750 uint32 + var x751 uint32 + x750, x751 = bits.Sub32(x733, 0xffffffff, uint32(uint1(x749))) + var x752 uint32 + var x753 uint32 + x752, x753 = bits.Sub32(x735, 0xffffffff, uint32(uint1(x751))) + var x754 uint32 + var x755 uint32 + x754, x755 = bits.Sub32(x737, 0xffffffff, uint32(uint1(x753))) + var x756 uint32 + var x757 uint32 + x756, x757 = bits.Sub32(x739, 0xfffffffe, uint32(uint1(x755))) + var x759 uint32 + _, x759 = bits.Sub32(x741, uint32(0x0), uint32(uint1(x757))) + var x760 uint32 + cmovznzU32(&x760, uint1(x759), x742, x725) + var x761 uint32 + cmovznzU32(&x761, uint1(x759), x744, x727) + var x762 uint32 + cmovznzU32(&x762, uint1(x759), x746, x729) + var x763 uint32 + cmovznzU32(&x763, uint1(x759), x748, x731) + var x764 uint32 + cmovznzU32(&x764, uint1(x759), x750, x733) + var x765 uint32 + cmovznzU32(&x765, uint1(x759), x752, x735) + var x766 uint32 + cmovznzU32(&x766, uint1(x759), x754, x737) + var x767 uint32 + cmovznzU32(&x767, uint1(x759), x756, x739) + out1[0] = x760 + out1[1] = x761 + out1[2] = x762 + out1[3] = x763 + out1[4] = x764 + out1[5] = x765 + out1[6] = x766 + out1[7] = x767 +} + +// 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 + var x41 uint32 + x41, x40 = bits.Mul32(x23, 0xfffffffe) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x23, 0xffffffff) + var x44 uint32 + var x45 uint32 + x45, x44 = bits.Mul32(x23, 0xffffffff) + var x46 uint32 + var x47 uint32 + x47, x46 = bits.Mul32(x23, 0xffffffff) + var x48 uint32 + var x49 uint32 + x49, x48 = bits.Mul32(x23, 0xffffffff) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x23, 0xffffffff) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x23, 0xffffffff) + var x54 uint32 + var x55 uint32 + x54, x55 = bits.Add32(x53, x50, uint32(0x0)) + x56 := (uint32(uint1(x55)) + x51) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x49, x46, uint32(0x0)) + var x59 uint32 + var x60 uint32 + x59, x60 = bits.Add32(x47, x44, uint32(uint1(x58))) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x45, x42, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x43, x40, uint32(uint1(x62))) + x65 := (uint32(uint1(x64)) + x41) + var x67 uint32 + _, x67 = bits.Add32(x23, x52, uint32(0x0)) + var x68 uint32 + var x69 uint32 + x68, x69 = bits.Add32(x25, x54, uint32(uint1(x67))) + var x70 uint32 + var x71 uint32 + x70, x71 = bits.Add32(x27, x56, uint32(uint1(x69))) + var x72 uint32 + var x73 uint32 + x72, x73 = bits.Add32(x29, x48, uint32(uint1(x71))) + var x74 uint32 + var x75 uint32 + x74, x75 = bits.Add32(x31, x57, uint32(uint1(x73))) + var x76 uint32 + var x77 uint32 + x76, x77 = bits.Add32(x33, x59, uint32(uint1(x75))) + var x78 uint32 + var x79 uint32 + x78, x79 = bits.Add32(x35, x61, uint32(uint1(x77))) + var x80 uint32 + var x81 uint32 + x80, x81 = bits.Add32(x37, x63, uint32(uint1(x79))) + var x82 uint32 + var x83 uint32 + x82, x83 = bits.Add32(x39, x65, uint32(uint1(x81))) + var x84 uint32 + var x85 uint32 + x85, x84 = bits.Mul32(x1, arg1[7]) + var x86 uint32 + var x87 uint32 + x87, x86 = bits.Mul32(x1, arg1[6]) + var x88 uint32 + var x89 uint32 + x89, x88 = bits.Mul32(x1, arg1[5]) + var x90 uint32 + var x91 uint32 + x91, x90 = bits.Mul32(x1, arg1[4]) + var x92 uint32 + var x93 uint32 + x93, x92 = bits.Mul32(x1, arg1[3]) + var x94 uint32 + var x95 uint32 + x95, x94 = bits.Mul32(x1, arg1[2]) + var x96 uint32 + var x97 uint32 + x97, x96 = bits.Mul32(x1, arg1[1]) + var x98 uint32 + var x99 uint32 + x99, x98 = bits.Mul32(x1, arg1[0]) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x99, x96, uint32(0x0)) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(x97, x94, uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x95, x92, uint32(uint1(x103))) + var x106 uint32 + var x107 uint32 + x106, x107 = bits.Add32(x93, x90, uint32(uint1(x105))) + var x108 uint32 + var x109 uint32 + x108, x109 = bits.Add32(x91, x88, uint32(uint1(x107))) + var x110 uint32 + var x111 uint32 + x110, x111 = bits.Add32(x89, x86, uint32(uint1(x109))) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x87, x84, uint32(uint1(x111))) + x114 := (uint32(uint1(x113)) + x85) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x68, x98, uint32(0x0)) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x70, x100, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x119, x120 = bits.Add32(x72, x102, uint32(uint1(x118))) + var x121 uint32 + var x122 uint32 + x121, x122 = bits.Add32(x74, x104, uint32(uint1(x120))) + var x123 uint32 + var x124 uint32 + x123, x124 = bits.Add32(x76, x106, uint32(uint1(x122))) + var x125 uint32 + var x126 uint32 + x125, x126 = bits.Add32(x78, x108, uint32(uint1(x124))) + var x127 uint32 + var x128 uint32 + x127, x128 = bits.Add32(x80, x110, uint32(uint1(x126))) + var x129 uint32 + var x130 uint32 + x129, x130 = bits.Add32(x82, x112, uint32(uint1(x128))) + var x131 uint32 + var x132 uint32 + x131, x132 = bits.Add32(uint32(uint1(x83)), x114, uint32(uint1(x130))) + var x133 uint32 + var x134 uint32 + x134, x133 = bits.Mul32(x115, 0xfffffffe) + var x135 uint32 + var x136 uint32 + x136, x135 = bits.Mul32(x115, 0xffffffff) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x115, 0xffffffff) + var x139 uint32 + var x140 uint32 + x140, x139 = bits.Mul32(x115, 0xffffffff) + var x141 uint32 + var x142 uint32 + x142, x141 = bits.Mul32(x115, 0xffffffff) + var x143 uint32 + var x144 uint32 + x144, x143 = bits.Mul32(x115, 0xffffffff) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x115, 0xffffffff) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x146, x143, uint32(0x0)) + x149 := (uint32(uint1(x148)) + x144) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x142, x139, uint32(0x0)) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x140, x137, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x138, x135, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32(x136, x133, uint32(uint1(x155))) + x158 := (uint32(uint1(x157)) + x134) + var x160 uint32 + _, x160 = bits.Add32(x115, x145, uint32(0x0)) + var x161 uint32 + var x162 uint32 + x161, x162 = bits.Add32(x117, x147, uint32(uint1(x160))) + var x163 uint32 + var x164 uint32 + x163, x164 = bits.Add32(x119, x149, uint32(uint1(x162))) + var x165 uint32 + var x166 uint32 + x165, x166 = bits.Add32(x121, x141, uint32(uint1(x164))) + var x167 uint32 + var x168 uint32 + x167, x168 = bits.Add32(x123, x150, uint32(uint1(x166))) + var x169 uint32 + var x170 uint32 + x169, x170 = bits.Add32(x125, x152, uint32(uint1(x168))) + var x171 uint32 + var x172 uint32 + x171, x172 = bits.Add32(x127, x154, uint32(uint1(x170))) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x129, x156, uint32(uint1(x172))) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(x131, x158, uint32(uint1(x174))) + x177 := (uint32(uint1(x176)) + uint32(uint1(x132))) + var x178 uint32 + var x179 uint32 + x179, x178 = bits.Mul32(x2, arg1[7]) + var x180 uint32 + var x181 uint32 + x181, x180 = bits.Mul32(x2, arg1[6]) + var x182 uint32 + var x183 uint32 + x183, x182 = bits.Mul32(x2, arg1[5]) + var x184 uint32 + var x185 uint32 + x185, x184 = bits.Mul32(x2, arg1[4]) + var x186 uint32 + var x187 uint32 + x187, x186 = bits.Mul32(x2, arg1[3]) + var x188 uint32 + var x189 uint32 + x189, x188 = bits.Mul32(x2, arg1[2]) + var x190 uint32 + var x191 uint32 + x191, x190 = bits.Mul32(x2, arg1[1]) + var x192 uint32 + var x193 uint32 + x193, x192 = bits.Mul32(x2, arg1[0]) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x193, x190, uint32(0x0)) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x191, x188, uint32(uint1(x195))) + var x198 uint32 + var x199 uint32 + x198, x199 = bits.Add32(x189, x186, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x187, x184, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x185, x182, uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x183, x180, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(x181, x178, uint32(uint1(x205))) + x208 := (uint32(uint1(x207)) + x179) + var x209 uint32 + var x210 uint32 + x209, x210 = bits.Add32(x161, x192, uint32(0x0)) + var x211 uint32 + var x212 uint32 + x211, x212 = bits.Add32(x163, x194, uint32(uint1(x210))) + 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 + x228, x227 = bits.Mul32(x209, 0xfffffffe) + var x229 uint32 + var x230 uint32 + x230, x229 = bits.Mul32(x209, 0xffffffff) + var x231 uint32 + var x232 uint32 + x232, x231 = bits.Mul32(x209, 0xffffffff) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x209, 0xffffffff) + var x235 uint32 + var x236 uint32 + x236, x235 = bits.Mul32(x209, 0xffffffff) + var x237 uint32 + var x238 uint32 + x238, x237 = bits.Mul32(x209, 0xffffffff) + var x239 uint32 + var x240 uint32 + x240, x239 = bits.Mul32(x209, 0xffffffff) + var x241 uint32 + var x242 uint32 + x241, x242 = bits.Add32(x240, x237, uint32(0x0)) + x243 := (uint32(uint1(x242)) + x238) + var x244 uint32 + var x245 uint32 + x244, x245 = bits.Add32(x236, x233, uint32(0x0)) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x234, x231, uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x232, x229, uint32(uint1(x247))) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x230, x227, uint32(uint1(x249))) + x252 := (uint32(uint1(x251)) + x228) + var x254 uint32 + _, x254 = bits.Add32(x209, x239, uint32(0x0)) + var x255 uint32 + var x256 uint32 + x255, x256 = bits.Add32(x211, x241, uint32(uint1(x254))) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x213, x243, uint32(uint1(x256))) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(x215, x235, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x217, x244, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(x219, x246, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(x221, x248, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(x223, x250, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(x225, x252, uint32(uint1(x268))) + x271 := (uint32(uint1(x270)) + uint32(uint1(x226))) + var x272 uint32 + var x273 uint32 + x273, x272 = bits.Mul32(x3, arg1[7]) + var x274 uint32 + var x275 uint32 + x275, x274 = bits.Mul32(x3, arg1[6]) + var x276 uint32 + var x277 uint32 + x277, x276 = bits.Mul32(x3, arg1[5]) + var x278 uint32 + var x279 uint32 + x279, x278 = bits.Mul32(x3, arg1[4]) + var x280 uint32 + var x281 uint32 + x281, x280 = bits.Mul32(x3, arg1[3]) + var x282 uint32 + var x283 uint32 + x283, x282 = bits.Mul32(x3, arg1[2]) + var x284 uint32 + var x285 uint32 + x285, x284 = bits.Mul32(x3, arg1[1]) + var x286 uint32 + var x287 uint32 + x287, x286 = bits.Mul32(x3, arg1[0]) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x287, x284, uint32(0x0)) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x285, x282, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x283, x280, uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x281, x278, uint32(uint1(x293))) + var x296 uint32 + var x297 uint32 + x296, x297 = bits.Add32(x279, x276, uint32(uint1(x295))) + var x298 uint32 + var x299 uint32 + x298, x299 = bits.Add32(x277, x274, uint32(uint1(x297))) + var x300 uint32 + var x301 uint32 + x300, x301 = bits.Add32(x275, x272, uint32(uint1(x299))) + x302 := (uint32(uint1(x301)) + x273) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x255, x286, uint32(0x0)) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x257, x288, uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x259, x290, uint32(uint1(x306))) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x261, x292, uint32(uint1(x308))) + var x311 uint32 + var x312 uint32 + x311, x312 = bits.Add32(x263, x294, uint32(uint1(x310))) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x265, x296, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x267, x298, uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x269, x300, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x271, x302, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x322, x321 = bits.Mul32(x303, 0xfffffffe) + var x323 uint32 + var x324 uint32 + x324, x323 = bits.Mul32(x303, 0xffffffff) + var x325 uint32 + var x326 uint32 + x326, x325 = bits.Mul32(x303, 0xffffffff) + var x327 uint32 + var x328 uint32 + x328, x327 = bits.Mul32(x303, 0xffffffff) + var x329 uint32 + var x330 uint32 + x330, x329 = bits.Mul32(x303, 0xffffffff) + var x331 uint32 + var x332 uint32 + x332, x331 = bits.Mul32(x303, 0xffffffff) + var x333 uint32 + var x334 uint32 + x334, x333 = bits.Mul32(x303, 0xffffffff) + var x335 uint32 + var x336 uint32 + x335, x336 = bits.Add32(x334, x331, uint32(0x0)) + x337 := (uint32(uint1(x336)) + x332) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x330, x327, uint32(0x0)) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x328, x325, uint32(uint1(x339))) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32(x326, x323, uint32(uint1(x341))) + var x344 uint32 + var x345 uint32 + x344, x345 = bits.Add32(x324, x321, uint32(uint1(x343))) + x346 := (uint32(uint1(x345)) + x322) + var x348 uint32 + _, x348 = bits.Add32(x303, x333, uint32(0x0)) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(x305, x335, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(x307, x337, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(x309, x329, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x311, x338, uint32(uint1(x354))) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(x313, x340, uint32(uint1(x356))) + var x359 uint32 + var x360 uint32 + x359, x360 = bits.Add32(x315, x342, uint32(uint1(x358))) + var x361 uint32 + var x362 uint32 + x361, x362 = bits.Add32(x317, x344, uint32(uint1(x360))) + var x363 uint32 + var x364 uint32 + x363, x364 = bits.Add32(x319, x346, uint32(uint1(x362))) + x365 := (uint32(uint1(x364)) + uint32(uint1(x320))) + var x366 uint32 + var x367 uint32 + x367, x366 = bits.Mul32(x4, arg1[7]) + var x368 uint32 + var x369 uint32 + x369, x368 = bits.Mul32(x4, arg1[6]) + var x370 uint32 + var x371 uint32 + x371, x370 = bits.Mul32(x4, arg1[5]) + var x372 uint32 + var x373 uint32 + x373, x372 = bits.Mul32(x4, arg1[4]) + var x374 uint32 + var x375 uint32 + x375, x374 = bits.Mul32(x4, arg1[3]) + var x376 uint32 + var x377 uint32 + x377, x376 = bits.Mul32(x4, arg1[2]) + var x378 uint32 + var x379 uint32 + x379, x378 = bits.Mul32(x4, arg1[1]) + var x380 uint32 + var x381 uint32 + x381, x380 = bits.Mul32(x4, arg1[0]) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x381, x378, uint32(0x0)) + var x384 uint32 + var x385 uint32 + x384, x385 = bits.Add32(x379, x376, uint32(uint1(x383))) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x377, x374, uint32(uint1(x385))) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32(x375, x372, uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x373, x370, uint32(uint1(x389))) + var x392 uint32 + var x393 uint32 + x392, x393 = bits.Add32(x371, x368, uint32(uint1(x391))) + var x394 uint32 + var x395 uint32 + x394, x395 = bits.Add32(x369, x366, uint32(uint1(x393))) + x396 := (uint32(uint1(x395)) + x367) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x349, x380, uint32(0x0)) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x351, x382, uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x353, x384, uint32(uint1(x400))) + 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 + x416, x415 = bits.Mul32(x397, 0xfffffffe) + var x417 uint32 + var x418 uint32 + x418, x417 = bits.Mul32(x397, 0xffffffff) + var x419 uint32 + var x420 uint32 + x420, x419 = bits.Mul32(x397, 0xffffffff) + var x421 uint32 + var x422 uint32 + x422, x421 = bits.Mul32(x397, 0xffffffff) + var x423 uint32 + var x424 uint32 + x424, x423 = bits.Mul32(x397, 0xffffffff) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x397, 0xffffffff) + var x427 uint32 + var x428 uint32 + x428, x427 = bits.Mul32(x397, 0xffffffff) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x428, x425, uint32(0x0)) + x431 := (uint32(uint1(x430)) + x426) + var x432 uint32 + var x433 uint32 + x432, x433 = bits.Add32(x424, x421, uint32(0x0)) + var x434 uint32 + var x435 uint32 + x434, x435 = bits.Add32(x422, x419, uint32(uint1(x433))) + var x436 uint32 + var x437 uint32 + x436, x437 = bits.Add32(x420, x417, uint32(uint1(x435))) + var x438 uint32 + var x439 uint32 + x438, x439 = bits.Add32(x418, x415, uint32(uint1(x437))) + x440 := (uint32(uint1(x439)) + x416) + var x442 uint32 + _, x442 = bits.Add32(x397, x427, uint32(0x0)) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x399, x429, uint32(uint1(x442))) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x401, x431, uint32(uint1(x444))) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x403, x423, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x405, x432, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x407, x434, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x409, x436, uint32(uint1(x452))) + var x455 uint32 + var x456 uint32 + x455, x456 = bits.Add32(x411, x438, uint32(uint1(x454))) + var x457 uint32 + var x458 uint32 + x457, x458 = bits.Add32(x413, x440, uint32(uint1(x456))) + x459 := (uint32(uint1(x458)) + uint32(uint1(x414))) + var x460 uint32 + var x461 uint32 + x461, x460 = bits.Mul32(x5, arg1[7]) + var x462 uint32 + var x463 uint32 + x463, x462 = bits.Mul32(x5, arg1[6]) + var x464 uint32 + var x465 uint32 + x465, x464 = bits.Mul32(x5, arg1[5]) + var x466 uint32 + var x467 uint32 + x467, x466 = bits.Mul32(x5, arg1[4]) + var x468 uint32 + var x469 uint32 + x469, x468 = bits.Mul32(x5, arg1[3]) + var x470 uint32 + var x471 uint32 + x471, x470 = bits.Mul32(x5, arg1[2]) + var x472 uint32 + var x473 uint32 + x473, x472 = bits.Mul32(x5, arg1[1]) + var x474 uint32 + var x475 uint32 + x475, x474 = bits.Mul32(x5, arg1[0]) + var x476 uint32 + var x477 uint32 + x476, x477 = bits.Add32(x475, x472, uint32(0x0)) + var x478 uint32 + var x479 uint32 + x478, x479 = bits.Add32(x473, x470, uint32(uint1(x477))) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x471, x468, uint32(uint1(x479))) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x469, x466, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x467, x464, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x465, x462, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x463, x460, uint32(uint1(x487))) + x490 := (uint32(uint1(x489)) + x461) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x443, x474, uint32(0x0)) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x445, x476, uint32(uint1(x492))) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(x447, x478, uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x497, x498 = bits.Add32(x449, x480, uint32(uint1(x496))) + var x499 uint32 + var x500 uint32 + x499, x500 = bits.Add32(x451, x482, uint32(uint1(x498))) + var x501 uint32 + var x502 uint32 + x501, x502 = bits.Add32(x453, x484, uint32(uint1(x500))) + var x503 uint32 + var x504 uint32 + x503, x504 = bits.Add32(x455, x486, uint32(uint1(x502))) + var x505 uint32 + var x506 uint32 + x505, x506 = bits.Add32(x457, x488, uint32(uint1(x504))) + var x507 uint32 + var x508 uint32 + x507, x508 = bits.Add32(x459, x490, uint32(uint1(x506))) + var x509 uint32 + var x510 uint32 + x510, x509 = bits.Mul32(x491, 0xfffffffe) + var x511 uint32 + var x512 uint32 + x512, x511 = bits.Mul32(x491, 0xffffffff) + var x513 uint32 + var x514 uint32 + x514, x513 = bits.Mul32(x491, 0xffffffff) + var x515 uint32 + var x516 uint32 + x516, x515 = bits.Mul32(x491, 0xffffffff) + var x517 uint32 + var x518 uint32 + x518, x517 = bits.Mul32(x491, 0xffffffff) + var x519 uint32 + var x520 uint32 + x520, x519 = bits.Mul32(x491, 0xffffffff) + var x521 uint32 + var x522 uint32 + x522, x521 = bits.Mul32(x491, 0xffffffff) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x522, x519, uint32(0x0)) + x525 := (uint32(uint1(x524)) + x520) + var x526 uint32 + var x527 uint32 + x526, x527 = bits.Add32(x518, x515, uint32(0x0)) + var x528 uint32 + var x529 uint32 + x528, x529 = bits.Add32(x516, x513, uint32(uint1(x527))) + var x530 uint32 + var x531 uint32 + x530, x531 = bits.Add32(x514, x511, uint32(uint1(x529))) + var x532 uint32 + var x533 uint32 + x532, x533 = bits.Add32(x512, x509, uint32(uint1(x531))) + x534 := (uint32(uint1(x533)) + x510) + var x536 uint32 + _, x536 = bits.Add32(x491, x521, uint32(0x0)) + var x537 uint32 + var x538 uint32 + x537, x538 = bits.Add32(x493, x523, uint32(uint1(x536))) + var x539 uint32 + var x540 uint32 + x539, x540 = bits.Add32(x495, x525, uint32(uint1(x538))) + var x541 uint32 + var x542 uint32 + x541, x542 = bits.Add32(x497, x517, uint32(uint1(x540))) + var x543 uint32 + var x544 uint32 + x543, x544 = bits.Add32(x499, x526, uint32(uint1(x542))) + var x545 uint32 + var x546 uint32 + x545, x546 = bits.Add32(x501, x528, uint32(uint1(x544))) + var x547 uint32 + var x548 uint32 + x547, x548 = bits.Add32(x503, x530, uint32(uint1(x546))) + var x549 uint32 + var x550 uint32 + x549, x550 = bits.Add32(x505, x532, uint32(uint1(x548))) + var x551 uint32 + var x552 uint32 + x551, x552 = bits.Add32(x507, x534, uint32(uint1(x550))) + x553 := (uint32(uint1(x552)) + uint32(uint1(x508))) + var x554 uint32 + var x555 uint32 + x555, x554 = bits.Mul32(x6, arg1[7]) + var x556 uint32 + var x557 uint32 + x557, x556 = bits.Mul32(x6, arg1[6]) + var x558 uint32 + var x559 uint32 + x559, x558 = bits.Mul32(x6, arg1[5]) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x6, arg1[4]) + var x562 uint32 + var x563 uint32 + x563, x562 = bits.Mul32(x6, arg1[3]) + var x564 uint32 + var x565 uint32 + x565, x564 = bits.Mul32(x6, arg1[2]) + var x566 uint32 + var x567 uint32 + x567, x566 = bits.Mul32(x6, arg1[1]) + var x568 uint32 + var x569 uint32 + x569, x568 = bits.Mul32(x6, arg1[0]) + var x570 uint32 + var x571 uint32 + x570, x571 = bits.Add32(x569, x566, uint32(0x0)) + var x572 uint32 + var x573 uint32 + x572, x573 = bits.Add32(x567, x564, uint32(uint1(x571))) + var x574 uint32 + var x575 uint32 + x574, x575 = bits.Add32(x565, x562, uint32(uint1(x573))) + var x576 uint32 + var x577 uint32 + x576, x577 = bits.Add32(x563, x560, uint32(uint1(x575))) + var x578 uint32 + var x579 uint32 + x578, x579 = bits.Add32(x561, x558, uint32(uint1(x577))) + var x580 uint32 + var x581 uint32 + x580, x581 = bits.Add32(x559, x556, uint32(uint1(x579))) + var x582 uint32 + var x583 uint32 + x582, x583 = bits.Add32(x557, x554, uint32(uint1(x581))) + x584 := (uint32(uint1(x583)) + x555) + var x585 uint32 + var x586 uint32 + x585, x586 = bits.Add32(x537, x568, uint32(0x0)) + var x587 uint32 + var x588 uint32 + x587, x588 = bits.Add32(x539, x570, uint32(uint1(x586))) + var x589 uint32 + var x590 uint32 + x589, x590 = bits.Add32(x541, x572, uint32(uint1(x588))) + var x591 uint32 + var x592 uint32 + x591, x592 = bits.Add32(x543, x574, uint32(uint1(x590))) + 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 + x604, x603 = bits.Mul32(x585, 0xfffffffe) + var x605 uint32 + var x606 uint32 + x606, x605 = bits.Mul32(x585, 0xffffffff) + var x607 uint32 + var x608 uint32 + x608, x607 = bits.Mul32(x585, 0xffffffff) + var x609 uint32 + var x610 uint32 + x610, x609 = bits.Mul32(x585, 0xffffffff) + var x611 uint32 + var x612 uint32 + x612, x611 = bits.Mul32(x585, 0xffffffff) + var x613 uint32 + var x614 uint32 + x614, x613 = bits.Mul32(x585, 0xffffffff) + var x615 uint32 + var x616 uint32 + x616, x615 = bits.Mul32(x585, 0xffffffff) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x616, x613, uint32(0x0)) + x619 := (uint32(uint1(x618)) + x614) + var x620 uint32 + var x621 uint32 + x620, x621 = bits.Add32(x612, x609, uint32(0x0)) + var x622 uint32 + var x623 uint32 + x622, x623 = bits.Add32(x610, x607, uint32(uint1(x621))) + var x624 uint32 + var x625 uint32 + x624, x625 = bits.Add32(x608, x605, uint32(uint1(x623))) + var x626 uint32 + var x627 uint32 + x626, x627 = bits.Add32(x606, x603, uint32(uint1(x625))) + x628 := (uint32(uint1(x627)) + x604) + var x630 uint32 + _, x630 = bits.Add32(x585, x615, uint32(0x0)) + var x631 uint32 + var x632 uint32 + x631, x632 = bits.Add32(x587, x617, uint32(uint1(x630))) + var x633 uint32 + var x634 uint32 + x633, x634 = bits.Add32(x589, x619, uint32(uint1(x632))) + var x635 uint32 + var x636 uint32 + x635, x636 = bits.Add32(x591, x611, uint32(uint1(x634))) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x593, x620, uint32(uint1(x636))) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x595, x622, uint32(uint1(x638))) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x597, x624, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x599, x626, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x601, x628, uint32(uint1(x644))) + x647 := (uint32(uint1(x646)) + uint32(uint1(x602))) + var x648 uint32 + var x649 uint32 + x649, x648 = bits.Mul32(x7, arg1[7]) + var x650 uint32 + var x651 uint32 + x651, x650 = bits.Mul32(x7, arg1[6]) + var x652 uint32 + var x653 uint32 + x653, x652 = bits.Mul32(x7, arg1[5]) + var x654 uint32 + var x655 uint32 + x655, x654 = bits.Mul32(x7, arg1[4]) + var x656 uint32 + var x657 uint32 + x657, x656 = bits.Mul32(x7, arg1[3]) + var x658 uint32 + var x659 uint32 + x659, x658 = bits.Mul32(x7, arg1[2]) + var x660 uint32 + var x661 uint32 + x661, x660 = bits.Mul32(x7, arg1[1]) + var x662 uint32 + var x663 uint32 + x663, x662 = bits.Mul32(x7, arg1[0]) + var x664 uint32 + var x665 uint32 + x664, x665 = bits.Add32(x663, x660, uint32(0x0)) + var x666 uint32 + var x667 uint32 + x666, x667 = bits.Add32(x661, x658, uint32(uint1(x665))) + var x668 uint32 + var x669 uint32 + x668, x669 = bits.Add32(x659, x656, uint32(uint1(x667))) + var x670 uint32 + var x671 uint32 + x670, x671 = bits.Add32(x657, x654, uint32(uint1(x669))) + var x672 uint32 + var x673 uint32 + x672, x673 = bits.Add32(x655, x652, uint32(uint1(x671))) + var x674 uint32 + var x675 uint32 + x674, x675 = bits.Add32(x653, x650, uint32(uint1(x673))) + var x676 uint32 + var x677 uint32 + x676, x677 = bits.Add32(x651, x648, uint32(uint1(x675))) + x678 := (uint32(uint1(x677)) + x649) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Add32(x631, x662, uint32(0x0)) + var x681 uint32 + var x682 uint32 + x681, x682 = bits.Add32(x633, x664, uint32(uint1(x680))) + var x683 uint32 + var x684 uint32 + x683, x684 = bits.Add32(x635, x666, uint32(uint1(x682))) + var x685 uint32 + var x686 uint32 + x685, x686 = bits.Add32(x637, x668, uint32(uint1(x684))) + var x687 uint32 + var x688 uint32 + x687, x688 = bits.Add32(x639, x670, uint32(uint1(x686))) + var x689 uint32 + var x690 uint32 + x689, x690 = bits.Add32(x641, x672, uint32(uint1(x688))) + var x691 uint32 + var x692 uint32 + x691, x692 = bits.Add32(x643, x674, uint32(uint1(x690))) + var x693 uint32 + var x694 uint32 + x693, x694 = bits.Add32(x645, x676, uint32(uint1(x692))) + var x695 uint32 + var x696 uint32 + x695, x696 = bits.Add32(x647, x678, uint32(uint1(x694))) + var x697 uint32 + var x698 uint32 + x698, x697 = bits.Mul32(x679, 0xfffffffe) + var x699 uint32 + var x700 uint32 + x700, x699 = bits.Mul32(x679, 0xffffffff) + var x701 uint32 + var x702 uint32 + x702, x701 = bits.Mul32(x679, 0xffffffff) + var x703 uint32 + var x704 uint32 + x704, x703 = bits.Mul32(x679, 0xffffffff) + var x705 uint32 + var x706 uint32 + x706, x705 = bits.Mul32(x679, 0xffffffff) + var x707 uint32 + var x708 uint32 + x708, x707 = bits.Mul32(x679, 0xffffffff) + var x709 uint32 + var x710 uint32 + x710, x709 = bits.Mul32(x679, 0xffffffff) + var x711 uint32 + var x712 uint32 + x711, x712 = bits.Add32(x710, x707, uint32(0x0)) + x713 := (uint32(uint1(x712)) + x708) + var x714 uint32 + var x715 uint32 + x714, x715 = bits.Add32(x706, x703, uint32(0x0)) + var x716 uint32 + var x717 uint32 + x716, x717 = bits.Add32(x704, x701, uint32(uint1(x715))) + var x718 uint32 + var x719 uint32 + x718, x719 = bits.Add32(x702, x699, uint32(uint1(x717))) + var x720 uint32 + var x721 uint32 + x720, x721 = bits.Add32(x700, x697, uint32(uint1(x719))) + x722 := (uint32(uint1(x721)) + x698) + var x724 uint32 + _, x724 = bits.Add32(x679, x709, uint32(0x0)) + var x725 uint32 + var x726 uint32 + x725, x726 = bits.Add32(x681, x711, uint32(uint1(x724))) + var x727 uint32 + var x728 uint32 + x727, x728 = bits.Add32(x683, x713, uint32(uint1(x726))) + var x729 uint32 + var x730 uint32 + x729, x730 = bits.Add32(x685, x705, uint32(uint1(x728))) + var x731 uint32 + var x732 uint32 + x731, x732 = bits.Add32(x687, x714, uint32(uint1(x730))) + var x733 uint32 + var x734 uint32 + x733, x734 = bits.Add32(x689, x716, uint32(uint1(x732))) + var x735 uint32 + var x736 uint32 + x735, x736 = bits.Add32(x691, x718, uint32(uint1(x734))) + var x737 uint32 + var x738 uint32 + x737, x738 = bits.Add32(x693, x720, uint32(uint1(x736))) + var x739 uint32 + var x740 uint32 + x739, x740 = bits.Add32(x695, x722, uint32(uint1(x738))) + x741 := (uint32(uint1(x740)) + uint32(uint1(x696))) + var x742 uint32 + var x743 uint32 + x742, x743 = bits.Sub32(x725, 0xffffffff, uint32(0x0)) + var x744 uint32 + var x745 uint32 + x744, x745 = bits.Sub32(x727, 0xffffffff, uint32(uint1(x743))) + var x746 uint32 + var x747 uint32 + x746, x747 = bits.Sub32(x729, uint32(0x0), uint32(uint1(x745))) + var x748 uint32 + var x749 uint32 + x748, x749 = bits.Sub32(x731, 0xffffffff, uint32(uint1(x747))) + var x750 uint32 + var x751 uint32 + x750, x751 = bits.Sub32(x733, 0xffffffff, uint32(uint1(x749))) + var x752 uint32 + var x753 uint32 + x752, x753 = bits.Sub32(x735, 0xffffffff, uint32(uint1(x751))) + var x754 uint32 + var x755 uint32 + x754, x755 = bits.Sub32(x737, 0xffffffff, uint32(uint1(x753))) + var x756 uint32 + var x757 uint32 + x756, x757 = bits.Sub32(x739, 0xfffffffe, uint32(uint1(x755))) + var x759 uint32 + _, x759 = bits.Sub32(x741, uint32(0x0), uint32(uint1(x757))) + var x760 uint32 + cmovznzU32(&x760, uint1(x759), x742, x725) + var x761 uint32 + cmovznzU32(&x761, uint1(x759), x744, x727) + var x762 uint32 + cmovznzU32(&x762, uint1(x759), x746, x729) + var x763 uint32 + cmovznzU32(&x763, uint1(x759), x748, x731) + var x764 uint32 + cmovznzU32(&x764, uint1(x759), x750, x733) + var x765 uint32 + cmovznzU32(&x765, uint1(x759), x752, x735) + var x766 uint32 + cmovznzU32(&x766, uint1(x759), x754, x737) + var x767 uint32 + cmovznzU32(&x767, uint1(x759), x756, x739) + out1[0] = x760 + out1[1] = x761 + out1[2] = x762 + out1[3] = x763 + out1[4] = x764 + out1[5] = x765 + out1[6] = x766 + out1[7] = x767 +} + +// 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, 0xffffffff, uint32(0x0)) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(x3, 0xffffffff, uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(x5, uint32(0x0), uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(x7, 0xffffffff, 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, 0xffffffff, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Sub32(x15, 0xfffffffe, 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, uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, x17, uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, uint32(0x0), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, x17, 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, x17, uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, (x17 & 0xfffffffe), 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, uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, x17, uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, uint32(0x0), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, x17, 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, x17, uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, (x17 & 0xfffffffe), 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 + var x3 uint32 + x3, x2 = bits.Mul32(x1, 0xfffffffe) + var x4 uint32 + var x5 uint32 + x5, x4 = bits.Mul32(x1, 0xffffffff) + var x6 uint32 + var x7 uint32 + x7, x6 = bits.Mul32(x1, 0xffffffff) + var x8 uint32 + var x9 uint32 + x9, x8 = bits.Mul32(x1, 0xffffffff) + var x10 uint32 + var x11 uint32 + x11, x10 = bits.Mul32(x1, 0xffffffff) + var x12 uint32 + var x13 uint32 + x13, x12 = bits.Mul32(x1, 0xffffffff) + var x14 uint32 + var x15 uint32 + x15, x14 = bits.Mul32(x1, 0xffffffff) + var x16 uint32 + var x17 uint32 + x16, x17 = bits.Add32(x15, x12, uint32(0x0)) + var x18 uint32 + var x19 uint32 + x18, x19 = bits.Add32(x11, x8, uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x9, x6, uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x7, x4, uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x5, x2, uint32(uint1(x23))) + var x27 uint32 + _, x27 = bits.Add32(x1, x14, uint32(0x0)) + var x28 uint32 + var x29 uint32 + x28, x29 = bits.Add32(uint32(0x0), x16, uint32(uint1(x27))) + var x30 uint32 + var x31 uint32 + x30, x31 = bits.Add32(uint32(0x0), (uint32(uint1(x17)) + x13), uint32(uint1(x29))) + var x32 uint32 + var x33 uint32 + x32, x33 = bits.Add32(uint32(0x0), x10, uint32(uint1(x31))) + var x34 uint32 + var x35 uint32 + x34, x35 = bits.Add32(uint32(0x0), x18, uint32(uint1(x33))) + 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(x28, arg1[1], uint32(0x0)) + var x44 uint32 + var x45 uint32 + x44, x45 = bits.Add32(x30, uint32(0x0), uint32(uint1(x43))) + 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((uint32(uint1(x41)) + (uint32(uint1(x25)) + x3)), uint32(0x0), uint32(uint1(x55))) + var x58 uint32 + var x59 uint32 + x59, x58 = bits.Mul32(x42, 0xfffffffe) + var x60 uint32 + var x61 uint32 + x61, x60 = bits.Mul32(x42, 0xffffffff) + var x62 uint32 + var x63 uint32 + x63, x62 = bits.Mul32(x42, 0xffffffff) + var x64 uint32 + var x65 uint32 + x65, x64 = bits.Mul32(x42, 0xffffffff) + var x66 uint32 + var x67 uint32 + x67, x66 = bits.Mul32(x42, 0xffffffff) + var x68 uint32 + var x69 uint32 + x69, x68 = bits.Mul32(x42, 0xffffffff) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x42, 0xffffffff) + var x72 uint32 + var x73 uint32 + x72, x73 = bits.Add32(x71, x68, uint32(0x0)) + var x74 uint32 + var x75 uint32 + x74, x75 = bits.Add32(x67, x64, uint32(0x0)) + var x76 uint32 + var x77 uint32 + x76, x77 = bits.Add32(x65, x62, uint32(uint1(x75))) + var x78 uint32 + var x79 uint32 + x78, x79 = bits.Add32(x63, x60, uint32(uint1(x77))) + var x80 uint32 + var x81 uint32 + x80, x81 = bits.Add32(x61, x58, uint32(uint1(x79))) + var x83 uint32 + _, x83 = bits.Add32(x42, x70, uint32(0x0)) + var x84 uint32 + var x85 uint32 + x84, x85 = bits.Add32(x44, x72, uint32(uint1(x83))) + var x86 uint32 + var x87 uint32 + x86, x87 = bits.Add32(x46, (uint32(uint1(x73)) + x69), uint32(uint1(x85))) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x48, x66, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x50, x74, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x52, x76, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x54, x78, uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x56, x80, uint32(uint1(x95))) + var x98 uint32 + var x99 uint32 + x98, x99 = bits.Add32(uint32(uint1(x57)), (uint32(uint1(x81)) + x59), uint32(uint1(x97))) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x84, arg1[2], uint32(0x0)) + var x102 uint32 + var x103 uint32 + x102, x103 = bits.Add32(x86, uint32(0x0), uint32(uint1(x101))) + var x104 uint32 + var x105 uint32 + x104, x105 = bits.Add32(x88, uint32(0x0), uint32(uint1(x103))) + 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 + x117, x116 = bits.Mul32(x100, 0xfffffffe) + var x118 uint32 + var x119 uint32 + x119, x118 = bits.Mul32(x100, 0xffffffff) + var x120 uint32 + var x121 uint32 + x121, x120 = bits.Mul32(x100, 0xffffffff) + var x122 uint32 + var x123 uint32 + x123, x122 = bits.Mul32(x100, 0xffffffff) + var x124 uint32 + var x125 uint32 + x125, x124 = bits.Mul32(x100, 0xffffffff) + var x126 uint32 + var x127 uint32 + x127, x126 = bits.Mul32(x100, 0xffffffff) + var x128 uint32 + var x129 uint32 + x129, x128 = bits.Mul32(x100, 0xffffffff) + var x130 uint32 + var x131 uint32 + x130, x131 = bits.Add32(x129, x126, uint32(0x0)) + var x132 uint32 + var x133 uint32 + x132, x133 = bits.Add32(x125, x122, uint32(0x0)) + var x134 uint32 + var x135 uint32 + x134, x135 = bits.Add32(x123, x120, uint32(uint1(x133))) + var x136 uint32 + var x137 uint32 + x136, x137 = bits.Add32(x121, x118, uint32(uint1(x135))) + var x138 uint32 + var x139 uint32 + x138, x139 = bits.Add32(x119, x116, uint32(uint1(x137))) + var x141 uint32 + _, x141 = bits.Add32(x100, x128, uint32(0x0)) + var x142 uint32 + var x143 uint32 + x142, x143 = bits.Add32(x102, x130, uint32(uint1(x141))) + var x144 uint32 + var x145 uint32 + x144, x145 = bits.Add32(x104, (uint32(uint1(x131)) + x127), uint32(uint1(x143))) + var x146 uint32 + var x147 uint32 + x146, x147 = bits.Add32(x106, x124, uint32(uint1(x145))) + var x148 uint32 + var x149 uint32 + x148, x149 = bits.Add32(x108, x132, uint32(uint1(x147))) + var x150 uint32 + var x151 uint32 + x150, x151 = bits.Add32(x110, x134, uint32(uint1(x149))) + var x152 uint32 + var x153 uint32 + x152, x153 = bits.Add32(x112, x136, uint32(uint1(x151))) + var x154 uint32 + var x155 uint32 + x154, x155 = bits.Add32(x114, x138, uint32(uint1(x153))) + var x156 uint32 + var x157 uint32 + x156, x157 = bits.Add32((uint32(uint1(x115)) + uint32(uint1(x99))), (uint32(uint1(x139)) + x117), uint32(uint1(x155))) + var x158 uint32 + var x159 uint32 + x158, x159 = bits.Add32(x142, arg1[3], uint32(0x0)) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x144, uint32(0x0), uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x146, uint32(0x0), uint32(uint1(x161))) + var x164 uint32 + var x165 uint32 + x164, x165 = bits.Add32(x148, uint32(0x0), uint32(uint1(x163))) + 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 + x175, x174 = bits.Mul32(x158, 0xfffffffe) + var x176 uint32 + var x177 uint32 + x177, x176 = bits.Mul32(x158, 0xffffffff) + var x178 uint32 + var x179 uint32 + x179, x178 = bits.Mul32(x158, 0xffffffff) + var x180 uint32 + var x181 uint32 + x181, x180 = bits.Mul32(x158, 0xffffffff) + var x182 uint32 + var x183 uint32 + x183, x182 = bits.Mul32(x158, 0xffffffff) + var x184 uint32 + var x185 uint32 + x185, x184 = bits.Mul32(x158, 0xffffffff) + var x186 uint32 + var x187 uint32 + x187, x186 = bits.Mul32(x158, 0xffffffff) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Add32(x187, x184, uint32(0x0)) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Add32(x183, x180, uint32(0x0)) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Add32(x181, x178, uint32(uint1(x191))) + var x194 uint32 + var x195 uint32 + x194, x195 = bits.Add32(x179, x176, uint32(uint1(x193))) + var x196 uint32 + var x197 uint32 + x196, x197 = bits.Add32(x177, x174, uint32(uint1(x195))) + var x199 uint32 + _, x199 = bits.Add32(x158, x186, uint32(0x0)) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Add32(x160, x188, uint32(uint1(x199))) + var x202 uint32 + var x203 uint32 + x202, x203 = bits.Add32(x162, (uint32(uint1(x189)) + x185), uint32(uint1(x201))) + var x204 uint32 + var x205 uint32 + x204, x205 = bits.Add32(x164, x182, uint32(uint1(x203))) + var x206 uint32 + var x207 uint32 + x206, x207 = bits.Add32(x166, x190, uint32(uint1(x205))) + var x208 uint32 + var x209 uint32 + x208, x209 = bits.Add32(x168, x192, uint32(uint1(x207))) + var x210 uint32 + var x211 uint32 + x210, x211 = bits.Add32(x170, x194, uint32(uint1(x209))) + var x212 uint32 + var x213 uint32 + x212, x213 = bits.Add32(x172, x196, uint32(uint1(x211))) + var x214 uint32 + var x215 uint32 + x214, x215 = bits.Add32((uint32(uint1(x173)) + uint32(uint1(x157))), (uint32(uint1(x197)) + x175), uint32(uint1(x213))) + var x216 uint32 + var x217 uint32 + x216, x217 = bits.Add32(x200, arg1[4], uint32(0x0)) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x202, uint32(0x0), uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x204, uint32(0x0), uint32(uint1(x219))) + var x222 uint32 + var x223 uint32 + x222, x223 = bits.Add32(x206, uint32(0x0), uint32(uint1(x221))) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x208, uint32(0x0), uint32(uint1(x223))) + 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 + x233, x232 = bits.Mul32(x216, 0xfffffffe) + var x234 uint32 + var x235 uint32 + x235, x234 = bits.Mul32(x216, 0xffffffff) + var x236 uint32 + var x237 uint32 + x237, x236 = bits.Mul32(x216, 0xffffffff) + var x238 uint32 + var x239 uint32 + x239, x238 = bits.Mul32(x216, 0xffffffff) + var x240 uint32 + var x241 uint32 + x241, x240 = bits.Mul32(x216, 0xffffffff) + var x242 uint32 + var x243 uint32 + x243, x242 = bits.Mul32(x216, 0xffffffff) + var x244 uint32 + var x245 uint32 + x245, x244 = bits.Mul32(x216, 0xffffffff) + var x246 uint32 + var x247 uint32 + x246, x247 = bits.Add32(x245, x242, uint32(0x0)) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x241, x238, uint32(0x0)) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x239, x236, uint32(uint1(x249))) + var x252 uint32 + var x253 uint32 + x252, x253 = bits.Add32(x237, x234, uint32(uint1(x251))) + var x254 uint32 + var x255 uint32 + x254, x255 = bits.Add32(x235, x232, uint32(uint1(x253))) + var x257 uint32 + _, x257 = bits.Add32(x216, x244, uint32(0x0)) + var x258 uint32 + var x259 uint32 + x258, x259 = bits.Add32(x218, x246, uint32(uint1(x257))) + var x260 uint32 + var x261 uint32 + x260, x261 = bits.Add32(x220, (uint32(uint1(x247)) + x243), uint32(uint1(x259))) + var x262 uint32 + var x263 uint32 + x262, x263 = bits.Add32(x222, x240, uint32(uint1(x261))) + var x264 uint32 + var x265 uint32 + x264, x265 = bits.Add32(x224, x248, uint32(uint1(x263))) + var x266 uint32 + var x267 uint32 + x266, x267 = bits.Add32(x226, x250, uint32(uint1(x265))) + var x268 uint32 + var x269 uint32 + x268, x269 = bits.Add32(x228, x252, uint32(uint1(x267))) + var x270 uint32 + var x271 uint32 + x270, x271 = bits.Add32(x230, x254, uint32(uint1(x269))) + var x272 uint32 + var x273 uint32 + x272, x273 = bits.Add32((uint32(uint1(x231)) + uint32(uint1(x215))), (uint32(uint1(x255)) + x233), uint32(uint1(x271))) + var x274 uint32 + var x275 uint32 + x274, x275 = bits.Add32(x258, arg1[5], uint32(0x0)) + var x276 uint32 + var x277 uint32 + x276, x277 = bits.Add32(x260, uint32(0x0), uint32(uint1(x275))) + var x278 uint32 + var x279 uint32 + x278, x279 = bits.Add32(x262, uint32(0x0), uint32(uint1(x277))) + var x280 uint32 + var x281 uint32 + x280, x281 = bits.Add32(x264, uint32(0x0), uint32(uint1(x279))) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x266, uint32(0x0), uint32(uint1(x281))) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x268, uint32(0x0), uint32(uint1(x283))) + 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 + x291, x290 = bits.Mul32(x274, 0xfffffffe) + var x292 uint32 + var x293 uint32 + x293, x292 = bits.Mul32(x274, 0xffffffff) + var x294 uint32 + var x295 uint32 + x295, x294 = bits.Mul32(x274, 0xffffffff) + var x296 uint32 + var x297 uint32 + x297, x296 = bits.Mul32(x274, 0xffffffff) + var x298 uint32 + var x299 uint32 + x299, x298 = bits.Mul32(x274, 0xffffffff) + var x300 uint32 + var x301 uint32 + x301, x300 = bits.Mul32(x274, 0xffffffff) + var x302 uint32 + var x303 uint32 + x303, x302 = bits.Mul32(x274, 0xffffffff) + var x304 uint32 + var x305 uint32 + x304, x305 = bits.Add32(x303, x300, uint32(0x0)) + var x306 uint32 + var x307 uint32 + x306, x307 = bits.Add32(x299, x296, uint32(0x0)) + var x308 uint32 + var x309 uint32 + x308, x309 = bits.Add32(x297, x294, uint32(uint1(x307))) + var x310 uint32 + var x311 uint32 + x310, x311 = bits.Add32(x295, x292, uint32(uint1(x309))) + var x312 uint32 + var x313 uint32 + x312, x313 = bits.Add32(x293, x290, uint32(uint1(x311))) + var x315 uint32 + _, x315 = bits.Add32(x274, x302, uint32(0x0)) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x276, x304, uint32(uint1(x315))) + var x318 uint32 + var x319 uint32 + x318, x319 = bits.Add32(x278, (uint32(uint1(x305)) + x301), uint32(uint1(x317))) + var x320 uint32 + var x321 uint32 + x320, x321 = bits.Add32(x280, x298, uint32(uint1(x319))) + var x322 uint32 + var x323 uint32 + x322, x323 = bits.Add32(x282, x306, uint32(uint1(x321))) + var x324 uint32 + var x325 uint32 + x324, x325 = bits.Add32(x284, x308, uint32(uint1(x323))) + var x326 uint32 + var x327 uint32 + x326, x327 = bits.Add32(x286, x310, uint32(uint1(x325))) + var x328 uint32 + var x329 uint32 + x328, x329 = bits.Add32(x288, x312, uint32(uint1(x327))) + var x330 uint32 + var x331 uint32 + x330, x331 = bits.Add32((uint32(uint1(x289)) + uint32(uint1(x273))), (uint32(uint1(x313)) + x291), uint32(uint1(x329))) + var x332 uint32 + var x333 uint32 + x332, x333 = bits.Add32(x316, arg1[6], uint32(0x0)) + var x334 uint32 + var x335 uint32 + x334, x335 = bits.Add32(x318, uint32(0x0), uint32(uint1(x333))) + var x336 uint32 + var x337 uint32 + x336, x337 = bits.Add32(x320, uint32(0x0), uint32(uint1(x335))) + var x338 uint32 + var x339 uint32 + x338, x339 = bits.Add32(x322, uint32(0x0), uint32(uint1(x337))) + var x340 uint32 + var x341 uint32 + x340, x341 = bits.Add32(x324, uint32(0x0), uint32(uint1(x339))) + var x342 uint32 + var x343 uint32 + x342, x343 = bits.Add32(x326, uint32(0x0), uint32(uint1(x341))) + var x344 uint32 + var x345 uint32 + x344, x345 = bits.Add32(x328, uint32(0x0), uint32(uint1(x343))) + var x346 uint32 + var x347 uint32 + x346, x347 = bits.Add32(x330, uint32(0x0), uint32(uint1(x345))) + var x348 uint32 + var x349 uint32 + x349, x348 = bits.Mul32(x332, 0xfffffffe) + var x350 uint32 + var x351 uint32 + x351, x350 = bits.Mul32(x332, 0xffffffff) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x332, 0xffffffff) + var x354 uint32 + var x355 uint32 + x355, x354 = bits.Mul32(x332, 0xffffffff) + var x356 uint32 + var x357 uint32 + x357, x356 = bits.Mul32(x332, 0xffffffff) + var x358 uint32 + var x359 uint32 + x359, x358 = bits.Mul32(x332, 0xffffffff) + var x360 uint32 + var x361 uint32 + x361, x360 = bits.Mul32(x332, 0xffffffff) + var x362 uint32 + var x363 uint32 + x362, x363 = bits.Add32(x361, x358, uint32(0x0)) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x357, x354, uint32(0x0)) + var x366 uint32 + var x367 uint32 + x366, x367 = bits.Add32(x355, x352, uint32(uint1(x365))) + var x368 uint32 + var x369 uint32 + x368, x369 = bits.Add32(x353, x350, uint32(uint1(x367))) + var x370 uint32 + var x371 uint32 + x370, x371 = bits.Add32(x351, x348, uint32(uint1(x369))) + var x373 uint32 + _, x373 = bits.Add32(x332, x360, uint32(0x0)) + var x374 uint32 + var x375 uint32 + x374, x375 = bits.Add32(x334, x362, uint32(uint1(x373))) + var x376 uint32 + var x377 uint32 + x376, x377 = bits.Add32(x336, (uint32(uint1(x363)) + x359), uint32(uint1(x375))) + var x378 uint32 + var x379 uint32 + x378, x379 = bits.Add32(x338, x356, uint32(uint1(x377))) + var x380 uint32 + var x381 uint32 + x380, x381 = bits.Add32(x340, x364, uint32(uint1(x379))) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x342, x366, uint32(uint1(x381))) + var x384 uint32 + var x385 uint32 + x384, x385 = bits.Add32(x344, x368, uint32(uint1(x383))) + var x386 uint32 + var x387 uint32 + x386, x387 = bits.Add32(x346, x370, uint32(uint1(x385))) + var x388 uint32 + var x389 uint32 + x388, x389 = bits.Add32((uint32(uint1(x347)) + uint32(uint1(x331))), (uint32(uint1(x371)) + x349), uint32(uint1(x387))) + var x390 uint32 + var x391 uint32 + x390, x391 = bits.Add32(x374, arg1[7], uint32(0x0)) + 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 + var x399 uint32 + x398, x399 = bits.Add32(x382, uint32(0x0), uint32(uint1(x397))) + var x400 uint32 + var x401 uint32 + x400, x401 = bits.Add32(x384, uint32(0x0), uint32(uint1(x399))) + var x402 uint32 + var x403 uint32 + x402, x403 = bits.Add32(x386, uint32(0x0), uint32(uint1(x401))) + var x404 uint32 + var x405 uint32 + x404, x405 = bits.Add32(x388, uint32(0x0), uint32(uint1(x403))) + var x406 uint32 + var x407 uint32 + x407, x406 = bits.Mul32(x390, 0xfffffffe) + var x408 uint32 + var x409 uint32 + x409, x408 = bits.Mul32(x390, 0xffffffff) + var x410 uint32 + var x411 uint32 + x411, x410 = bits.Mul32(x390, 0xffffffff) + var x412 uint32 + var x413 uint32 + x413, x412 = bits.Mul32(x390, 0xffffffff) + var x414 uint32 + var x415 uint32 + x415, x414 = bits.Mul32(x390, 0xffffffff) + var x416 uint32 + var x417 uint32 + x417, x416 = bits.Mul32(x390, 0xffffffff) + var x418 uint32 + var x419 uint32 + x419, x418 = bits.Mul32(x390, 0xffffffff) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x419, x416, uint32(0x0)) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x415, x412, uint32(0x0)) + var x424 uint32 + var x425 uint32 + x424, x425 = bits.Add32(x413, x410, uint32(uint1(x423))) + var x426 uint32 + var x427 uint32 + x426, x427 = bits.Add32(x411, x408, uint32(uint1(x425))) + var x428 uint32 + var x429 uint32 + x428, x429 = bits.Add32(x409, x406, uint32(uint1(x427))) + var x431 uint32 + _, x431 = bits.Add32(x390, x418, uint32(0x0)) + var x432 uint32 + var x433 uint32 + x432, x433 = bits.Add32(x392, x420, uint32(uint1(x431))) + var x434 uint32 + var x435 uint32 + x434, x435 = bits.Add32(x394, (uint32(uint1(x421)) + x417), uint32(uint1(x433))) + var x436 uint32 + var x437 uint32 + x436, x437 = bits.Add32(x396, x414, uint32(uint1(x435))) + var x438 uint32 + var x439 uint32 + x438, x439 = bits.Add32(x398, x422, uint32(uint1(x437))) + var x440 uint32 + var x441 uint32 + x440, x441 = bits.Add32(x400, x424, uint32(uint1(x439))) + var x442 uint32 + var x443 uint32 + x442, x443 = bits.Add32(x402, x426, uint32(uint1(x441))) + var x444 uint32 + var x445 uint32 + x444, x445 = bits.Add32(x404, x428, uint32(uint1(x443))) + var x446 uint32 + var x447 uint32 + x446, x447 = bits.Add32((uint32(uint1(x405)) + uint32(uint1(x389))), (uint32(uint1(x429)) + x407), uint32(uint1(x445))) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Sub32(x432, 0xffffffff, uint32(0x0)) + var x450 uint32 + var x451 uint32 + x450, x451 = bits.Sub32(x434, 0xffffffff, uint32(uint1(x449))) + var x452 uint32 + var x453 uint32 + x452, x453 = bits.Sub32(x436, uint32(0x0), uint32(uint1(x451))) + var x454 uint32 + var x455 uint32 + x454, x455 = bits.Sub32(x438, 0xffffffff, uint32(uint1(x453))) + var x456 uint32 + var x457 uint32 + x456, x457 = bits.Sub32(x440, 0xffffffff, uint32(uint1(x455))) + var x458 uint32 + var x459 uint32 + x458, x459 = bits.Sub32(x442, 0xffffffff, uint32(uint1(x457))) + var x460 uint32 + var x461 uint32 + x460, x461 = bits.Sub32(x444, 0xffffffff, uint32(uint1(x459))) + var x462 uint32 + var x463 uint32 + x462, x463 = bits.Sub32(x446, 0xfffffffe, uint32(uint1(x461))) + var x465 uint32 + _, x465 = bits.Sub32(uint32(uint1(x447)), uint32(0x0), uint32(uint1(x463))) + var x466 uint32 + cmovznzU32(&x466, uint1(x465), x448, x432) + var x467 uint32 + cmovznzU32(&x467, uint1(x465), x450, x434) + var x468 uint32 + cmovznzU32(&x468, uint1(x465), x452, x436) + var x469 uint32 + cmovznzU32(&x469, uint1(x465), x454, x438) + var x470 uint32 + cmovznzU32(&x470, uint1(x465), x456, x440) + var x471 uint32 + cmovznzU32(&x471, uint1(x465), x458, x442) + var x472 uint32 + cmovznzU32(&x472, uint1(x465), x460, x444) + var x473 uint32 + cmovznzU32(&x473, uint1(x465), x462, x446) + out1[0] = x466 + out1[1] = x467 + out1[2] = x468 + out1[3] = x469 + out1[4] = x470 + out1[5] = x471 + out1[6] = x472 + out1[7] = x473 +} + +// 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, 0x4) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, 0x2) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, 0x2) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, 0xffffffff) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, 0x2) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, 0x3) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Add32(x20, x17, uint32(0x0)) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Add32(uint32(uint1(x18)), x15, uint32(uint1(x22))) + var x25 uint32 + var x26 uint32 + x25, x26 = bits.Add32(x16, x13, uint32(uint1(x24))) + var x27 uint32 + var x28 uint32 + x27, x28 = bits.Add32(uint32(uint1(x14)), x8, uint32(uint1(x26))) + var x29 uint32 + var x30 uint32 + x29, x30 = bits.Add32(uint32(0x0), x8, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Add32(uint32(0x0), x11, uint32(uint1(x30))) + var x33 uint32 + var x34 uint32 + x33, x34 = bits.Add32(uint32(uint1(x12)), x9, uint32(uint1(x32))) + var x35 uint32 + var x36 uint32 + x36, x35 = bits.Mul32(x19, 0xfffffffe) + var x37 uint32 + var x38 uint32 + x38, x37 = bits.Mul32(x19, 0xffffffff) + var x39 uint32 + var x40 uint32 + x40, x39 = bits.Mul32(x19, 0xffffffff) + var x41 uint32 + var x42 uint32 + x42, x41 = bits.Mul32(x19, 0xffffffff) + var x43 uint32 + var x44 uint32 + x44, x43 = bits.Mul32(x19, 0xffffffff) + var x45 uint32 + var x46 uint32 + x46, x45 = bits.Mul32(x19, 0xffffffff) + var x47 uint32 + var x48 uint32 + x48, x47 = bits.Mul32(x19, 0xffffffff) + var x49 uint32 + var x50 uint32 + x49, x50 = bits.Add32(x48, x45, uint32(0x0)) + var x51 uint32 + var x52 uint32 + x51, x52 = bits.Add32(x44, x41, uint32(0x0)) + var x53 uint32 + var x54 uint32 + x53, x54 = bits.Add32(x42, x39, uint32(uint1(x52))) + var x55 uint32 + var x56 uint32 + x55, x56 = bits.Add32(x40, x37, uint32(uint1(x54))) + var x57 uint32 + var x58 uint32 + x57, x58 = bits.Add32(x38, x35, uint32(uint1(x56))) + var x60 uint32 + _, x60 = bits.Add32(x19, x47, uint32(0x0)) + var x61 uint32 + var x62 uint32 + x61, x62 = bits.Add32(x21, x49, uint32(uint1(x60))) + var x63 uint32 + var x64 uint32 + x63, x64 = bits.Add32(x23, (uint32(uint1(x50)) + x46), uint32(uint1(x62))) + var x65 uint32 + var x66 uint32 + x65, x66 = bits.Add32(x25, x43, uint32(uint1(x64))) + var x67 uint32 + var x68 uint32 + x67, x68 = bits.Add32(x27, x51, uint32(uint1(x66))) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Add32(x29, x53, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Add32(x31, x55, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Add32(x33, x57, uint32(uint1(x72))) + var x75 uint32 + var x76 uint32 + x75, x76 = bits.Add32((uint32(uint1(x34)) + x10), (uint32(uint1(x58)) + x36), uint32(uint1(x74))) + var x77 uint32 + var x78 uint32 + x78, x77 = bits.Mul32(x1, 0x4) + var x79 uint32 + var x80 uint32 + x80, x79 = bits.Mul32(x1, 0x2) + var x81 uint32 + var x82 uint32 + x82, x81 = bits.Mul32(x1, 0x2) + var x83 uint32 + var x84 uint32 + x84, x83 = bits.Mul32(x1, 0xffffffff) + var x85 uint32 + var x86 uint32 + x86, x85 = bits.Mul32(x1, 0x2) + var x87 uint32 + var x88 uint32 + x88, x87 = bits.Mul32(x1, 0x3) + var x89 uint32 + var x90 uint32 + x89, x90 = bits.Add32(x88, x85, uint32(0x0)) + var x91 uint32 + var x92 uint32 + x91, x92 = bits.Add32(uint32(uint1(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(uint32(uint1(x82)), x1, uint32(uint1(x94))) + var x97 uint32 + var x98 uint32 + x97, x98 = bits.Add32(uint32(0x0), x1, uint32(uint1(x96))) + var x99 uint32 + var x100 uint32 + x99, x100 = bits.Add32(uint32(0x0), x79, uint32(uint1(x98))) + var x101 uint32 + var x102 uint32 + x101, x102 = bits.Add32(uint32(uint1(x80)), x77, uint32(uint1(x100))) + var x103 uint32 + var x104 uint32 + x103, x104 = bits.Add32(x61, x87, uint32(0x0)) + var x105 uint32 + var x106 uint32 + x105, x106 = bits.Add32(x63, x89, uint32(uint1(x104))) + var x107 uint32 + var x108 uint32 + x107, x108 = bits.Add32(x65, x91, uint32(uint1(x106))) + var x109 uint32 + var x110 uint32 + x109, x110 = bits.Add32(x67, x93, uint32(uint1(x108))) + var x111 uint32 + var x112 uint32 + x111, x112 = bits.Add32(x69, x95, uint32(uint1(x110))) + var x113 uint32 + var x114 uint32 + x113, x114 = bits.Add32(x71, x97, uint32(uint1(x112))) + var x115 uint32 + var x116 uint32 + x115, x116 = bits.Add32(x73, x99, uint32(uint1(x114))) + var x117 uint32 + var x118 uint32 + x117, x118 = bits.Add32(x75, x101, uint32(uint1(x116))) + var x119 uint32 + var x120 uint32 + x120, x119 = bits.Mul32(x103, 0xfffffffe) + var x121 uint32 + var x122 uint32 + x122, x121 = bits.Mul32(x103, 0xffffffff) + var x123 uint32 + var x124 uint32 + x124, x123 = bits.Mul32(x103, 0xffffffff) + var x125 uint32 + var x126 uint32 + x126, x125 = bits.Mul32(x103, 0xffffffff) + var x127 uint32 + var x128 uint32 + x128, x127 = bits.Mul32(x103, 0xffffffff) + var x129 uint32 + var x130 uint32 + x130, x129 = bits.Mul32(x103, 0xffffffff) + var x131 uint32 + var x132 uint32 + x132, x131 = bits.Mul32(x103, 0xffffffff) + var x133 uint32 + var x134 uint32 + x133, x134 = bits.Add32(x132, x129, uint32(0x0)) + var x135 uint32 + var x136 uint32 + x135, x136 = bits.Add32(x128, x125, uint32(0x0)) + var x137 uint32 + var x138 uint32 + x137, x138 = bits.Add32(x126, x123, uint32(uint1(x136))) + var x139 uint32 + var x140 uint32 + x139, x140 = bits.Add32(x124, x121, uint32(uint1(x138))) + var x141 uint32 + var x142 uint32 + x141, x142 = bits.Add32(x122, x119, uint32(uint1(x140))) + var x144 uint32 + _, x144 = bits.Add32(x103, x131, uint32(0x0)) + var x145 uint32 + var x146 uint32 + x145, x146 = bits.Add32(x105, x133, uint32(uint1(x144))) + var x147 uint32 + var x148 uint32 + x147, x148 = bits.Add32(x107, (uint32(uint1(x134)) + x130), uint32(uint1(x146))) + var x149 uint32 + var x150 uint32 + x149, x150 = bits.Add32(x109, x127, uint32(uint1(x148))) + var x151 uint32 + var x152 uint32 + x151, x152 = bits.Add32(x111, x135, uint32(uint1(x150))) + var x153 uint32 + var x154 uint32 + x153, x154 = bits.Add32(x113, x137, uint32(uint1(x152))) + var x155 uint32 + var x156 uint32 + x155, x156 = bits.Add32(x115, x139, uint32(uint1(x154))) + var x157 uint32 + var x158 uint32 + x157, x158 = bits.Add32(x117, x141, uint32(uint1(x156))) + var x159 uint32 + var x160 uint32 + x159, x160 = bits.Add32(((uint32(uint1(x118)) + uint32(uint1(x76))) + (uint32(uint1(x102)) + x78)), (uint32(uint1(x142)) + x120), uint32(uint1(x158))) + var x161 uint32 + var x162 uint32 + x162, x161 = bits.Mul32(x2, 0x4) + var x163 uint32 + var x164 uint32 + x164, x163 = bits.Mul32(x2, 0x2) + var x165 uint32 + var x166 uint32 + x166, x165 = bits.Mul32(x2, 0x2) + var x167 uint32 + var x168 uint32 + x168, x167 = bits.Mul32(x2, 0xffffffff) + var x169 uint32 + var x170 uint32 + x170, x169 = bits.Mul32(x2, 0x2) + var x171 uint32 + var x172 uint32 + x172, x171 = bits.Mul32(x2, 0x3) + var x173 uint32 + var x174 uint32 + x173, x174 = bits.Add32(x172, x169, uint32(0x0)) + var x175 uint32 + var x176 uint32 + x175, x176 = bits.Add32(uint32(uint1(x170)), x167, uint32(uint1(x174))) + var x177 uint32 + var x178 uint32 + x177, x178 = bits.Add32(x168, x165, uint32(uint1(x176))) + var x179 uint32 + var x180 uint32 + x179, x180 = bits.Add32(uint32(uint1(x166)), x2, uint32(uint1(x178))) + var x181 uint32 + var x182 uint32 + x181, x182 = bits.Add32(uint32(0x0), x2, uint32(uint1(x180))) + var x183 uint32 + var x184 uint32 + x183, x184 = bits.Add32(uint32(0x0), x163, uint32(uint1(x182))) + var x185 uint32 + var x186 uint32 + x185, x186 = bits.Add32(uint32(uint1(x164)), x161, uint32(uint1(x184))) + var x187 uint32 + var x188 uint32 + x187, x188 = bits.Add32(x145, x171, uint32(0x0)) + var x189 uint32 + var x190 uint32 + x189, x190 = bits.Add32(x147, x173, uint32(uint1(x188))) + var x191 uint32 + var x192 uint32 + x191, x192 = bits.Add32(x149, x175, uint32(uint1(x190))) + var x193 uint32 + var x194 uint32 + x193, x194 = bits.Add32(x151, x177, uint32(uint1(x192))) + var x195 uint32 + var x196 uint32 + x195, x196 = bits.Add32(x153, x179, uint32(uint1(x194))) + var x197 uint32 + var x198 uint32 + x197, x198 = bits.Add32(x155, x181, uint32(uint1(x196))) + var x199 uint32 + var x200 uint32 + x199, x200 = bits.Add32(x157, x183, uint32(uint1(x198))) + var x201 uint32 + var x202 uint32 + x201, x202 = bits.Add32(x159, x185, uint32(uint1(x200))) + var x203 uint32 + var x204 uint32 + x204, x203 = bits.Mul32(x187, 0xfffffffe) + var x205 uint32 + var x206 uint32 + x206, x205 = bits.Mul32(x187, 0xffffffff) + var x207 uint32 + var x208 uint32 + x208, x207 = bits.Mul32(x187, 0xffffffff) + var x209 uint32 + var x210 uint32 + x210, x209 = bits.Mul32(x187, 0xffffffff) + var x211 uint32 + var x212 uint32 + x212, x211 = bits.Mul32(x187, 0xffffffff) + var x213 uint32 + var x214 uint32 + x214, x213 = bits.Mul32(x187, 0xffffffff) + var x215 uint32 + var x216 uint32 + x216, x215 = bits.Mul32(x187, 0xffffffff) + var x217 uint32 + var x218 uint32 + x217, x218 = bits.Add32(x216, x213, uint32(0x0)) + var x219 uint32 + var x220 uint32 + x219, x220 = bits.Add32(x212, x209, uint32(0x0)) + var x221 uint32 + var x222 uint32 + x221, x222 = bits.Add32(x210, x207, uint32(uint1(x220))) + var x223 uint32 + var x224 uint32 + x223, x224 = bits.Add32(x208, x205, uint32(uint1(x222))) + var x225 uint32 + var x226 uint32 + x225, x226 = bits.Add32(x206, x203, uint32(uint1(x224))) + var x228 uint32 + _, x228 = bits.Add32(x187, x215, uint32(0x0)) + var x229 uint32 + var x230 uint32 + x229, x230 = bits.Add32(x189, x217, uint32(uint1(x228))) + var x231 uint32 + var x232 uint32 + x231, x232 = bits.Add32(x191, (uint32(uint1(x218)) + x214), uint32(uint1(x230))) + var x233 uint32 + var x234 uint32 + x233, x234 = bits.Add32(x193, x211, uint32(uint1(x232))) + var x235 uint32 + var x236 uint32 + x235, x236 = bits.Add32(x195, x219, uint32(uint1(x234))) + var x237 uint32 + var x238 uint32 + x237, x238 = bits.Add32(x197, x221, uint32(uint1(x236))) + var x239 uint32 + var x240 uint32 + x239, x240 = bits.Add32(x199, x223, uint32(uint1(x238))) + var x241 uint32 + var x242 uint32 + x241, x242 = bits.Add32(x201, x225, uint32(uint1(x240))) + var x243 uint32 + var x244 uint32 + x243, x244 = bits.Add32(((uint32(uint1(x202)) + uint32(uint1(x160))) + (uint32(uint1(x186)) + x162)), (uint32(uint1(x226)) + x204), uint32(uint1(x242))) + var x245 uint32 + var x246 uint32 + x246, x245 = bits.Mul32(x3, 0x4) + var x247 uint32 + var x248 uint32 + x248, x247 = bits.Mul32(x3, 0x2) + var x249 uint32 + var x250 uint32 + x250, x249 = bits.Mul32(x3, 0x2) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x3, 0xffffffff) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x3, 0x2) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x3, 0x3) + var x257 uint32 + var x258 uint32 + x257, x258 = bits.Add32(x256, x253, uint32(0x0)) + var x259 uint32 + var x260 uint32 + x259, x260 = bits.Add32(uint32(uint1(x254)), x251, uint32(uint1(x258))) + var x261 uint32 + var x262 uint32 + x261, x262 = bits.Add32(x252, x249, uint32(uint1(x260))) + var x263 uint32 + var x264 uint32 + x263, x264 = bits.Add32(uint32(uint1(x250)), x3, uint32(uint1(x262))) + var x265 uint32 + var x266 uint32 + x265, x266 = bits.Add32(uint32(0x0), x3, uint32(uint1(x264))) + var x267 uint32 + var x268 uint32 + x267, x268 = bits.Add32(uint32(0x0), x247, uint32(uint1(x266))) + var x269 uint32 + var x270 uint32 + x269, x270 = bits.Add32(uint32(uint1(x248)), x245, uint32(uint1(x268))) + var x271 uint32 + var x272 uint32 + x271, x272 = bits.Add32(x229, x255, uint32(0x0)) + var x273 uint32 + var x274 uint32 + x273, x274 = bits.Add32(x231, x257, uint32(uint1(x272))) + var x275 uint32 + var x276 uint32 + x275, x276 = bits.Add32(x233, x259, uint32(uint1(x274))) + var x277 uint32 + var x278 uint32 + x277, x278 = bits.Add32(x235, x261, uint32(uint1(x276))) + var x279 uint32 + var x280 uint32 + x279, x280 = bits.Add32(x237, x263, uint32(uint1(x278))) + var x281 uint32 + var x282 uint32 + x281, x282 = bits.Add32(x239, x265, uint32(uint1(x280))) + var x283 uint32 + var x284 uint32 + x283, x284 = bits.Add32(x241, x267, uint32(uint1(x282))) + var x285 uint32 + var x286 uint32 + x285, x286 = bits.Add32(x243, x269, uint32(uint1(x284))) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x271, 0xfffffffe) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x271, 0xffffffff) + var x291 uint32 + var x292 uint32 + x292, x291 = bits.Mul32(x271, 0xffffffff) + var x293 uint32 + var x294 uint32 + x294, x293 = bits.Mul32(x271, 0xffffffff) + var x295 uint32 + var x296 uint32 + x296, x295 = bits.Mul32(x271, 0xffffffff) + var x297 uint32 + var x298 uint32 + x298, x297 = bits.Mul32(x271, 0xffffffff) + var x299 uint32 + var x300 uint32 + x300, x299 = bits.Mul32(x271, 0xffffffff) + var x301 uint32 + var x302 uint32 + x301, x302 = bits.Add32(x300, x297, uint32(0x0)) + var x303 uint32 + var x304 uint32 + x303, x304 = bits.Add32(x296, x293, uint32(0x0)) + var x305 uint32 + var x306 uint32 + x305, x306 = bits.Add32(x294, x291, uint32(uint1(x304))) + var x307 uint32 + var x308 uint32 + x307, x308 = bits.Add32(x292, x289, uint32(uint1(x306))) + var x309 uint32 + var x310 uint32 + x309, x310 = bits.Add32(x290, x287, uint32(uint1(x308))) + var x312 uint32 + _, x312 = bits.Add32(x271, x299, uint32(0x0)) + var x313 uint32 + var x314 uint32 + x313, x314 = bits.Add32(x273, x301, uint32(uint1(x312))) + var x315 uint32 + var x316 uint32 + x315, x316 = bits.Add32(x275, (uint32(uint1(x302)) + x298), uint32(uint1(x314))) + var x317 uint32 + var x318 uint32 + x317, x318 = bits.Add32(x277, x295, uint32(uint1(x316))) + var x319 uint32 + var x320 uint32 + x319, x320 = bits.Add32(x279, x303, uint32(uint1(x318))) + var x321 uint32 + var x322 uint32 + x321, x322 = bits.Add32(x281, x305, uint32(uint1(x320))) + var x323 uint32 + var x324 uint32 + x323, x324 = bits.Add32(x283, x307, uint32(uint1(x322))) + var x325 uint32 + var x326 uint32 + x325, x326 = bits.Add32(x285, x309, uint32(uint1(x324))) + var x327 uint32 + var x328 uint32 + x327, x328 = bits.Add32(((uint32(uint1(x286)) + uint32(uint1(x244))) + (uint32(uint1(x270)) + x246)), (uint32(uint1(x310)) + x288), uint32(uint1(x326))) + var x329 uint32 + var x330 uint32 + x330, x329 = bits.Mul32(x4, 0x4) + var x331 uint32 + var x332 uint32 + x332, x331 = bits.Mul32(x4, 0x2) + var x333 uint32 + var x334 uint32 + x334, x333 = bits.Mul32(x4, 0x2) + var x335 uint32 + var x336 uint32 + x336, x335 = bits.Mul32(x4, 0xffffffff) + var x337 uint32 + var x338 uint32 + x338, x337 = bits.Mul32(x4, 0x2) + var x339 uint32 + var x340 uint32 + x340, x339 = bits.Mul32(x4, 0x3) + var x341 uint32 + var x342 uint32 + x341, x342 = bits.Add32(x340, x337, uint32(0x0)) + var x343 uint32 + var x344 uint32 + x343, x344 = bits.Add32(uint32(uint1(x338)), x335, uint32(uint1(x342))) + var x345 uint32 + var x346 uint32 + x345, x346 = bits.Add32(x336, x333, uint32(uint1(x344))) + var x347 uint32 + var x348 uint32 + x347, x348 = bits.Add32(uint32(uint1(x334)), x4, uint32(uint1(x346))) + var x349 uint32 + var x350 uint32 + x349, x350 = bits.Add32(uint32(0x0), x4, uint32(uint1(x348))) + var x351 uint32 + var x352 uint32 + x351, x352 = bits.Add32(uint32(0x0), x331, uint32(uint1(x350))) + var x353 uint32 + var x354 uint32 + x353, x354 = bits.Add32(uint32(uint1(x332)), x329, uint32(uint1(x352))) + var x355 uint32 + var x356 uint32 + x355, x356 = bits.Add32(x313, x339, uint32(0x0)) + var x357 uint32 + var x358 uint32 + x357, x358 = bits.Add32(x315, x341, uint32(uint1(x356))) + var x359 uint32 + var x360 uint32 + x359, x360 = bits.Add32(x317, x343, uint32(uint1(x358))) + var x361 uint32 + var x362 uint32 + x361, x362 = bits.Add32(x319, x345, uint32(uint1(x360))) + var x363 uint32 + var x364 uint32 + x363, x364 = bits.Add32(x321, x347, uint32(uint1(x362))) + var x365 uint32 + var x366 uint32 + x365, x366 = bits.Add32(x323, x349, uint32(uint1(x364))) + var x367 uint32 + var x368 uint32 + x367, x368 = bits.Add32(x325, x351, uint32(uint1(x366))) + var x369 uint32 + var x370 uint32 + x369, x370 = bits.Add32(x327, x353, uint32(uint1(x368))) + var x371 uint32 + var x372 uint32 + x372, x371 = bits.Mul32(x355, 0xfffffffe) + var x373 uint32 + var x374 uint32 + x374, x373 = bits.Mul32(x355, 0xffffffff) + var x375 uint32 + var x376 uint32 + x376, x375 = bits.Mul32(x355, 0xffffffff) + var x377 uint32 + var x378 uint32 + x378, x377 = bits.Mul32(x355, 0xffffffff) + var x379 uint32 + var x380 uint32 + x380, x379 = bits.Mul32(x355, 0xffffffff) + var x381 uint32 + var x382 uint32 + x382, x381 = bits.Mul32(x355, 0xffffffff) + var x383 uint32 + var x384 uint32 + x384, x383 = bits.Mul32(x355, 0xffffffff) + var x385 uint32 + var x386 uint32 + x385, x386 = bits.Add32(x384, x381, uint32(0x0)) + var x387 uint32 + var x388 uint32 + x387, x388 = bits.Add32(x380, x377, uint32(0x0)) + var x389 uint32 + var x390 uint32 + x389, x390 = bits.Add32(x378, x375, uint32(uint1(x388))) + var x391 uint32 + var x392 uint32 + x391, x392 = bits.Add32(x376, x373, uint32(uint1(x390))) + var x393 uint32 + var x394 uint32 + x393, x394 = bits.Add32(x374, x371, uint32(uint1(x392))) + var x396 uint32 + _, x396 = bits.Add32(x355, x383, uint32(0x0)) + var x397 uint32 + var x398 uint32 + x397, x398 = bits.Add32(x357, x385, uint32(uint1(x396))) + var x399 uint32 + var x400 uint32 + x399, x400 = bits.Add32(x359, (uint32(uint1(x386)) + x382), uint32(uint1(x398))) + var x401 uint32 + var x402 uint32 + x401, x402 = bits.Add32(x361, x379, uint32(uint1(x400))) + var x403 uint32 + var x404 uint32 + x403, x404 = bits.Add32(x363, x387, uint32(uint1(x402))) + var x405 uint32 + var x406 uint32 + x405, x406 = bits.Add32(x365, x389, uint32(uint1(x404))) + var x407 uint32 + var x408 uint32 + x407, x408 = bits.Add32(x367, x391, uint32(uint1(x406))) + var x409 uint32 + var x410 uint32 + x409, x410 = bits.Add32(x369, x393, uint32(uint1(x408))) + var x411 uint32 + var x412 uint32 + x411, x412 = bits.Add32(((uint32(uint1(x370)) + uint32(uint1(x328))) + (uint32(uint1(x354)) + x330)), (uint32(uint1(x394)) + x372), uint32(uint1(x410))) + var x413 uint32 + var x414 uint32 + x414, x413 = bits.Mul32(x5, 0x4) + var x415 uint32 + var x416 uint32 + x416, x415 = bits.Mul32(x5, 0x2) + var x417 uint32 + var x418 uint32 + x418, x417 = bits.Mul32(x5, 0x2) + var x419 uint32 + var x420 uint32 + x420, x419 = bits.Mul32(x5, 0xffffffff) + var x421 uint32 + var x422 uint32 + x422, x421 = bits.Mul32(x5, 0x2) + var x423 uint32 + var x424 uint32 + x424, x423 = bits.Mul32(x5, 0x3) + var x425 uint32 + var x426 uint32 + x425, x426 = bits.Add32(x424, x421, uint32(0x0)) + var x427 uint32 + var x428 uint32 + x427, x428 = bits.Add32(uint32(uint1(x422)), x419, uint32(uint1(x426))) + var x429 uint32 + var x430 uint32 + x429, x430 = bits.Add32(x420, x417, uint32(uint1(x428))) + var x431 uint32 + var x432 uint32 + x431, x432 = bits.Add32(uint32(uint1(x418)), x5, uint32(uint1(x430))) + var x433 uint32 + var x434 uint32 + x433, x434 = bits.Add32(uint32(0x0), x5, uint32(uint1(x432))) + var x435 uint32 + var x436 uint32 + x435, x436 = bits.Add32(uint32(0x0), x415, uint32(uint1(x434))) + var x437 uint32 + var x438 uint32 + x437, x438 = bits.Add32(uint32(uint1(x416)), x413, uint32(uint1(x436))) + var x439 uint32 + var x440 uint32 + x439, x440 = bits.Add32(x397, x423, uint32(0x0)) + var x441 uint32 + var x442 uint32 + x441, x442 = bits.Add32(x399, x425, uint32(uint1(x440))) + var x443 uint32 + var x444 uint32 + x443, x444 = bits.Add32(x401, x427, uint32(uint1(x442))) + var x445 uint32 + var x446 uint32 + x445, x446 = bits.Add32(x403, x429, uint32(uint1(x444))) + var x447 uint32 + var x448 uint32 + x447, x448 = bits.Add32(x405, x431, uint32(uint1(x446))) + var x449 uint32 + var x450 uint32 + x449, x450 = bits.Add32(x407, x433, uint32(uint1(x448))) + var x451 uint32 + var x452 uint32 + x451, x452 = bits.Add32(x409, x435, uint32(uint1(x450))) + var x453 uint32 + var x454 uint32 + x453, x454 = bits.Add32(x411, x437, uint32(uint1(x452))) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x439, 0xfffffffe) + var x457 uint32 + var x458 uint32 + x458, x457 = bits.Mul32(x439, 0xffffffff) + var x459 uint32 + var x460 uint32 + x460, x459 = bits.Mul32(x439, 0xffffffff) + var x461 uint32 + var x462 uint32 + x462, x461 = bits.Mul32(x439, 0xffffffff) + var x463 uint32 + var x464 uint32 + x464, x463 = bits.Mul32(x439, 0xffffffff) + var x465 uint32 + var x466 uint32 + x466, x465 = bits.Mul32(x439, 0xffffffff) + var x467 uint32 + var x468 uint32 + x468, x467 = bits.Mul32(x439, 0xffffffff) + var x469 uint32 + var x470 uint32 + x469, x470 = bits.Add32(x468, x465, uint32(0x0)) + var x471 uint32 + var x472 uint32 + x471, x472 = bits.Add32(x464, x461, uint32(0x0)) + var x473 uint32 + var x474 uint32 + x473, x474 = bits.Add32(x462, x459, uint32(uint1(x472))) + var x475 uint32 + var x476 uint32 + x475, x476 = bits.Add32(x460, x457, uint32(uint1(x474))) + var x477 uint32 + var x478 uint32 + x477, x478 = bits.Add32(x458, x455, uint32(uint1(x476))) + var x480 uint32 + _, x480 = bits.Add32(x439, x467, uint32(0x0)) + var x481 uint32 + var x482 uint32 + x481, x482 = bits.Add32(x441, x469, uint32(uint1(x480))) + var x483 uint32 + var x484 uint32 + x483, x484 = bits.Add32(x443, (uint32(uint1(x470)) + x466), uint32(uint1(x482))) + var x485 uint32 + var x486 uint32 + x485, x486 = bits.Add32(x445, x463, uint32(uint1(x484))) + var x487 uint32 + var x488 uint32 + x487, x488 = bits.Add32(x447, x471, uint32(uint1(x486))) + var x489 uint32 + var x490 uint32 + x489, x490 = bits.Add32(x449, x473, uint32(uint1(x488))) + var x491 uint32 + var x492 uint32 + x491, x492 = bits.Add32(x451, x475, uint32(uint1(x490))) + var x493 uint32 + var x494 uint32 + x493, x494 = bits.Add32(x453, x477, uint32(uint1(x492))) + var x495 uint32 + var x496 uint32 + x495, x496 = bits.Add32(((uint32(uint1(x454)) + uint32(uint1(x412))) + (uint32(uint1(x438)) + x414)), (uint32(uint1(x478)) + x456), uint32(uint1(x494))) + var x497 uint32 + var x498 uint32 + x498, x497 = bits.Mul32(x6, 0x4) + var x499 uint32 + var x500 uint32 + x500, x499 = bits.Mul32(x6, 0x2) + var x501 uint32 + var x502 uint32 + x502, x501 = bits.Mul32(x6, 0x2) + var x503 uint32 + var x504 uint32 + x504, x503 = bits.Mul32(x6, 0xffffffff) + var x505 uint32 + var x506 uint32 + x506, x505 = bits.Mul32(x6, 0x2) + var x507 uint32 + var x508 uint32 + x508, x507 = bits.Mul32(x6, 0x3) + var x509 uint32 + var x510 uint32 + x509, x510 = bits.Add32(x508, x505, uint32(0x0)) + var x511 uint32 + var x512 uint32 + x511, x512 = bits.Add32(uint32(uint1(x506)), x503, uint32(uint1(x510))) + var x513 uint32 + var x514 uint32 + x513, x514 = bits.Add32(x504, x501, uint32(uint1(x512))) + var x515 uint32 + var x516 uint32 + x515, x516 = bits.Add32(uint32(uint1(x502)), x6, uint32(uint1(x514))) + var x517 uint32 + var x518 uint32 + x517, x518 = bits.Add32(uint32(0x0), x6, uint32(uint1(x516))) + var x519 uint32 + var x520 uint32 + x519, x520 = bits.Add32(uint32(0x0), x499, uint32(uint1(x518))) + var x521 uint32 + var x522 uint32 + x521, x522 = bits.Add32(uint32(uint1(x500)), x497, uint32(uint1(x520))) + var x523 uint32 + var x524 uint32 + x523, x524 = bits.Add32(x481, x507, uint32(0x0)) + var x525 uint32 + var x526 uint32 + x525, x526 = bits.Add32(x483, x509, uint32(uint1(x524))) + var x527 uint32 + var x528 uint32 + x527, x528 = bits.Add32(x485, x511, uint32(uint1(x526))) + var x529 uint32 + var x530 uint32 + x529, x530 = bits.Add32(x487, x513, uint32(uint1(x528))) + var x531 uint32 + var x532 uint32 + x531, x532 = bits.Add32(x489, x515, uint32(uint1(x530))) + var x533 uint32 + var x534 uint32 + x533, x534 = bits.Add32(x491, x517, uint32(uint1(x532))) + var x535 uint32 + var x536 uint32 + x535, x536 = bits.Add32(x493, x519, uint32(uint1(x534))) + var x537 uint32 + var x538 uint32 + x537, x538 = bits.Add32(x495, x521, uint32(uint1(x536))) + var x539 uint32 + var x540 uint32 + x540, x539 = bits.Mul32(x523, 0xfffffffe) + var x541 uint32 + var x542 uint32 + x542, x541 = bits.Mul32(x523, 0xffffffff) + var x543 uint32 + var x544 uint32 + x544, x543 = bits.Mul32(x523, 0xffffffff) + var x545 uint32 + var x546 uint32 + x546, x545 = bits.Mul32(x523, 0xffffffff) + var x547 uint32 + var x548 uint32 + x548, x547 = bits.Mul32(x523, 0xffffffff) + var x549 uint32 + var x550 uint32 + x550, x549 = bits.Mul32(x523, 0xffffffff) + var x551 uint32 + var x552 uint32 + x552, x551 = bits.Mul32(x523, 0xffffffff) + var x553 uint32 + var x554 uint32 + x553, x554 = bits.Add32(x552, x549, uint32(0x0)) + var x555 uint32 + var x556 uint32 + x555, x556 = bits.Add32(x548, x545, uint32(0x0)) + var x557 uint32 + var x558 uint32 + x557, x558 = bits.Add32(x546, x543, uint32(uint1(x556))) + var x559 uint32 + var x560 uint32 + x559, x560 = bits.Add32(x544, x541, uint32(uint1(x558))) + var x561 uint32 + var x562 uint32 + x561, x562 = bits.Add32(x542, x539, uint32(uint1(x560))) + var x564 uint32 + _, x564 = bits.Add32(x523, x551, uint32(0x0)) + var x565 uint32 + var x566 uint32 + x565, x566 = bits.Add32(x525, x553, uint32(uint1(x564))) + var x567 uint32 + var x568 uint32 + x567, x568 = bits.Add32(x527, (uint32(uint1(x554)) + x550), uint32(uint1(x566))) + var x569 uint32 + var x570 uint32 + x569, x570 = bits.Add32(x529, x547, uint32(uint1(x568))) + var x571 uint32 + var x572 uint32 + x571, x572 = bits.Add32(x531, x555, uint32(uint1(x570))) + var x573 uint32 + var x574 uint32 + x573, x574 = bits.Add32(x533, x557, uint32(uint1(x572))) + var x575 uint32 + var x576 uint32 + x575, x576 = bits.Add32(x535, x559, uint32(uint1(x574))) + var x577 uint32 + var x578 uint32 + x577, x578 = bits.Add32(x537, x561, uint32(uint1(x576))) + var x579 uint32 + var x580 uint32 + x579, x580 = bits.Add32(((uint32(uint1(x538)) + uint32(uint1(x496))) + (uint32(uint1(x522)) + x498)), (uint32(uint1(x562)) + x540), uint32(uint1(x578))) + var x581 uint32 + var x582 uint32 + x582, x581 = bits.Mul32(x7, 0x4) + var x583 uint32 + var x584 uint32 + x584, x583 = bits.Mul32(x7, 0x2) + var x585 uint32 + var x586 uint32 + x586, x585 = bits.Mul32(x7, 0x2) + var x587 uint32 + var x588 uint32 + x588, x587 = bits.Mul32(x7, 0xffffffff) + var x589 uint32 + var x590 uint32 + x590, x589 = bits.Mul32(x7, 0x2) + var x591 uint32 + var x592 uint32 + x592, x591 = bits.Mul32(x7, 0x3) + var x593 uint32 + var x594 uint32 + x593, x594 = bits.Add32(x592, x589, uint32(0x0)) + var x595 uint32 + var x596 uint32 + x595, x596 = bits.Add32(uint32(uint1(x590)), x587, uint32(uint1(x594))) + var x597 uint32 + var x598 uint32 + x597, x598 = bits.Add32(x588, x585, uint32(uint1(x596))) + var x599 uint32 + var x600 uint32 + x599, x600 = bits.Add32(uint32(uint1(x586)), x7, uint32(uint1(x598))) + var x601 uint32 + var x602 uint32 + x601, x602 = bits.Add32(uint32(0x0), x7, uint32(uint1(x600))) + var x603 uint32 + var x604 uint32 + x603, x604 = bits.Add32(uint32(0x0), x583, uint32(uint1(x602))) + var x605 uint32 + var x606 uint32 + x605, x606 = bits.Add32(uint32(uint1(x584)), x581, uint32(uint1(x604))) + var x607 uint32 + var x608 uint32 + x607, x608 = bits.Add32(x565, x591, uint32(0x0)) + var x609 uint32 + var x610 uint32 + x609, x610 = bits.Add32(x567, x593, uint32(uint1(x608))) + var x611 uint32 + var x612 uint32 + x611, x612 = bits.Add32(x569, x595, uint32(uint1(x610))) + var x613 uint32 + var x614 uint32 + x613, x614 = bits.Add32(x571, x597, uint32(uint1(x612))) + var x615 uint32 + var x616 uint32 + x615, x616 = bits.Add32(x573, x599, uint32(uint1(x614))) + var x617 uint32 + var x618 uint32 + x617, x618 = bits.Add32(x575, x601, uint32(uint1(x616))) + var x619 uint32 + var x620 uint32 + x619, x620 = bits.Add32(x577, x603, uint32(uint1(x618))) + var x621 uint32 + var x622 uint32 + x621, x622 = bits.Add32(x579, x605, uint32(uint1(x620))) + var x623 uint32 + var x624 uint32 + x624, x623 = bits.Mul32(x607, 0xfffffffe) + var x625 uint32 + var x626 uint32 + x626, x625 = bits.Mul32(x607, 0xffffffff) + var x627 uint32 + var x628 uint32 + x628, x627 = bits.Mul32(x607, 0xffffffff) + var x629 uint32 + var x630 uint32 + x630, x629 = bits.Mul32(x607, 0xffffffff) + var x631 uint32 + var x632 uint32 + x632, x631 = bits.Mul32(x607, 0xffffffff) + var x633 uint32 + var x634 uint32 + x634, x633 = bits.Mul32(x607, 0xffffffff) + var x635 uint32 + var x636 uint32 + x636, x635 = bits.Mul32(x607, 0xffffffff) + var x637 uint32 + var x638 uint32 + x637, x638 = bits.Add32(x636, x633, uint32(0x0)) + var x639 uint32 + var x640 uint32 + x639, x640 = bits.Add32(x632, x629, uint32(0x0)) + var x641 uint32 + var x642 uint32 + x641, x642 = bits.Add32(x630, x627, uint32(uint1(x640))) + var x643 uint32 + var x644 uint32 + x643, x644 = bits.Add32(x628, x625, uint32(uint1(x642))) + var x645 uint32 + var x646 uint32 + x645, x646 = bits.Add32(x626, x623, uint32(uint1(x644))) + var x648 uint32 + _, x648 = bits.Add32(x607, x635, uint32(0x0)) + var x649 uint32 + var x650 uint32 + x649, x650 = bits.Add32(x609, x637, uint32(uint1(x648))) + var x651 uint32 + var x652 uint32 + x651, x652 = bits.Add32(x611, (uint32(uint1(x638)) + x634), uint32(uint1(x650))) + var x653 uint32 + var x654 uint32 + x653, x654 = bits.Add32(x613, x631, uint32(uint1(x652))) + var x655 uint32 + var x656 uint32 + x655, x656 = bits.Add32(x615, x639, uint32(uint1(x654))) + var x657 uint32 + var x658 uint32 + x657, x658 = bits.Add32(x617, x641, uint32(uint1(x656))) + var x659 uint32 + var x660 uint32 + x659, x660 = bits.Add32(x619, x643, uint32(uint1(x658))) + var x661 uint32 + var x662 uint32 + x661, x662 = bits.Add32(x621, x645, uint32(uint1(x660))) + var x663 uint32 + var x664 uint32 + x663, x664 = bits.Add32(((uint32(uint1(x622)) + uint32(uint1(x580))) + (uint32(uint1(x606)) + x582)), (uint32(uint1(x646)) + x624), uint32(uint1(x662))) + var x665 uint32 + var x666 uint32 + x665, x666 = bits.Sub32(x649, 0xffffffff, uint32(0x0)) + var x667 uint32 + var x668 uint32 + x667, x668 = bits.Sub32(x651, 0xffffffff, uint32(uint1(x666))) + var x669 uint32 + var x670 uint32 + x669, x670 = bits.Sub32(x653, uint32(0x0), uint32(uint1(x668))) + var x671 uint32 + var x672 uint32 + x671, x672 = bits.Sub32(x655, 0xffffffff, uint32(uint1(x670))) + var x673 uint32 + var x674 uint32 + x673, x674 = bits.Sub32(x657, 0xffffffff, uint32(uint1(x672))) + var x675 uint32 + var x676 uint32 + x675, x676 = bits.Sub32(x659, 0xffffffff, uint32(uint1(x674))) + var x677 uint32 + var x678 uint32 + x677, x678 = bits.Sub32(x661, 0xffffffff, uint32(uint1(x676))) + var x679 uint32 + var x680 uint32 + x679, x680 = bits.Sub32(x663, 0xfffffffe, uint32(uint1(x678))) + var x682 uint32 + _, x682 = bits.Sub32(uint32(uint1(x664)), uint32(0x0), uint32(uint1(x680))) + var x683 uint32 + cmovznzU32(&x683, uint1(x682), x665, x649) + var x684 uint32 + cmovznzU32(&x684, uint1(x682), x667, x651) + var x685 uint32 + cmovznzU32(&x685, uint1(x682), x669, x653) + var x686 uint32 + cmovznzU32(&x686, uint1(x682), x671, x655) + var x687 uint32 + cmovznzU32(&x687, uint1(x682), x673, x657) + var x688 uint32 + cmovznzU32(&x688, uint1(x682), x675, x659) + var x689 uint32 + cmovznzU32(&x689, uint1(x682), x677, x661) + var x690 uint32 + cmovznzU32(&x690, uint1(x682), x679, x663) + out1[0] = x683 + out1[1] = x684 + out1[2] = x685 + out1[3] = x686 + out1[4] = x687 + out1[5] = x688 + out1[6] = x689 + out1[7] = x690 +} + +// 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] = uint32(0x1) + out1[1] = uint32(0x0) + out1[2] = 0xffffffff + out1[3] = uint32(0x0) + out1[4] = uint32(0x0) + out1[5] = uint32(0x0) + out1[6] = uint32(0x0) + out1[7] = uint32(0x1) +} + +// 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] = 0xffffffff + out1[1] = 0xffffffff + out1[2] = uint32(0x0) + out1[3] = 0xffffffff + out1[4] = 0xffffffff + out1[5] = 0xffffffff + out1[6] = 0xffffffff + out1[7] = 0xfffffffe + 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, 0xffffffff, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Sub32(x53, 0xffffffff, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Sub32(x55, uint32(0x0), uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Sub32(x57, 0xffffffff, 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, 0xffffffff, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Sub32(x65, 0xfffffffe, 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, uint32(0x0)) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x95, x109, uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x97, uint32(0x0), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x99, x109, 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, x109, uint32(uint1(x121))) + var x124 uint32 + x124, _ = bits.Add32(x107, (x109 & 0xfffffffe), 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, 0xffffffff, uint32(0x0)) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Sub32(x172, 0xffffffff, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Sub32(x174, uint32(0x0), uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Sub32(x176, 0xffffffff, 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, 0xffffffff, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Sub32(x184, 0xfffffffe, 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] = 0x8ffffffe + out1[1] = 0x50000002 + out1[2] = 0x9ffffffe + out1[3] = 0xe8000000 + out1[4] = 0x8ffffffe + out1[5] = 0xd0000001 + out1[6] = 0x1ffffffd + out1[7] = 0x28000001 +} diff --git a/fiat-go/32/sm2scalar/sm2scalar b/fiat-go/32/sm2scalar/sm2scalar new file mode 100644 index 00000000000..94e8aef231c --- /dev/null +++ b/fiat-go/32/sm2scalar/sm2scalar @@ -0,0 +1,5459 @@ +// 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 sm2scalar '' 32 '2^256 - 2^224 - 188730267045675049073202170516080344797' 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): sm2scalar +// +// 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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") +// +// +// +// 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 sm2scalar + +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, 0x72350975) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0xfffffffe) + 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, 0xffffffff) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0x7203df6b) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x40, 0x21c6052b) + var x54 uint32 + var x55 uint32 + x55, x54 = bits.Mul32(x40, 0x53bbf409) + var x56 uint32 + var x57 uint32 + x57, x56 = bits.Mul32(x40, 0x39d54123) + 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, 0x72350975) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x140, 0xfffffffe) + 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, 0xffffffff) + var x150 uint32 + var x151 uint32 + x151, x150 = bits.Mul32(x140, 0x7203df6b) + var x152 uint32 + var x153 uint32 + x153, x152 = bits.Mul32(x140, 0x21c6052b) + var x154 uint32 + var x155 uint32 + x155, x154 = bits.Mul32(x140, 0x53bbf409) + var x156 uint32 + var x157 uint32 + x157, x156 = bits.Mul32(x140, 0x39d54123) + 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, 0x72350975) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x241, 0xfffffffe) + 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, 0xffffffff) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x241, 0x7203df6b) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x241, 0x21c6052b) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x241, 0x53bbf409) + var x257 uint32 + var x258 uint32 + x258, x257 = bits.Mul32(x241, 0x39d54123) + 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, 0x72350975) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x342, 0xfffffffe) + 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, 0xffffffff) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x342, 0x7203df6b) + var x354 uint32 + var x355 uint32 + x355, x354 = bits.Mul32(x342, 0x21c6052b) + var x356 uint32 + var x357 uint32 + x357, x356 = bits.Mul32(x342, 0x53bbf409) + var x358 uint32 + var x359 uint32 + x359, x358 = bits.Mul32(x342, 0x39d54123) + 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, 0x72350975) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x443, 0xfffffffe) + 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, 0xffffffff) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x443, 0x7203df6b) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x443, 0x21c6052b) + var x457 uint32 + var x458 uint32 + x458, x457 = bits.Mul32(x443, 0x53bbf409) + var x459 uint32 + var x460 uint32 + x460, x459 = bits.Mul32(x443, 0x39d54123) + 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, 0x72350975) + var x546 uint32 + var x547 uint32 + x547, x546 = bits.Mul32(x544, 0xfffffffe) + 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, 0xffffffff) + var x554 uint32 + var x555 uint32 + x555, x554 = bits.Mul32(x544, 0x7203df6b) + var x556 uint32 + var x557 uint32 + x557, x556 = bits.Mul32(x544, 0x21c6052b) + var x558 uint32 + var x559 uint32 + x559, x558 = bits.Mul32(x544, 0x53bbf409) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x544, 0x39d54123) + 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, 0x72350975) + var x647 uint32 + var x648 uint32 + x648, x647 = bits.Mul32(x645, 0xfffffffe) + 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, 0xffffffff) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x645, 0x7203df6b) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x645, 0x21c6052b) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x645, 0x53bbf409) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x645, 0x39d54123) + 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, 0x72350975) + var x748 uint32 + var x749 uint32 + x749, x748 = bits.Mul32(x746, 0xfffffffe) + 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, 0xffffffff) + var x756 uint32 + var x757 uint32 + x757, x756 = bits.Mul32(x746, 0x7203df6b) + var x758 uint32 + var x759 uint32 + x759, x758 = bits.Mul32(x746, 0x21c6052b) + var x760 uint32 + var x761 uint32 + x761, x760 = bits.Mul32(x746, 0x53bbf409) + var x762 uint32 + var x763 uint32 + x763, x762 = bits.Mul32(x746, 0x39d54123) + 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, 0x39d54123, uint32(0x0)) + var x800 uint32 + var x801 uint32 + x800, x801 = bits.Sub32(x783, 0x53bbf409, uint32(uint1(x799))) + var x802 uint32 + var x803 uint32 + x802, x803 = bits.Sub32(x785, 0x21c6052b, uint32(uint1(x801))) + var x804 uint32 + var x805 uint32 + x804, x805 = bits.Sub32(x787, 0x7203df6b, uint32(uint1(x803))) + var x806 uint32 + var x807 uint32 + x806, x807 = bits.Sub32(x789, 0xffffffff, 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, 0xfffffffe, 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, 0x72350975) + var x42 uint32 + var x43 uint32 + x43, x42 = bits.Mul32(x40, 0xfffffffe) + 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, 0xffffffff) + var x50 uint32 + var x51 uint32 + x51, x50 = bits.Mul32(x40, 0x7203df6b) + var x52 uint32 + var x53 uint32 + x53, x52 = bits.Mul32(x40, 0x21c6052b) + var x54 uint32 + var x55 uint32 + x55, x54 = bits.Mul32(x40, 0x53bbf409) + var x56 uint32 + var x57 uint32 + x57, x56 = bits.Mul32(x40, 0x39d54123) + 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, 0x72350975) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x140, 0xfffffffe) + 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, 0xffffffff) + var x150 uint32 + var x151 uint32 + x151, x150 = bits.Mul32(x140, 0x7203df6b) + var x152 uint32 + var x153 uint32 + x153, x152 = bits.Mul32(x140, 0x21c6052b) + var x154 uint32 + var x155 uint32 + x155, x154 = bits.Mul32(x140, 0x53bbf409) + var x156 uint32 + var x157 uint32 + x157, x156 = bits.Mul32(x140, 0x39d54123) + 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, 0x72350975) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x241, 0xfffffffe) + 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, 0xffffffff) + var x251 uint32 + var x252 uint32 + x252, x251 = bits.Mul32(x241, 0x7203df6b) + var x253 uint32 + var x254 uint32 + x254, x253 = bits.Mul32(x241, 0x21c6052b) + var x255 uint32 + var x256 uint32 + x256, x255 = bits.Mul32(x241, 0x53bbf409) + var x257 uint32 + var x258 uint32 + x258, x257 = bits.Mul32(x241, 0x39d54123) + 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, 0x72350975) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x342, 0xfffffffe) + 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, 0xffffffff) + var x352 uint32 + var x353 uint32 + x353, x352 = bits.Mul32(x342, 0x7203df6b) + var x354 uint32 + var x355 uint32 + x355, x354 = bits.Mul32(x342, 0x21c6052b) + var x356 uint32 + var x357 uint32 + x357, x356 = bits.Mul32(x342, 0x53bbf409) + var x358 uint32 + var x359 uint32 + x359, x358 = bits.Mul32(x342, 0x39d54123) + 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, 0x72350975) + var x445 uint32 + var x446 uint32 + x446, x445 = bits.Mul32(x443, 0xfffffffe) + 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, 0xffffffff) + var x453 uint32 + var x454 uint32 + x454, x453 = bits.Mul32(x443, 0x7203df6b) + var x455 uint32 + var x456 uint32 + x456, x455 = bits.Mul32(x443, 0x21c6052b) + var x457 uint32 + var x458 uint32 + x458, x457 = bits.Mul32(x443, 0x53bbf409) + var x459 uint32 + var x460 uint32 + x460, x459 = bits.Mul32(x443, 0x39d54123) + 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, 0x72350975) + var x546 uint32 + var x547 uint32 + x547, x546 = bits.Mul32(x544, 0xfffffffe) + 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, 0xffffffff) + var x554 uint32 + var x555 uint32 + x555, x554 = bits.Mul32(x544, 0x7203df6b) + var x556 uint32 + var x557 uint32 + x557, x556 = bits.Mul32(x544, 0x21c6052b) + var x558 uint32 + var x559 uint32 + x559, x558 = bits.Mul32(x544, 0x53bbf409) + var x560 uint32 + var x561 uint32 + x561, x560 = bits.Mul32(x544, 0x39d54123) + 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, 0x72350975) + var x647 uint32 + var x648 uint32 + x648, x647 = bits.Mul32(x645, 0xfffffffe) + 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, 0xffffffff) + var x655 uint32 + var x656 uint32 + x656, x655 = bits.Mul32(x645, 0x7203df6b) + var x657 uint32 + var x658 uint32 + x658, x657 = bits.Mul32(x645, 0x21c6052b) + var x659 uint32 + var x660 uint32 + x660, x659 = bits.Mul32(x645, 0x53bbf409) + var x661 uint32 + var x662 uint32 + x662, x661 = bits.Mul32(x645, 0x39d54123) + 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, 0x72350975) + var x748 uint32 + var x749 uint32 + x749, x748 = bits.Mul32(x746, 0xfffffffe) + 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, 0xffffffff) + var x756 uint32 + var x757 uint32 + x757, x756 = bits.Mul32(x746, 0x7203df6b) + var x758 uint32 + var x759 uint32 + x759, x758 = bits.Mul32(x746, 0x21c6052b) + var x760 uint32 + var x761 uint32 + x761, x760 = bits.Mul32(x746, 0x53bbf409) + var x762 uint32 + var x763 uint32 + x763, x762 = bits.Mul32(x746, 0x39d54123) + 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, 0x39d54123, uint32(0x0)) + var x800 uint32 + var x801 uint32 + x800, x801 = bits.Sub32(x783, 0x53bbf409, uint32(uint1(x799))) + var x802 uint32 + var x803 uint32 + x802, x803 = bits.Sub32(x785, 0x21c6052b, uint32(uint1(x801))) + var x804 uint32 + var x805 uint32 + x804, x805 = bits.Sub32(x787, 0x7203df6b, uint32(uint1(x803))) + var x806 uint32 + var x807 uint32 + x806, x807 = bits.Sub32(x789, 0xffffffff, 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, 0xfffffffe, 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, 0x39d54123, uint32(0x0)) + var x19 uint32 + var x20 uint32 + x19, x20 = bits.Sub32(x3, 0x53bbf409, uint32(uint1(x18))) + var x21 uint32 + var x22 uint32 + x21, x22 = bits.Sub32(x5, 0x21c6052b, uint32(uint1(x20))) + var x23 uint32 + var x24 uint32 + x23, x24 = bits.Sub32(x7, 0x7203df6b, 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, 0xffffffff, uint32(uint1(x28))) + var x31 uint32 + var x32 uint32 + x31, x32 = bits.Sub32(x15, 0xfffffffe, 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 & 0x39d54123), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0x53bbf409), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0x21c6052b), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0x7203df6b), 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, x17, uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, (x17 & 0xfffffffe), 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 & 0x39d54123), uint32(0x0)) + var x20 uint32 + var x21 uint32 + x20, x21 = bits.Add32(x3, (x17 & 0x53bbf409), uint32(uint1(x19))) + var x22 uint32 + var x23 uint32 + x22, x23 = bits.Add32(x5, (x17 & 0x21c6052b), uint32(uint1(x21))) + var x24 uint32 + var x25 uint32 + x24, x25 = bits.Add32(x7, (x17 & 0x7203df6b), 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, x17, uint32(uint1(x29))) + var x32 uint32 + x32, _ = bits.Add32(x15, (x17 & 0xfffffffe), 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, 0x72350975) + var x4 uint32 + var x5 uint32 + x5, x4 = bits.Mul32(x2, 0xfffffffe) + 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, 0x7203df6b) + var x14 uint32 + var x15 uint32 + x15, x14 = bits.Mul32(x2, 0x21c6052b) + var x16 uint32 + var x17 uint32 + x17, x16 = bits.Mul32(x2, 0x53bbf409) + var x18 uint32 + var x19 uint32 + x19, x18 = bits.Mul32(x2, 0x39d54123) + 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(x36, arg1[1], uint32(0x0)) + 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(x44, uint32(0x0), uint32(uint1(x57))) + var x60 uint32 + var x61 uint32 + x60, x61 = bits.Add32(x46, uint32(0x0), uint32(uint1(x59))) + var x62 uint32 + var x63 uint32 + x62, x63 = bits.Add32(x48, uint32(0x0), uint32(uint1(x61))) + var x64 uint32 + var x65 uint32 + x64, x65 = bits.Add32((uint32(uint1(x49)) + (uint32(uint1(x33)) + x5)), uint32(0x0), uint32(uint1(x63))) + var x66 uint32 + _, x66 = bits.Mul32(x50, 0x72350975) + var x68 uint32 + var x69 uint32 + x69, x68 = bits.Mul32(x66, 0xfffffffe) + var x70 uint32 + var x71 uint32 + x71, x70 = bits.Mul32(x66, 0xffffffff) + var x72 uint32 + var x73 uint32 + x73, x72 = bits.Mul32(x66, 0xffffffff) + var x74 uint32 + var x75 uint32 + x75, x74 = bits.Mul32(x66, 0xffffffff) + var x76 uint32 + var x77 uint32 + x77, x76 = bits.Mul32(x66, 0x7203df6b) + var x78 uint32 + var x79 uint32 + x79, x78 = bits.Mul32(x66, 0x21c6052b) + var x80 uint32 + var x81 uint32 + x81, x80 = bits.Mul32(x66, 0x53bbf409) + var x82 uint32 + var x83 uint32 + x83, x82 = bits.Mul32(x66, 0x39d54123) + var x84 uint32 + var x85 uint32 + x84, x85 = bits.Add32(x83, x80, uint32(0x0)) + var x86 uint32 + var x87 uint32 + x86, x87 = bits.Add32(x81, x78, uint32(uint1(x85))) + var x88 uint32 + var x89 uint32 + x88, x89 = bits.Add32(x79, x76, uint32(uint1(x87))) + var x90 uint32 + var x91 uint32 + x90, x91 = bits.Add32(x77, x74, uint32(uint1(x89))) + var x92 uint32 + var x93 uint32 + x92, x93 = bits.Add32(x75, x72, uint32(uint1(x91))) + var x94 uint32 + var x95 uint32 + x94, x95 = bits.Add32(x73, x70, uint32(uint1(x93))) + var x96 uint32 + var x97 uint32 + x96, x97 = bits.Add32(x71, x68, uint32(uint1(x95))) + var x99 uint32 + _, x99 = bits.Add32(x50, x82, uint32(0x0)) + var x100 uint32 + var x101 uint32 + x100, x101 = bits.Add32(x52, x84, uint32(uint1(x99))) + 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(uint32(uint1(x65)), (uint32(uint1(x97)) + x69), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x100, arg1[2], uint32(0x0)) + var x118 uint32 + var x119 uint32 + x118, x119 = bits.Add32(x102, uint32(0x0), uint32(uint1(x117))) + 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 + _, x132 = bits.Mul32(x116, 0x72350975) + var x134 uint32 + var x135 uint32 + x135, x134 = bits.Mul32(x132, 0xfffffffe) + var x136 uint32 + var x137 uint32 + x137, x136 = bits.Mul32(x132, 0xffffffff) + var x138 uint32 + var x139 uint32 + x139, x138 = bits.Mul32(x132, 0xffffffff) + var x140 uint32 + var x141 uint32 + x141, x140 = bits.Mul32(x132, 0xffffffff) + var x142 uint32 + var x143 uint32 + x143, x142 = bits.Mul32(x132, 0x7203df6b) + var x144 uint32 + var x145 uint32 + x145, x144 = bits.Mul32(x132, 0x21c6052b) + var x146 uint32 + var x147 uint32 + x147, x146 = bits.Mul32(x132, 0x53bbf409) + var x148 uint32 + var x149 uint32 + x149, x148 = bits.Mul32(x132, 0x39d54123) + 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))) + var x160 uint32 + var x161 uint32 + x160, x161 = bits.Add32(x139, x136, uint32(uint1(x159))) + var x162 uint32 + var x163 uint32 + x162, x163 = bits.Add32(x137, x134, uint32(uint1(x161))) + var x165 uint32 + _, x165 = bits.Add32(x116, x148, uint32(0x0)) + var x166 uint32 + var x167 uint32 + x166, x167 = bits.Add32(x118, x150, uint32(uint1(x165))) + 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((uint32(uint1(x131)) + uint32(uint1(x115))), (uint32(uint1(x163)) + x135), uint32(uint1(x179))) + var x182 uint32 + var x183 uint32 + x182, x183 = bits.Add32(x166, arg1[3], uint32(0x0)) + var x184 uint32 + var x185 uint32 + x184, x185 = bits.Add32(x168, uint32(0x0), uint32(uint1(x183))) + 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 + _, x198 = bits.Mul32(x182, 0x72350975) + var x200 uint32 + var x201 uint32 + x201, x200 = bits.Mul32(x198, 0xfffffffe) + 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, 0x7203df6b) + var x210 uint32 + var x211 uint32 + x211, x210 = bits.Mul32(x198, 0x21c6052b) + var x212 uint32 + var x213 uint32 + x213, x212 = bits.Mul32(x198, 0x53bbf409) + var x214 uint32 + var x215 uint32 + x215, x214 = bits.Mul32(x198, 0x39d54123) + var x216 uint32 + var x217 uint32 + x216, x217 = bits.Add32(x215, x212, uint32(0x0)) + var x218 uint32 + var x219 uint32 + x218, x219 = bits.Add32(x213, x210, uint32(uint1(x217))) + var x220 uint32 + var x221 uint32 + x220, x221 = bits.Add32(x211, x208, uint32(uint1(x219))) + var x222 uint32 + var x223 uint32 + x222, x223 = bits.Add32(x209, x206, uint32(uint1(x221))) + var x224 uint32 + var x225 uint32 + x224, x225 = bits.Add32(x207, x204, uint32(uint1(x223))) + var x226 uint32 + var x227 uint32 + x226, x227 = bits.Add32(x205, x202, uint32(uint1(x225))) + var x228 uint32 + var x229 uint32 + x228, x229 = bits.Add32(x203, x200, uint32(uint1(x227))) + var x231 uint32 + _, x231 = bits.Add32(x182, x214, uint32(0x0)) + var x232 uint32 + var x233 uint32 + x232, x233 = bits.Add32(x184, x216, uint32(uint1(x231))) + 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((uint32(uint1(x197)) + uint32(uint1(x181))), (uint32(uint1(x229)) + x201), uint32(uint1(x245))) + var x248 uint32 + var x249 uint32 + x248, x249 = bits.Add32(x232, arg1[4], uint32(0x0)) + var x250 uint32 + var x251 uint32 + x250, x251 = bits.Add32(x234, uint32(0x0), uint32(uint1(x249))) + 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 + _, x264 = bits.Mul32(x248, 0x72350975) + var x266 uint32 + var x267 uint32 + x267, x266 = bits.Mul32(x264, 0xfffffffe) + var x268 uint32 + var x269 uint32 + x269, x268 = bits.Mul32(x264, 0xffffffff) + var x270 uint32 + var x271 uint32 + x271, x270 = bits.Mul32(x264, 0xffffffff) + var x272 uint32 + var x273 uint32 + x273, x272 = bits.Mul32(x264, 0xffffffff) + var x274 uint32 + var x275 uint32 + x275, x274 = bits.Mul32(x264, 0x7203df6b) + var x276 uint32 + var x277 uint32 + x277, x276 = bits.Mul32(x264, 0x21c6052b) + var x278 uint32 + var x279 uint32 + x279, x278 = bits.Mul32(x264, 0x53bbf409) + var x280 uint32 + var x281 uint32 + x281, x280 = bits.Mul32(x264, 0x39d54123) + var x282 uint32 + var x283 uint32 + x282, x283 = bits.Add32(x281, x278, uint32(0x0)) + var x284 uint32 + var x285 uint32 + x284, x285 = bits.Add32(x279, x276, uint32(uint1(x283))) + var x286 uint32 + var x287 uint32 + x286, x287 = bits.Add32(x277, x274, uint32(uint1(x285))) + var x288 uint32 + var x289 uint32 + x288, x289 = bits.Add32(x275, x272, uint32(uint1(x287))) + var x290 uint32 + var x291 uint32 + x290, x291 = bits.Add32(x273, x270, uint32(uint1(x289))) + var x292 uint32 + var x293 uint32 + x292, x293 = bits.Add32(x271, x268, uint32(uint1(x291))) + var x294 uint32 + var x295 uint32 + x294, x295 = bits.Add32(x269, x266, uint32(uint1(x293))) + var x297 uint32 + _, x297 = bits.Add32(x248, x280, uint32(0x0)) + var x298 uint32 + var x299 uint32 + x298, x299 = bits.Add32(x250, x282, uint32(uint1(x297))) + 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((uint32(uint1(x263)) + uint32(uint1(x247))), (uint32(uint1(x295)) + x267), uint32(uint1(x311))) + var x314 uint32 + var x315 uint32 + x314, x315 = bits.Add32(x298, arg1[5], uint32(0x0)) + var x316 uint32 + var x317 uint32 + x316, x317 = bits.Add32(x300, uint32(0x0), uint32(uint1(x315))) + 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 + _, x330 = bits.Mul32(x314, 0x72350975) + var x332 uint32 + var x333 uint32 + x333, x332 = bits.Mul32(x330, 0xfffffffe) + var x334 uint32 + var x335 uint32 + x335, x334 = bits.Mul32(x330, 0xffffffff) + var x336 uint32 + var x337 uint32 + x337, x336 = bits.Mul32(x330, 0xffffffff) + var x338 uint32 + var x339 uint32 + x339, x338 = bits.Mul32(x330, 0xffffffff) + var x340 uint32 + var x341 uint32 + x341, x340 = bits.Mul32(x330, 0x7203df6b) + var x342 uint32 + var x343 uint32 + x343, x342 = bits.Mul32(x330, 0x21c6052b) + var x344 uint32 + var x345 uint32 + x345, x344 = bits.Mul32(x330, 0x53bbf409) + var x346 uint32 + var x347 uint32 + x347, x346 = bits.Mul32(x330, 0x39d54123) + var x348 uint32 + var x349 uint32 + x348, x349 = bits.Add32(x347, x344, uint32(0x0)) + var x350 uint32 + var x351 uint32 + x350, x351 = bits.Add32(x345, x342, uint32(uint1(x349))) + var x352 uint32 + var x353 uint32 + x352, x353 = bits.Add32(x343, x340, uint32(uint1(x351))) + var x354 uint32 + var x355 uint32 + x354, x355 = bits.Add32(x341, x338, uint32(uint1(x353))) + var x356 uint32 + var x357 uint32 + x356, x357 = bits.Add32(x339, x336, uint32(uint1(x355))) + var x358 uint32 + var x359 uint32 + x358, x359 = bits.Add32(x337, x334, uint32(uint1(x357))) + var x360 uint32 + var x361 uint32 + x360, x361 = bits.Add32(x335, x332, uint32(uint1(x359))) + var x363 uint32 + _, x363 = bits.Add32(x314, x346, uint32(0x0)) + var x364 uint32 + var x365 uint32 + x364, x365 = bits.Add32(x316, x348, uint32(uint1(x363))) + 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((uint32(uint1(x329)) + uint32(uint1(x313))), (uint32(uint1(x361)) + x333), uint32(uint1(x377))) + var x380 uint32 + var x381 uint32 + x380, x381 = bits.Add32(x364, arg1[6], uint32(0x0)) + var x382 uint32 + var x383 uint32 + x382, x383 = bits.Add32(x366, uint32(0x0), uint32(uint1(x381))) + 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 + _, x396 = bits.Mul32(x380, 0x72350975) + var x398 uint32 + var x399 uint32 + x399, x398 = bits.Mul32(x396, 0xfffffffe) + var x400 uint32 + var x401 uint32 + x401, x400 = bits.Mul32(x396, 0xffffffff) + var x402 uint32 + var x403 uint32 + x403, x402 = bits.Mul32(x396, 0xffffffff) + var x404 uint32 + var x405 uint32 + x405, x404 = bits.Mul32(x396, 0xffffffff) + var x406 uint32 + var x407 uint32 + x407, x406 = bits.Mul32(x396, 0x7203df6b) + var x408 uint32 + var x409 uint32 + x409, x408 = bits.Mul32(x396, 0x21c6052b) + var x410 uint32 + var x411 uint32 + x411, x410 = bits.Mul32(x396, 0x53bbf409) + var x412 uint32 + var x413 uint32 + x413, x412 = bits.Mul32(x396, 0x39d54123) + var x414 uint32 + var x415 uint32 + x414, x415 = bits.Add32(x413, x410, uint32(0x0)) + var x416 uint32 + var x417 uint32 + x416, x417 = bits.Add32(x411, x408, uint32(uint1(x415))) + var x418 uint32 + var x419 uint32 + x418, x419 = bits.Add32(x409, x406, uint32(uint1(x417))) + var x420 uint32 + var x421 uint32 + x420, x421 = bits.Add32(x407, x404, uint32(uint1(x419))) + var x422 uint32 + var x423 uint32 + x422, x423 = bits.Add32(x405, x402, uint32(uint1(x421))) + var x424 uint32 + var x425 uint32 + x424, x425 = bits.Add32(x403, x400, uint32(uint1(x423))) + var x426 uint32 + var x427 uint32 + x426, x427 = bits.Add32(x401, x398, uint32(uint1(x425))) + var x429 uint32 + _, x429 = bits.Add32(x380, x412, uint32(0x0)) + var x430 uint32 + var x431 uint32 + x430, x431 = bits.Add32(x382, x414, uint32(uint1(x429))) + 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((uint32(uint1(x395)) + uint32(uint1(x379))), (uint32(uint1(x427)) + x399), uint32(uint1(x443))) + var x446 uint32 + var x447 uint32 + x446, x447 = bits.Add32(x430, arg1[7], uint32(0x0)) + var x448 uint32 + var x449 uint32 + x448, x449 = bits.Add32(x432, uint32(0x0), uint32(uint1(x447))) + 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 + _, x462 = bits.Mul32(x446, 0x72350975) + var x464 uint32 + var x465 uint32 + x465, x464 = bits.Mul32(x462, 0xfffffffe) + var x466 uint32 + var x467 uint32 + x467, x466 = bits.Mul32(x462, 0xffffffff) + var x468 uint32 + var x469 uint32 + x469, x468 = bits.Mul32(x462, 0xffffffff) + var x470 uint32 + var x471 uint32 + x471, x470 = bits.Mul32(x462, 0xffffffff) + var x472 uint32 + var x473 uint32 + x473, x472 = bits.Mul32(x462, 0x7203df6b) + var x474 uint32 + var x475 uint32 + x475, x474 = bits.Mul32(x462, 0x21c6052b) + var x476 uint32 + var x477 uint32 + x477, x476 = bits.Mul32(x462, 0x53bbf409) + var x478 uint32 + var x479 uint32 + x479, x478 = bits.Mul32(x462, 0x39d54123) + var x480 uint32 + var x481 uint32 + x480, x481 = bits.Add32(x479, x476, uint32(0x0)) + var x482 uint32 + var x483 uint32 + x482, x483 = bits.Add32(x477, x474, uint32(uint1(x481))) + var x484 uint32 + var x485 uint32 + x484, x485 = bits.Add32(x475, x472, uint32(uint1(x483))) + var x486 uint32 + var x487 uint32 + x486, x487 = bits.Add32(x473, x470, uint32(uint1(x485))) + var x488 uint32 + var x489 uint32 + x488, x489 = bits.Add32(x471, x468, uint32(uint1(x487))) + var x490 uint32 + var x491 uint32 + x490, x491 = bits.Add32(x469, x466, uint32(uint1(x489))) + var x492 uint32 + var x493 uint32 + x492, x493 = bits.Add32(x467, x464, uint32(uint1(x491))) + var x495 uint32 + _, x495 = bits.Add32(x446, x478, uint32(0x0)) + var x496 uint32 + var x497 uint32 + x496, x497 = bits.Add32(x448, x480, uint32(uint1(x495))) + 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((uint32(uint1(x461)) + uint32(uint1(x445))), (uint32(uint1(x493)) + x465), uint32(uint1(x509))) + var x512 uint32 + var x513 uint32 + x512, x513 = bits.Sub32(x496, 0x39d54123, uint32(0x0)) + var x514 uint32 + var x515 uint32 + x514, x515 = bits.Sub32(x498, 0x53bbf409, uint32(uint1(x513))) + var x516 uint32 + var x517 uint32 + x516, x517 = bits.Sub32(x500, 0x21c6052b, uint32(uint1(x515))) + var x518 uint32 + var x519 uint32 + x518, x519 = bits.Sub32(x502, 0x7203df6b, uint32(uint1(x517))) + var x520 uint32 + var x521 uint32 + x520, x521 = bits.Sub32(x504, 0xffffffff, uint32(uint1(x519))) + var x522 uint32 + var x523 uint32 + x522, x523 = bits.Sub32(x506, 0xffffffff, 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, 0xfffffffe, uint32(uint1(x525))) + var x529 uint32 + _, x529 = bits.Sub32(uint32(uint1(x511)), uint32(0x0), uint32(uint1(x527))) + var x530 uint32 + cmovznzU32(&x530, uint1(x529), x512, x496) + var x531 uint32 + cmovznzU32(&x531, uint1(x529), x514, x498) + var x532 uint32 + cmovznzU32(&x532, uint1(x529), x516, x500) + var x533 uint32 + cmovznzU32(&x533, uint1(x529), x518, x502) + var x534 uint32 + cmovznzU32(&x534, uint1(x529), x520, x504) + var x535 uint32 + cmovznzU32(&x535, uint1(x529), x522, x506) + var x536 uint32 + cmovznzU32(&x536, uint1(x529), x524, x508) + var x537 uint32 + cmovznzU32(&x537, uint1(x529), x526, x510) + out1[0] = x530 + out1[1] = x531 + out1[2] = x532 + out1[3] = x533 + out1[4] = x534 + out1[5] = x535 + out1[6] = x536 + out1[7] = x537 +} + +// 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, 0x1eb5e412) + var x11 uint32 + var x12 uint32 + x12, x11 = bits.Mul32(x8, 0xa22b3d3b) + var x13 uint32 + var x14 uint32 + x14, x13 = bits.Mul32(x8, 0x620fc84c) + var x15 uint32 + var x16 uint32 + x16, x15 = bits.Mul32(x8, 0x3affe0d4) + var x17 uint32 + var x18 uint32 + x18, x17 = bits.Mul32(x8, 0x3464504a) + var x19 uint32 + var x20 uint32 + x20, x19 = bits.Mul32(x8, 0xde6fa2fa) + var x21 uint32 + var x22 uint32 + x22, x21 = bits.Mul32(x8, 0x901192af) + var x23 uint32 + var x24 uint32 + x24, x23 = bits.Mul32(x8, 0x7c114f20) + 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, 0x72350975) + var x41 uint32 + var x42 uint32 + x42, x41 = bits.Mul32(x39, 0xfffffffe) + 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, 0xffffffff) + var x49 uint32 + var x50 uint32 + x50, x49 = bits.Mul32(x39, 0x7203df6b) + var x51 uint32 + var x52 uint32 + x52, x51 = bits.Mul32(x39, 0x21c6052b) + var x53 uint32 + var x54 uint32 + x54, x53 = bits.Mul32(x39, 0x53bbf409) + var x55 uint32 + var x56 uint32 + x56, x55 = bits.Mul32(x39, 0x39d54123) + 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, 0x1eb5e412) + var x91 uint32 + var x92 uint32 + x92, x91 = bits.Mul32(x1, 0xa22b3d3b) + var x93 uint32 + var x94 uint32 + x94, x93 = bits.Mul32(x1, 0x620fc84c) + var x95 uint32 + var x96 uint32 + x96, x95 = bits.Mul32(x1, 0x3affe0d4) + var x97 uint32 + var x98 uint32 + x98, x97 = bits.Mul32(x1, 0x3464504a) + var x99 uint32 + var x100 uint32 + x100, x99 = bits.Mul32(x1, 0xde6fa2fa) + var x101 uint32 + var x102 uint32 + x102, x101 = bits.Mul32(x1, 0x901192af) + var x103 uint32 + var x104 uint32 + x104, x103 = bits.Mul32(x1, 0x7c114f20) + 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, 0x72350975) + var x137 uint32 + var x138 uint32 + x138, x137 = bits.Mul32(x135, 0xfffffffe) + 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, 0xffffffff) + var x145 uint32 + var x146 uint32 + x146, x145 = bits.Mul32(x135, 0x7203df6b) + var x147 uint32 + var x148 uint32 + x148, x147 = bits.Mul32(x135, 0x21c6052b) + var x149 uint32 + var x150 uint32 + x150, x149 = bits.Mul32(x135, 0x53bbf409) + var x151 uint32 + var x152 uint32 + x152, x151 = bits.Mul32(x135, 0x39d54123) + 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, 0x1eb5e412) + var x187 uint32 + var x188 uint32 + x188, x187 = bits.Mul32(x2, 0xa22b3d3b) + var x189 uint32 + var x190 uint32 + x190, x189 = bits.Mul32(x2, 0x620fc84c) + var x191 uint32 + var x192 uint32 + x192, x191 = bits.Mul32(x2, 0x3affe0d4) + var x193 uint32 + var x194 uint32 + x194, x193 = bits.Mul32(x2, 0x3464504a) + var x195 uint32 + var x196 uint32 + x196, x195 = bits.Mul32(x2, 0xde6fa2fa) + var x197 uint32 + var x198 uint32 + x198, x197 = bits.Mul32(x2, 0x901192af) + var x199 uint32 + var x200 uint32 + x200, x199 = bits.Mul32(x2, 0x7c114f20) + 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, 0x72350975) + var x233 uint32 + var x234 uint32 + x234, x233 = bits.Mul32(x231, 0xfffffffe) + 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, 0xffffffff) + var x241 uint32 + var x242 uint32 + x242, x241 = bits.Mul32(x231, 0x7203df6b) + var x243 uint32 + var x244 uint32 + x244, x243 = bits.Mul32(x231, 0x21c6052b) + var x245 uint32 + var x246 uint32 + x246, x245 = bits.Mul32(x231, 0x53bbf409) + var x247 uint32 + var x248 uint32 + x248, x247 = bits.Mul32(x231, 0x39d54123) + 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, 0x1eb5e412) + var x283 uint32 + var x284 uint32 + x284, x283 = bits.Mul32(x3, 0xa22b3d3b) + var x285 uint32 + var x286 uint32 + x286, x285 = bits.Mul32(x3, 0x620fc84c) + var x287 uint32 + var x288 uint32 + x288, x287 = bits.Mul32(x3, 0x3affe0d4) + var x289 uint32 + var x290 uint32 + x290, x289 = bits.Mul32(x3, 0x3464504a) + var x291 uint32 + var x292 uint32 + x292, x291 = bits.Mul32(x3, 0xde6fa2fa) + var x293 uint32 + var x294 uint32 + x294, x293 = bits.Mul32(x3, 0x901192af) + var x295 uint32 + var x296 uint32 + x296, x295 = bits.Mul32(x3, 0x7c114f20) + 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, 0x72350975) + var x329 uint32 + var x330 uint32 + x330, x329 = bits.Mul32(x327, 0xfffffffe) + 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, 0xffffffff) + var x337 uint32 + var x338 uint32 + x338, x337 = bits.Mul32(x327, 0x7203df6b) + var x339 uint32 + var x340 uint32 + x340, x339 = bits.Mul32(x327, 0x21c6052b) + var x341 uint32 + var x342 uint32 + x342, x341 = bits.Mul32(x327, 0x53bbf409) + var x343 uint32 + var x344 uint32 + x344, x343 = bits.Mul32(x327, 0x39d54123) + 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, 0x1eb5e412) + var x379 uint32 + var x380 uint32 + x380, x379 = bits.Mul32(x4, 0xa22b3d3b) + var x381 uint32 + var x382 uint32 + x382, x381 = bits.Mul32(x4, 0x620fc84c) + var x383 uint32 + var x384 uint32 + x384, x383 = bits.Mul32(x4, 0x3affe0d4) + var x385 uint32 + var x386 uint32 + x386, x385 = bits.Mul32(x4, 0x3464504a) + var x387 uint32 + var x388 uint32 + x388, x387 = bits.Mul32(x4, 0xde6fa2fa) + var x389 uint32 + var x390 uint32 + x390, x389 = bits.Mul32(x4, 0x901192af) + var x391 uint32 + var x392 uint32 + x392, x391 = bits.Mul32(x4, 0x7c114f20) + 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, 0x72350975) + var x425 uint32 + var x426 uint32 + x426, x425 = bits.Mul32(x423, 0xfffffffe) + 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, 0xffffffff) + var x433 uint32 + var x434 uint32 + x434, x433 = bits.Mul32(x423, 0x7203df6b) + var x435 uint32 + var x436 uint32 + x436, x435 = bits.Mul32(x423, 0x21c6052b) + var x437 uint32 + var x438 uint32 + x438, x437 = bits.Mul32(x423, 0x53bbf409) + var x439 uint32 + var x440 uint32 + x440, x439 = bits.Mul32(x423, 0x39d54123) + 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, 0x1eb5e412) + var x475 uint32 + var x476 uint32 + x476, x475 = bits.Mul32(x5, 0xa22b3d3b) + var x477 uint32 + var x478 uint32 + x478, x477 = bits.Mul32(x5, 0x620fc84c) + var x479 uint32 + var x480 uint32 + x480, x479 = bits.Mul32(x5, 0x3affe0d4) + var x481 uint32 + var x482 uint32 + x482, x481 = bits.Mul32(x5, 0x3464504a) + var x483 uint32 + var x484 uint32 + x484, x483 = bits.Mul32(x5, 0xde6fa2fa) + var x485 uint32 + var x486 uint32 + x486, x485 = bits.Mul32(x5, 0x901192af) + var x487 uint32 + var x488 uint32 + x488, x487 = bits.Mul32(x5, 0x7c114f20) + 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, 0x72350975) + var x521 uint32 + var x522 uint32 + x522, x521 = bits.Mul32(x519, 0xfffffffe) + 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, 0xffffffff) + var x529 uint32 + var x530 uint32 + x530, x529 = bits.Mul32(x519, 0x7203df6b) + var x531 uint32 + var x532 uint32 + x532, x531 = bits.Mul32(x519, 0x21c6052b) + var x533 uint32 + var x534 uint32 + x534, x533 = bits.Mul32(x519, 0x53bbf409) + var x535 uint32 + var x536 uint32 + x536, x535 = bits.Mul32(x519, 0x39d54123) + 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, 0x1eb5e412) + var x571 uint32 + var x572 uint32 + x572, x571 = bits.Mul32(x6, 0xa22b3d3b) + var x573 uint32 + var x574 uint32 + x574, x573 = bits.Mul32(x6, 0x620fc84c) + var x575 uint32 + var x576 uint32 + x576, x575 = bits.Mul32(x6, 0x3affe0d4) + var x577 uint32 + var x578 uint32 + x578, x577 = bits.Mul32(x6, 0x3464504a) + var x579 uint32 + var x580 uint32 + x580, x579 = bits.Mul32(x6, 0xde6fa2fa) + var x581 uint32 + var x582 uint32 + x582, x581 = bits.Mul32(x6, 0x901192af) + var x583 uint32 + var x584 uint32 + x584, x583 = bits.Mul32(x6, 0x7c114f20) + 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, 0x72350975) + var x617 uint32 + var x618 uint32 + x618, x617 = bits.Mul32(x615, 0xfffffffe) + 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, 0xffffffff) + var x625 uint32 + var x626 uint32 + x626, x625 = bits.Mul32(x615, 0x7203df6b) + var x627 uint32 + var x628 uint32 + x628, x627 = bits.Mul32(x615, 0x21c6052b) + var x629 uint32 + var x630 uint32 + x630, x629 = bits.Mul32(x615, 0x53bbf409) + var x631 uint32 + var x632 uint32 + x632, x631 = bits.Mul32(x615, 0x39d54123) + 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, 0x1eb5e412) + var x667 uint32 + var x668 uint32 + x668, x667 = bits.Mul32(x7, 0xa22b3d3b) + var x669 uint32 + var x670 uint32 + x670, x669 = bits.Mul32(x7, 0x620fc84c) + var x671 uint32 + var x672 uint32 + x672, x671 = bits.Mul32(x7, 0x3affe0d4) + var x673 uint32 + var x674 uint32 + x674, x673 = bits.Mul32(x7, 0x3464504a) + var x675 uint32 + var x676 uint32 + x676, x675 = bits.Mul32(x7, 0xde6fa2fa) + var x677 uint32 + var x678 uint32 + x678, x677 = bits.Mul32(x7, 0x901192af) + var x679 uint32 + var x680 uint32 + x680, x679 = bits.Mul32(x7, 0x7c114f20) + 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, 0x72350975) + var x713 uint32 + var x714 uint32 + x714, x713 = bits.Mul32(x711, 0xfffffffe) + 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, 0xffffffff) + var x721 uint32 + var x722 uint32 + x722, x721 = bits.Mul32(x711, 0x7203df6b) + var x723 uint32 + var x724 uint32 + x724, x723 = bits.Mul32(x711, 0x21c6052b) + var x725 uint32 + var x726 uint32 + x726, x725 = bits.Mul32(x711, 0x53bbf409) + var x727 uint32 + var x728 uint32 + x728, x727 = bits.Mul32(x711, 0x39d54123) + 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, 0x39d54123, uint32(0x0)) + var x763 uint32 + var x764 uint32 + x763, x764 = bits.Sub32(x747, 0x53bbf409, uint32(uint1(x762))) + var x765 uint32 + var x766 uint32 + x765, x766 = bits.Sub32(x749, 0x21c6052b, uint32(uint1(x764))) + var x767 uint32 + var x768 uint32 + x767, x768 = bits.Sub32(x751, 0x7203df6b, uint32(uint1(x766))) + var x769 uint32 + var x770 uint32 + x769, x770 = bits.Sub32(x753, 0xffffffff, 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, 0xfffffffe, 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] = 0xc62abedd + out1[1] = 0xac440bf6 + out1[2] = 0xde39fad4 + out1[3] = 0x8dfc2094 + out1[4] = uint32(0x0) + out1[5] = uint32(0x0) + out1[6] = uint32(0x0) + out1[7] = uint32(0x1) +} + +// 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] = 0x39d54123 + out1[1] = 0x53bbf409 + out1[2] = 0x21c6052b + out1[3] = 0x7203df6b + out1[4] = 0xffffffff + out1[5] = 0xffffffff + out1[6] = 0xffffffff + out1[7] = 0xfffffffe + 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, 0x39d54123, uint32(0x0)) + var x69 uint32 + var x70 uint32 + x69, x70 = bits.Sub32(x53, 0x53bbf409, uint32(uint1(x68))) + var x71 uint32 + var x72 uint32 + x71, x72 = bits.Sub32(x55, 0x21c6052b, uint32(uint1(x70))) + var x73 uint32 + var x74 uint32 + x73, x74 = bits.Sub32(x57, 0x7203df6b, 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, 0xffffffff, uint32(uint1(x78))) + var x81 uint32 + var x82 uint32 + x81, x82 = bits.Sub32(x65, 0xfffffffe, 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 & 0x39d54123), uint32(0x0)) + var x112 uint32 + var x113 uint32 + x112, x113 = bits.Add32(x95, (x109 & 0x53bbf409), uint32(uint1(x111))) + var x114 uint32 + var x115 uint32 + x114, x115 = bits.Add32(x97, (x109 & 0x21c6052b), uint32(uint1(x113))) + var x116 uint32 + var x117 uint32 + x116, x117 = bits.Add32(x99, (x109 & 0x7203df6b), 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, x109, uint32(uint1(x121))) + var x124 uint32 + x124, _ = bits.Add32(x107, (x109 & 0xfffffffe), 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, 0x39d54123, uint32(0x0)) + var x188 uint32 + var x189 uint32 + x188, x189 = bits.Sub32(x172, 0x53bbf409, uint32(uint1(x187))) + var x190 uint32 + var x191 uint32 + x190, x191 = bits.Sub32(x174, 0x21c6052b, uint32(uint1(x189))) + var x192 uint32 + var x193 uint32 + x192, x193 = bits.Sub32(x176, 0x7203df6b, 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, 0xffffffff, uint32(uint1(x197))) + var x200 uint32 + var x201 uint32 + x200, x201 = bits.Sub32(x184, 0xfffffffe, 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] = 0xb351756d + out1[1] = 0x1aa32707 + out1[2] = 0x1e2a62fa + out1[3] = 0xabdd67 + out1[4] = 0xd4009a81 + out1[5] = 0x49280d7d + out1[6] = 0xe6bb86e8 + out1[7] = 0xd730336e +} diff --git a/fiat-go/64/sm2/sm2.go b/fiat-go/64/sm2/sm2.go new file mode 100644 index 00000000000..cda0b9f0b58 --- /dev/null +++ b/fiat-go/64/sm2/sm2.go @@ -0,0 +1,1858 @@ +// 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 sm2 '' 64 '2^256 - 2^224 - 2^96 + 2^64 - 1' 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): sm2 +// +// 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") +// +// +// +// 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 sm2 + +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 + var x21 uint64 + x21, x20 = bits.Mul64(x11, 0xfffffffeffffffff) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x11, 0xffffffffffffffff) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x11, 0xffffffff00000000) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x11, 0xffffffffffffffff) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x27, x24, uint64(0x0)) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x25, x22, uint64(uint1(x29))) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x23, x20, uint64(uint1(x31))) + x34 := (uint64(uint1(x33)) + x21) + var x36 uint64 + _, x36 = bits.Add64(x11, x26, uint64(0x0)) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x13, x28, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x15, x30, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x17, x32, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x19, x34, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, arg2[3]) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg2[2]) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, arg2[1]) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, arg2[0]) + 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))) + x59 := (uint64(uint1(x58)) + x46) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64(x37, x51, uint64(0x0)) + 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(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(uint64(uint1(x44)), x59, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x60, 0xfffffffeffffffff) + var x72 uint64 + var x73 uint64 + x73, x72 = bits.Mul64(x60, 0xffffffffffffffff) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x60, 0xffffffff00000000) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x60, 0xffffffffffffffff) + var x78 uint64 + var x79 uint64 + x78, x79 = bits.Add64(x77, x74, uint64(0x0)) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x75, x72, uint64(uint1(x79))) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x73, x70, uint64(uint1(x81))) + x84 := (uint64(uint1(x83)) + x71) + var x86 uint64 + _, x86 = bits.Add64(x60, x76, uint64(0x0)) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x62, x78, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x64, x80, uint64(uint1(x88))) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x66, x82, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x68, x84, uint64(uint1(x92))) + x95 := (uint64(uint1(x94)) + uint64(uint1(x69))) + var x96 uint64 + var x97 uint64 + x97, x96 = bits.Mul64(x2, arg2[3]) + var x98 uint64 + var x99 uint64 + x99, x98 = bits.Mul64(x2, arg2[2]) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x2, arg2[1]) + var x102 uint64 + var x103 uint64 + x103, x102 = bits.Mul64(x2, arg2[0]) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Add64(x103, x100, uint64(0x0)) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Add64(x101, x98, uint64(uint1(x105))) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Add64(x99, x96, uint64(uint1(x107))) + x110 := (uint64(uint1(x109)) + x97) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x87, x102, uint64(0x0)) + var x113 uint64 + var x114 uint64 + x113, x114 = bits.Add64(x89, x104, uint64(uint1(x112))) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x91, x106, uint64(uint1(x114))) + 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 + x122, x121 = bits.Mul64(x111, 0xfffffffeffffffff) + var x123 uint64 + var x124 uint64 + x124, x123 = bits.Mul64(x111, 0xffffffffffffffff) + var x125 uint64 + var x126 uint64 + x126, x125 = bits.Mul64(x111, 0xffffffff00000000) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x111, 0xffffffffffffffff) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x128, x125, uint64(0x0)) + var x131 uint64 + var x132 uint64 + x131, x132 = bits.Add64(x126, x123, uint64(uint1(x130))) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x124, x121, uint64(uint1(x132))) + x135 := (uint64(uint1(x134)) + x122) + var x137 uint64 + _, x137 = bits.Add64(x111, x127, uint64(0x0)) + var x138 uint64 + var x139 uint64 + x138, x139 = bits.Add64(x113, x129, uint64(uint1(x137))) + var x140 uint64 + var x141 uint64 + x140, x141 = bits.Add64(x115, x131, uint64(uint1(x139))) + var x142 uint64 + var x143 uint64 + x142, x143 = bits.Add64(x117, x133, uint64(uint1(x141))) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x119, x135, uint64(uint1(x143))) + x146 := (uint64(uint1(x145)) + uint64(uint1(x120))) + var x147 uint64 + var x148 uint64 + x148, x147 = bits.Mul64(x3, arg2[3]) + var x149 uint64 + var x150 uint64 + x150, x149 = bits.Mul64(x3, arg2[2]) + var x151 uint64 + var x152 uint64 + x152, x151 = bits.Mul64(x3, arg2[1]) + var x153 uint64 + var x154 uint64 + x154, x153 = bits.Mul64(x3, arg2[0]) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x154, x151, uint64(0x0)) + var x157 uint64 + var x158 uint64 + x157, x158 = bits.Add64(x152, x149, uint64(uint1(x156))) + var x159 uint64 + var x160 uint64 + x159, x160 = bits.Add64(x150, x147, uint64(uint1(x158))) + x161 := (uint64(uint1(x160)) + x148) + var x162 uint64 + var x163 uint64 + x162, x163 = bits.Add64(x138, x153, uint64(0x0)) + var x164 uint64 + var x165 uint64 + x164, x165 = bits.Add64(x140, x155, uint64(uint1(x163))) + var x166 uint64 + var x167 uint64 + x166, x167 = bits.Add64(x142, x157, uint64(uint1(x165))) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x144, x159, uint64(uint1(x167))) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x146, x161, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x173, x172 = bits.Mul64(x162, 0xfffffffeffffffff) + var x174 uint64 + var x175 uint64 + x175, x174 = bits.Mul64(x162, 0xffffffffffffffff) + var x176 uint64 + var x177 uint64 + x177, x176 = bits.Mul64(x162, 0xffffffff00000000) + var x178 uint64 + var x179 uint64 + x179, x178 = bits.Mul64(x162, 0xffffffffffffffff) + var x180 uint64 + var x181 uint64 + x180, x181 = bits.Add64(x179, x176, uint64(0x0)) + var x182 uint64 + var x183 uint64 + x182, x183 = bits.Add64(x177, x174, uint64(uint1(x181))) + var x184 uint64 + var x185 uint64 + x184, x185 = bits.Add64(x175, x172, uint64(uint1(x183))) + x186 := (uint64(uint1(x185)) + x173) + var x188 uint64 + _, x188 = bits.Add64(x162, x178, uint64(0x0)) + var x189 uint64 + var x190 uint64 + x189, x190 = bits.Add64(x164, x180, uint64(uint1(x188))) + var x191 uint64 + var x192 uint64 + x191, x192 = bits.Add64(x166, x182, uint64(uint1(x190))) + var x193 uint64 + var x194 uint64 + x193, x194 = bits.Add64(x168, x184, uint64(uint1(x192))) + var x195 uint64 + var x196 uint64 + x195, x196 = bits.Add64(x170, x186, uint64(uint1(x194))) + x197 := (uint64(uint1(x196)) + uint64(uint1(x171))) + var x198 uint64 + var x199 uint64 + x198, x199 = bits.Sub64(x189, 0xffffffffffffffff, uint64(0x0)) + var x200 uint64 + var x201 uint64 + x200, x201 = bits.Sub64(x191, 0xffffffff00000000, uint64(uint1(x199))) + var x202 uint64 + var x203 uint64 + x202, x203 = bits.Sub64(x193, 0xffffffffffffffff, uint64(uint1(x201))) + var x204 uint64 + var x205 uint64 + x204, x205 = bits.Sub64(x195, 0xfffffffeffffffff, uint64(uint1(x203))) + var x207 uint64 + _, x207 = bits.Sub64(x197, uint64(0x0), uint64(uint1(x205))) + var x208 uint64 + cmovznzU64(&x208, uint1(x207), x198, x189) + var x209 uint64 + cmovznzU64(&x209, uint1(x207), x200, x191) + var x210 uint64 + cmovznzU64(&x210, uint1(x207), x202, x193) + var x211 uint64 + cmovznzU64(&x211, uint1(x207), x204, x195) + out1[0] = x208 + out1[1] = x209 + out1[2] = x210 + out1[3] = x211 +} + +// 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 + var x21 uint64 + x21, x20 = bits.Mul64(x11, 0xfffffffeffffffff) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x11, 0xffffffffffffffff) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x11, 0xffffffff00000000) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x11, 0xffffffffffffffff) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x27, x24, uint64(0x0)) + var x30 uint64 + var x31 uint64 + x30, x31 = bits.Add64(x25, x22, uint64(uint1(x29))) + var x32 uint64 + var x33 uint64 + x32, x33 = bits.Add64(x23, x20, uint64(uint1(x31))) + x34 := (uint64(uint1(x33)) + x21) + var x36 uint64 + _, x36 = bits.Add64(x11, x26, uint64(0x0)) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x13, x28, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x15, x30, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64(x17, x32, uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x43, x44 = bits.Add64(x19, x34, uint64(uint1(x42))) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, arg1[3]) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, arg1[2]) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, arg1[1]) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, arg1[0]) + 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))) + x59 := (uint64(uint1(x58)) + x46) + var x60 uint64 + var x61 uint64 + x60, x61 = bits.Add64(x37, x51, uint64(0x0)) + 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(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(uint64(uint1(x44)), x59, uint64(uint1(x67))) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x60, 0xfffffffeffffffff) + var x72 uint64 + var x73 uint64 + x73, x72 = bits.Mul64(x60, 0xffffffffffffffff) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x60, 0xffffffff00000000) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x60, 0xffffffffffffffff) + var x78 uint64 + var x79 uint64 + x78, x79 = bits.Add64(x77, x74, uint64(0x0)) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x75, x72, uint64(uint1(x79))) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x73, x70, uint64(uint1(x81))) + x84 := (uint64(uint1(x83)) + x71) + var x86 uint64 + _, x86 = bits.Add64(x60, x76, uint64(0x0)) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(x62, x78, uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x89, x90 = bits.Add64(x64, x80, uint64(uint1(x88))) + var x91 uint64 + var x92 uint64 + x91, x92 = bits.Add64(x66, x82, uint64(uint1(x90))) + var x93 uint64 + var x94 uint64 + x93, x94 = bits.Add64(x68, x84, uint64(uint1(x92))) + x95 := (uint64(uint1(x94)) + uint64(uint1(x69))) + var x96 uint64 + var x97 uint64 + x97, x96 = bits.Mul64(x2, arg1[3]) + var x98 uint64 + var x99 uint64 + x99, x98 = bits.Mul64(x2, arg1[2]) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x2, arg1[1]) + var x102 uint64 + var x103 uint64 + x103, x102 = bits.Mul64(x2, arg1[0]) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Add64(x103, x100, uint64(0x0)) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Add64(x101, x98, uint64(uint1(x105))) + var x108 uint64 + var x109 uint64 + x108, x109 = bits.Add64(x99, x96, uint64(uint1(x107))) + x110 := (uint64(uint1(x109)) + x97) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Add64(x87, x102, uint64(0x0)) + var x113 uint64 + var x114 uint64 + x113, x114 = bits.Add64(x89, x104, uint64(uint1(x112))) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Add64(x91, x106, uint64(uint1(x114))) + 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 + x122, x121 = bits.Mul64(x111, 0xfffffffeffffffff) + var x123 uint64 + var x124 uint64 + x124, x123 = bits.Mul64(x111, 0xffffffffffffffff) + var x125 uint64 + var x126 uint64 + x126, x125 = bits.Mul64(x111, 0xffffffff00000000) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x111, 0xffffffffffffffff) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x128, x125, uint64(0x0)) + var x131 uint64 + var x132 uint64 + x131, x132 = bits.Add64(x126, x123, uint64(uint1(x130))) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(x124, x121, uint64(uint1(x132))) + x135 := (uint64(uint1(x134)) + x122) + var x137 uint64 + _, x137 = bits.Add64(x111, x127, uint64(0x0)) + var x138 uint64 + var x139 uint64 + x138, x139 = bits.Add64(x113, x129, uint64(uint1(x137))) + var x140 uint64 + var x141 uint64 + x140, x141 = bits.Add64(x115, x131, uint64(uint1(x139))) + var x142 uint64 + var x143 uint64 + x142, x143 = bits.Add64(x117, x133, uint64(uint1(x141))) + var x144 uint64 + var x145 uint64 + x144, x145 = bits.Add64(x119, x135, uint64(uint1(x143))) + x146 := (uint64(uint1(x145)) + uint64(uint1(x120))) + var x147 uint64 + var x148 uint64 + x148, x147 = bits.Mul64(x3, arg1[3]) + var x149 uint64 + var x150 uint64 + x150, x149 = bits.Mul64(x3, arg1[2]) + var x151 uint64 + var x152 uint64 + x152, x151 = bits.Mul64(x3, arg1[1]) + var x153 uint64 + var x154 uint64 + x154, x153 = bits.Mul64(x3, arg1[0]) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x154, x151, uint64(0x0)) + var x157 uint64 + var x158 uint64 + x157, x158 = bits.Add64(x152, x149, uint64(uint1(x156))) + var x159 uint64 + var x160 uint64 + x159, x160 = bits.Add64(x150, x147, uint64(uint1(x158))) + x161 := (uint64(uint1(x160)) + x148) + var x162 uint64 + var x163 uint64 + x162, x163 = bits.Add64(x138, x153, uint64(0x0)) + var x164 uint64 + var x165 uint64 + x164, x165 = bits.Add64(x140, x155, uint64(uint1(x163))) + var x166 uint64 + var x167 uint64 + x166, x167 = bits.Add64(x142, x157, uint64(uint1(x165))) + var x168 uint64 + var x169 uint64 + x168, x169 = bits.Add64(x144, x159, uint64(uint1(x167))) + var x170 uint64 + var x171 uint64 + x170, x171 = bits.Add64(x146, x161, uint64(uint1(x169))) + var x172 uint64 + var x173 uint64 + x173, x172 = bits.Mul64(x162, 0xfffffffeffffffff) + var x174 uint64 + var x175 uint64 + x175, x174 = bits.Mul64(x162, 0xffffffffffffffff) + var x176 uint64 + var x177 uint64 + x177, x176 = bits.Mul64(x162, 0xffffffff00000000) + var x178 uint64 + var x179 uint64 + x179, x178 = bits.Mul64(x162, 0xffffffffffffffff) + var x180 uint64 + var x181 uint64 + x180, x181 = bits.Add64(x179, x176, uint64(0x0)) + var x182 uint64 + var x183 uint64 + x182, x183 = bits.Add64(x177, x174, uint64(uint1(x181))) + var x184 uint64 + var x185 uint64 + x184, x185 = bits.Add64(x175, x172, uint64(uint1(x183))) + x186 := (uint64(uint1(x185)) + x173) + var x188 uint64 + _, x188 = bits.Add64(x162, x178, uint64(0x0)) + var x189 uint64 + var x190 uint64 + x189, x190 = bits.Add64(x164, x180, uint64(uint1(x188))) + var x191 uint64 + var x192 uint64 + x191, x192 = bits.Add64(x166, x182, uint64(uint1(x190))) + var x193 uint64 + var x194 uint64 + x193, x194 = bits.Add64(x168, x184, uint64(uint1(x192))) + var x195 uint64 + var x196 uint64 + x195, x196 = bits.Add64(x170, x186, uint64(uint1(x194))) + x197 := (uint64(uint1(x196)) + uint64(uint1(x171))) + var x198 uint64 + var x199 uint64 + x198, x199 = bits.Sub64(x189, 0xffffffffffffffff, uint64(0x0)) + var x200 uint64 + var x201 uint64 + x200, x201 = bits.Sub64(x191, 0xffffffff00000000, uint64(uint1(x199))) + var x202 uint64 + var x203 uint64 + x202, x203 = bits.Sub64(x193, 0xffffffffffffffff, uint64(uint1(x201))) + var x204 uint64 + var x205 uint64 + x204, x205 = bits.Sub64(x195, 0xfffffffeffffffff, uint64(uint1(x203))) + var x207 uint64 + _, x207 = bits.Sub64(x197, uint64(0x0), uint64(uint1(x205))) + var x208 uint64 + cmovznzU64(&x208, uint1(x207), x198, x189) + var x209 uint64 + cmovznzU64(&x209, uint1(x207), x200, x191) + var x210 uint64 + cmovznzU64(&x210, uint1(x207), x202, x193) + var x211 uint64 + cmovznzU64(&x211, uint1(x207), x204, x195) + out1[0] = x208 + out1[1] = x209 + out1[2] = x210 + out1[3] = x211 +} + +// 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, 0xffffffffffffffff, uint64(0x0)) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(x3, 0xffffffff00000000, 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, 0xfffffffeffffffff, 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, uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0xffffffff00000000), 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 & 0xfffffffeffffffff), 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, uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0xffffffff00000000), 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 & 0xfffffffeffffffff), 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 + var x3 uint64 + x3, x2 = bits.Mul64(x1, 0xfffffffeffffffff) + var x4 uint64 + var x5 uint64 + x5, x4 = bits.Mul64(x1, 0xffffffffffffffff) + var x6 uint64 + var x7 uint64 + x7, x6 = bits.Mul64(x1, 0xffffffff00000000) + var x8 uint64 + var x9 uint64 + x9, x8 = bits.Mul64(x1, 0xffffffffffffffff) + var x10 uint64 + var x11 uint64 + x10, x11 = bits.Add64(x9, x6, uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x7, x4, uint64(uint1(x11))) + var x14 uint64 + var x15 uint64 + x14, x15 = bits.Add64(x5, x2, uint64(uint1(x13))) + var x17 uint64 + _, x17 = bits.Add64(x1, x8, uint64(0x0)) + var x18 uint64 + var x19 uint64 + x18, x19 = bits.Add64(uint64(0x0), x10, uint64(uint1(x17))) + 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(x18, arg1[1], uint64(0x0)) + var x26 uint64 + var x27 uint64 + x26, x27 = bits.Add64(x20, uint64(0x0), uint64(uint1(x25))) + var x28 uint64 + var x29 uint64 + x28, x29 = bits.Add64(x22, uint64(0x0), uint64(uint1(x27))) + var x30 uint64 + var x31 uint64 + x31, x30 = bits.Mul64(x24, 0xfffffffeffffffff) + var x32 uint64 + var x33 uint64 + x33, x32 = bits.Mul64(x24, 0xffffffffffffffff) + var x34 uint64 + var x35 uint64 + x35, x34 = bits.Mul64(x24, 0xffffffff00000000) + var x36 uint64 + var x37 uint64 + x37, x36 = bits.Mul64(x24, 0xffffffffffffffff) + var x38 uint64 + var x39 uint64 + x38, x39 = bits.Add64(x37, x34, uint64(0x0)) + var x40 uint64 + var x41 uint64 + x40, x41 = bits.Add64(x35, x32, uint64(uint1(x39))) + var x42 uint64 + var x43 uint64 + x42, x43 = bits.Add64(x33, x30, uint64(uint1(x41))) + var x45 uint64 + _, x45 = bits.Add64(x24, x36, uint64(0x0)) + var x46 uint64 + var x47 uint64 + x46, x47 = bits.Add64(x26, x38, uint64(uint1(x45))) + var x48 uint64 + var x49 uint64 + x48, x49 = bits.Add64(x28, x40, uint64(uint1(x47))) + var x50 uint64 + var x51 uint64 + x50, x51 = bits.Add64((uint64(uint1(x29)) + (uint64(uint1(x23)) + (uint64(uint1(x15)) + x3))), x42, uint64(uint1(x49))) + var x52 uint64 + var x53 uint64 + x52, x53 = bits.Add64(x46, arg1[2], uint64(0x0)) + var x54 uint64 + var x55 uint64 + x54, x55 = bits.Add64(x48, uint64(0x0), uint64(uint1(x53))) + var x56 uint64 + var x57 uint64 + x56, x57 = bits.Add64(x50, uint64(0x0), uint64(uint1(x55))) + var x58 uint64 + var x59 uint64 + x59, x58 = bits.Mul64(x52, 0xfffffffeffffffff) + var x60 uint64 + var x61 uint64 + x61, x60 = bits.Mul64(x52, 0xffffffffffffffff) + var x62 uint64 + var x63 uint64 + x63, x62 = bits.Mul64(x52, 0xffffffff00000000) + var x64 uint64 + var x65 uint64 + x65, x64 = bits.Mul64(x52, 0xffffffffffffffff) + 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 x73 uint64 + _, x73 = bits.Add64(x52, x64, uint64(0x0)) + var x74 uint64 + var x75 uint64 + x74, x75 = bits.Add64(x54, x66, uint64(uint1(x73))) + var x76 uint64 + var x77 uint64 + x76, x77 = bits.Add64(x56, x68, uint64(uint1(x75))) + var x78 uint64 + var x79 uint64 + x78, x79 = bits.Add64((uint64(uint1(x57)) + (uint64(uint1(x51)) + (uint64(uint1(x43)) + x31))), x70, uint64(uint1(x77))) + var x80 uint64 + var x81 uint64 + x80, x81 = bits.Add64(x74, arg1[3], uint64(0x0)) + var x82 uint64 + var x83 uint64 + x82, x83 = bits.Add64(x76, uint64(0x0), uint64(uint1(x81))) + var x84 uint64 + var x85 uint64 + x84, x85 = bits.Add64(x78, uint64(0x0), uint64(uint1(x83))) + var x86 uint64 + var x87 uint64 + x87, x86 = bits.Mul64(x80, 0xfffffffeffffffff) + var x88 uint64 + var x89 uint64 + x89, x88 = bits.Mul64(x80, 0xffffffffffffffff) + var x90 uint64 + var x91 uint64 + x91, x90 = bits.Mul64(x80, 0xffffffff00000000) + var x92 uint64 + var x93 uint64 + x93, x92 = bits.Mul64(x80, 0xffffffffffffffff) + var x94 uint64 + var x95 uint64 + x94, x95 = bits.Add64(x93, x90, uint64(0x0)) + var x96 uint64 + var x97 uint64 + x96, x97 = bits.Add64(x91, x88, uint64(uint1(x95))) + var x98 uint64 + var x99 uint64 + x98, x99 = bits.Add64(x89, x86, uint64(uint1(x97))) + var x101 uint64 + _, x101 = bits.Add64(x80, x92, uint64(0x0)) + var x102 uint64 + var x103 uint64 + x102, x103 = bits.Add64(x82, x94, uint64(uint1(x101))) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Add64(x84, x96, uint64(uint1(x103))) + var x106 uint64 + var x107 uint64 + x106, x107 = bits.Add64((uint64(uint1(x85)) + (uint64(uint1(x79)) + (uint64(uint1(x71)) + x59))), x98, uint64(uint1(x105))) + x108 := (uint64(uint1(x107)) + (uint64(uint1(x99)) + x87)) + var x109 uint64 + var x110 uint64 + x109, x110 = bits.Sub64(x102, 0xffffffffffffffff, uint64(0x0)) + var x111 uint64 + var x112 uint64 + x111, x112 = bits.Sub64(x104, 0xffffffff00000000, uint64(uint1(x110))) + var x113 uint64 + var x114 uint64 + x113, x114 = bits.Sub64(x106, 0xffffffffffffffff, uint64(uint1(x112))) + var x115 uint64 + var x116 uint64 + x115, x116 = bits.Sub64(x108, 0xfffffffeffffffff, uint64(uint1(x114))) + var x118 uint64 + _, x118 = bits.Sub64(uint64(0x0), uint64(0x0), uint64(uint1(x116))) + var x119 uint64 + cmovznzU64(&x119, uint1(x118), x109, x102) + var x120 uint64 + cmovznzU64(&x120, uint1(x118), x111, x104) + var x121 uint64 + cmovznzU64(&x121, uint1(x118), x113, x106) + var x122 uint64 + cmovznzU64(&x122, uint1(x118), x115, x108) + out1[0] = x119 + out1[1] = x120 + out1[2] = x121 + out1[3] = x122 +} + +// 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, 0x400000002) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, 0x100000001) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, 0x2ffffffff) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, 0x200000003) + 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 + var x20 uint64 + x20, x19 = bits.Mul64(x11, 0xfffffffeffffffff) + var x21 uint64 + var x22 uint64 + x22, x21 = bits.Mul64(x11, 0xffffffffffffffff) + var x23 uint64 + var x24 uint64 + x24, x23 = bits.Mul64(x11, 0xffffffff00000000) + var x25 uint64 + var x26 uint64 + x26, x25 = bits.Mul64(x11, 0xffffffffffffffff) + var x27 uint64 + var x28 uint64 + x27, x28 = bits.Add64(x26, x23, uint64(0x0)) + var x29 uint64 + var x30 uint64 + x29, x30 = bits.Add64(x24, x21, uint64(uint1(x28))) + var x31 uint64 + var x32 uint64 + x31, x32 = bits.Add64(x22, x19, uint64(uint1(x30))) + var x34 uint64 + _, x34 = bits.Add64(x11, x25, uint64(0x0)) + var x35 uint64 + var x36 uint64 + x35, x36 = bits.Add64(x13, x27, uint64(uint1(x34))) + var x37 uint64 + var x38 uint64 + x37, x38 = bits.Add64(x15, x29, uint64(uint1(x36))) + var x39 uint64 + var x40 uint64 + x39, x40 = bits.Add64(x17, x31, uint64(uint1(x38))) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Add64((uint64(uint1(x18)) + x6), (uint64(uint1(x32)) + x20), uint64(uint1(x40))) + var x43 uint64 + var x44 uint64 + x44, x43 = bits.Mul64(x1, 0x400000002) + var x45 uint64 + var x46 uint64 + x46, x45 = bits.Mul64(x1, 0x100000001) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, 0x2ffffffff) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, 0x200000003) + var x51 uint64 + var x52 uint64 + x51, x52 = bits.Add64(x50, x47, uint64(0x0)) + var x53 uint64 + var x54 uint64 + x53, x54 = bits.Add64(x48, x45, uint64(uint1(x52))) + var x55 uint64 + var x56 uint64 + x55, x56 = bits.Add64(x46, x43, uint64(uint1(x54))) + var x57 uint64 + var x58 uint64 + x57, x58 = bits.Add64(x35, x49, uint64(0x0)) + var x59 uint64 + var x60 uint64 + x59, x60 = bits.Add64(x37, x51, uint64(uint1(x58))) + 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 + x66, x65 = bits.Mul64(x57, 0xfffffffeffffffff) + var x67 uint64 + var x68 uint64 + x68, x67 = bits.Mul64(x57, 0xffffffffffffffff) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x57, 0xffffffff00000000) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x57, 0xffffffffffffffff) + var x73 uint64 + var x74 uint64 + x73, x74 = bits.Add64(x72, x69, uint64(0x0)) + var x75 uint64 + var x76 uint64 + x75, x76 = bits.Add64(x70, x67, uint64(uint1(x74))) + var x77 uint64 + var x78 uint64 + x77, x78 = bits.Add64(x68, x65, uint64(uint1(x76))) + var x80 uint64 + _, x80 = bits.Add64(x57, x71, uint64(0x0)) + var x81 uint64 + var x82 uint64 + x81, x82 = bits.Add64(x59, x73, uint64(uint1(x80))) + var x83 uint64 + var x84 uint64 + x83, x84 = bits.Add64(x61, x75, uint64(uint1(x82))) + var x85 uint64 + var x86 uint64 + x85, x86 = bits.Add64(x63, x77, uint64(uint1(x84))) + var x87 uint64 + var x88 uint64 + x87, x88 = bits.Add64(((uint64(uint1(x64)) + uint64(uint1(x42))) + (uint64(uint1(x56)) + x44)), (uint64(uint1(x78)) + x66), uint64(uint1(x86))) + var x89 uint64 + var x90 uint64 + x90, x89 = bits.Mul64(x2, 0x400000002) + var x91 uint64 + var x92 uint64 + x92, x91 = bits.Mul64(x2, 0x100000001) + var x93 uint64 + var x94 uint64 + x94, x93 = bits.Mul64(x2, 0x2ffffffff) + var x95 uint64 + var x96 uint64 + x96, x95 = bits.Mul64(x2, 0x200000003) + var x97 uint64 + var x98 uint64 + x97, x98 = bits.Add64(x96, x93, uint64(0x0)) + var x99 uint64 + var x100 uint64 + x99, x100 = bits.Add64(x94, x91, uint64(uint1(x98))) + var x101 uint64 + var x102 uint64 + x101, x102 = bits.Add64(x92, x89, uint64(uint1(x100))) + var x103 uint64 + var x104 uint64 + x103, x104 = bits.Add64(x81, x95, uint64(0x0)) + var x105 uint64 + var x106 uint64 + x105, x106 = bits.Add64(x83, x97, uint64(uint1(x104))) + var x107 uint64 + var x108 uint64 + x107, x108 = bits.Add64(x85, x99, uint64(uint1(x106))) + var x109 uint64 + var x110 uint64 + x109, x110 = bits.Add64(x87, x101, uint64(uint1(x108))) + var x111 uint64 + var x112 uint64 + x112, x111 = bits.Mul64(x103, 0xfffffffeffffffff) + var x113 uint64 + var x114 uint64 + x114, x113 = bits.Mul64(x103, 0xffffffffffffffff) + var x115 uint64 + var x116 uint64 + x116, x115 = bits.Mul64(x103, 0xffffffff00000000) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x103, 0xffffffffffffffff) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Add64(x118, x115, uint64(0x0)) + var x121 uint64 + var x122 uint64 + x121, x122 = bits.Add64(x116, x113, uint64(uint1(x120))) + var x123 uint64 + var x124 uint64 + x123, x124 = bits.Add64(x114, x111, uint64(uint1(x122))) + var x126 uint64 + _, x126 = bits.Add64(x103, x117, uint64(0x0)) + var x127 uint64 + var x128 uint64 + x127, x128 = bits.Add64(x105, x119, uint64(uint1(x126))) + var x129 uint64 + var x130 uint64 + x129, x130 = bits.Add64(x107, x121, uint64(uint1(x128))) + var x131 uint64 + var x132 uint64 + x131, x132 = bits.Add64(x109, x123, uint64(uint1(x130))) + var x133 uint64 + var x134 uint64 + x133, x134 = bits.Add64(((uint64(uint1(x110)) + uint64(uint1(x88))) + (uint64(uint1(x102)) + x90)), (uint64(uint1(x124)) + x112), uint64(uint1(x132))) + var x135 uint64 + var x136 uint64 + x136, x135 = bits.Mul64(x3, 0x400000002) + var x137 uint64 + var x138 uint64 + x138, x137 = bits.Mul64(x3, 0x100000001) + var x139 uint64 + var x140 uint64 + x140, x139 = bits.Mul64(x3, 0x2ffffffff) + var x141 uint64 + var x142 uint64 + x142, x141 = bits.Mul64(x3, 0x200000003) + 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))) + var x149 uint64 + var x150 uint64 + x149, x150 = bits.Add64(x127, x141, uint64(0x0)) + var x151 uint64 + var x152 uint64 + x151, x152 = bits.Add64(x129, x143, uint64(uint1(x150))) + var x153 uint64 + var x154 uint64 + x153, x154 = bits.Add64(x131, x145, uint64(uint1(x152))) + var x155 uint64 + var x156 uint64 + x155, x156 = bits.Add64(x133, x147, uint64(uint1(x154))) + var x157 uint64 + var x158 uint64 + x158, x157 = bits.Mul64(x149, 0xfffffffeffffffff) + var x159 uint64 + var x160 uint64 + x160, x159 = bits.Mul64(x149, 0xffffffffffffffff) + var x161 uint64 + var x162 uint64 + x162, x161 = bits.Mul64(x149, 0xffffffff00000000) + var x163 uint64 + var x164 uint64 + x164, x163 = bits.Mul64(x149, 0xffffffffffffffff) + var x165 uint64 + var x166 uint64 + x165, x166 = bits.Add64(x164, x161, uint64(0x0)) + var x167 uint64 + var x168 uint64 + x167, x168 = bits.Add64(x162, x159, uint64(uint1(x166))) + var x169 uint64 + var x170 uint64 + x169, x170 = bits.Add64(x160, x157, uint64(uint1(x168))) + var x172 uint64 + _, x172 = bits.Add64(x149, x163, uint64(0x0)) + var x173 uint64 + var x174 uint64 + x173, x174 = bits.Add64(x151, x165, uint64(uint1(x172))) + var x175 uint64 + var x176 uint64 + x175, x176 = bits.Add64(x153, x167, uint64(uint1(x174))) + var x177 uint64 + var x178 uint64 + x177, x178 = bits.Add64(x155, x169, uint64(uint1(x176))) + var x179 uint64 + var x180 uint64 + x179, x180 = bits.Add64(((uint64(uint1(x156)) + uint64(uint1(x134))) + (uint64(uint1(x148)) + x136)), (uint64(uint1(x170)) + x158), uint64(uint1(x178))) + var x181 uint64 + var x182 uint64 + x181, x182 = bits.Sub64(x173, 0xffffffffffffffff, uint64(0x0)) + var x183 uint64 + var x184 uint64 + x183, x184 = bits.Sub64(x175, 0xffffffff00000000, uint64(uint1(x182))) + var x185 uint64 + var x186 uint64 + x185, x186 = bits.Sub64(x177, 0xffffffffffffffff, uint64(uint1(x184))) + var x187 uint64 + var x188 uint64 + x187, x188 = bits.Sub64(x179, 0xfffffffeffffffff, uint64(uint1(x186))) + var x190 uint64 + _, x190 = bits.Sub64(uint64(uint1(x180)), uint64(0x0), uint64(uint1(x188))) + var x191 uint64 + cmovznzU64(&x191, uint1(x190), x181, x173) + var x192 uint64 + cmovznzU64(&x192, uint1(x190), x183, x175) + var x193 uint64 + cmovznzU64(&x193, uint1(x190), x185, x177) + var x194 uint64 + cmovznzU64(&x194, uint1(x190), x187, x179) + out1[0] = x191 + out1[1] = x192 + out1[2] = x193 + out1[3] = x194 +} + +// 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] = uint64(0x1) + out1[1] = 0xffffffff + out1[2] = uint64(0x0) + out1[3] = 0x100000000 +} + +// 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] = 0xffffffffffffffff + out1[1] = 0xffffffff00000000 + out1[2] = 0xffffffffffffffff + out1[3] = 0xfffffffeffffffff + 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, 0xffffffffffffffff, uint64(0x0)) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Sub64(x33, 0xffffffff00000000, 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, 0xfffffffeffffffff, 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, uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x55, (x61 & 0xffffffff00000000), 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 & 0xfffffffeffffffff), 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, 0xffffffffffffffff, uint64(0x0)) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Sub64(x96, 0xffffffff00000000, 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, 0xfffffffeffffffff, 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] = 0x500000028ffffffe + out1[1] = 0xe80000009ffffffe + out1[2] = 0xd00000018ffffffe + out1[3] = 0x280000011ffffffd +} diff --git a/fiat-go/64/sm2scalar/sm2scalar.go b/fiat-go/64/sm2scalar/sm2scalar.go new file mode 100644 index 00000000000..bfa1c2a5814 --- /dev/null +++ b/fiat-go/64/sm2scalar/sm2scalar.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 sm2scalar '' 64 '2^256 - 2^224 - 188730267045675049073202170516080344797' 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): sm2scalar +// +// 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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") +// +// +// +// 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 sm2scalar + +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, 0x327f9e8872350975) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0xfffffffeffffffff) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0xffffffffffffffff) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0x7203df6b21c6052b) + var x28 uint64 + var x29 uint64 + x29, x28 = bits.Mul64(x20, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x72, 0xfffffffeffffffff) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x72, 0xffffffffffffffff) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x72, 0x7203df6b21c6052b) + var x80 uint64 + var x81 uint64 + x81, x80 = bits.Mul64(x72, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x125, 0xfffffffeffffffff) + var x129 uint64 + var x130 uint64 + x130, x129 = bits.Mul64(x125, 0xffffffffffffffff) + var x131 uint64 + var x132 uint64 + x132, x131 = bits.Mul64(x125, 0x7203df6b21c6052b) + var x133 uint64 + var x134 uint64 + x134, x133 = bits.Mul64(x125, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x180 uint64 + var x181 uint64 + x181, x180 = bits.Mul64(x178, 0xfffffffeffffffff) + var x182 uint64 + var x183 uint64 + x183, x182 = bits.Mul64(x178, 0xffffffffffffffff) + var x184 uint64 + var x185 uint64 + x185, x184 = bits.Mul64(x178, 0x7203df6b21c6052b) + var x186 uint64 + var x187 uint64 + x187, x186 = bits.Mul64(x178, 0x53bbf40939d54123) + 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, 0x53bbf40939d54123, uint64(0x0)) + var x208 uint64 + var x209 uint64 + x208, x209 = bits.Sub64(x199, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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, 0x327f9e8872350975) + var x22 uint64 + var x23 uint64 + x23, x22 = bits.Mul64(x20, 0xfffffffeffffffff) + var x24 uint64 + var x25 uint64 + x25, x24 = bits.Mul64(x20, 0xffffffffffffffff) + var x26 uint64 + var x27 uint64 + x27, x26 = bits.Mul64(x20, 0x7203df6b21c6052b) + var x28 uint64 + var x29 uint64 + x29, x28 = bits.Mul64(x20, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x74 uint64 + var x75 uint64 + x75, x74 = bits.Mul64(x72, 0xfffffffeffffffff) + var x76 uint64 + var x77 uint64 + x77, x76 = bits.Mul64(x72, 0xffffffffffffffff) + var x78 uint64 + var x79 uint64 + x79, x78 = bits.Mul64(x72, 0x7203df6b21c6052b) + var x80 uint64 + var x81 uint64 + x81, x80 = bits.Mul64(x72, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x127 uint64 + var x128 uint64 + x128, x127 = bits.Mul64(x125, 0xfffffffeffffffff) + var x129 uint64 + var x130 uint64 + x130, x129 = bits.Mul64(x125, 0xffffffffffffffff) + var x131 uint64 + var x132 uint64 + x132, x131 = bits.Mul64(x125, 0x7203df6b21c6052b) + var x133 uint64 + var x134 uint64 + x134, x133 = bits.Mul64(x125, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x180 uint64 + var x181 uint64 + x181, x180 = bits.Mul64(x178, 0xfffffffeffffffff) + var x182 uint64 + var x183 uint64 + x183, x182 = bits.Mul64(x178, 0xffffffffffffffff) + var x184 uint64 + var x185 uint64 + x185, x184 = bits.Mul64(x178, 0x7203df6b21c6052b) + var x186 uint64 + var x187 uint64 + x187, x186 = bits.Mul64(x178, 0x53bbf40939d54123) + 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, 0x53bbf40939d54123, uint64(0x0)) + var x208 uint64 + var x209 uint64 + x208, x209 = bits.Sub64(x199, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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, 0x53bbf40939d54123, uint64(0x0)) + var x11 uint64 + var x12 uint64 + x11, x12 = bits.Sub64(x3, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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 & 0x53bbf40939d54123), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0x7203df6b21c6052b), 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 & 0xfffffffeffffffff), 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 & 0x53bbf40939d54123), uint64(0x0)) + var x12 uint64 + var x13 uint64 + x12, x13 = bits.Add64(x3, (x9 & 0x7203df6b21c6052b), 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 & 0xfffffffeffffffff), 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, 0x327f9e8872350975) + var x4 uint64 + var x5 uint64 + x5, x4 = bits.Mul64(x2, 0xfffffffeffffffff) + var x6 uint64 + var x7 uint64 + x7, x6 = bits.Mul64(x2, 0xffffffffffffffff) + var x8 uint64 + var x9 uint64 + x9, x8 = bits.Mul64(x2, 0x7203df6b21c6052b) + var x10 uint64 + var x11 uint64 + x11, x10 = bits.Mul64(x2, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x34 uint64 + var x35 uint64 + x35, x34 = bits.Mul64(x32, 0xfffffffeffffffff) + var x36 uint64 + var x37 uint64 + x37, x36 = bits.Mul64(x32, 0xffffffffffffffff) + var x38 uint64 + var x39 uint64 + x39, x38 = bits.Mul64(x32, 0x7203df6b21c6052b) + var x40 uint64 + var x41 uint64 + x41, x40 = bits.Mul64(x32, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x64 uint64 + var x65 uint64 + x65, x64 = bits.Mul64(x62, 0xfffffffeffffffff) + var x66 uint64 + var x67 uint64 + x67, x66 = bits.Mul64(x62, 0xffffffffffffffff) + var x68 uint64 + var x69 uint64 + x69, x68 = bits.Mul64(x62, 0x7203df6b21c6052b) + var x70 uint64 + var x71 uint64 + x71, x70 = bits.Mul64(x62, 0x53bbf40939d54123) + 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, 0x327f9e8872350975) + var x94 uint64 + var x95 uint64 + x95, x94 = bits.Mul64(x92, 0xfffffffeffffffff) + var x96 uint64 + var x97 uint64 + x97, x96 = bits.Mul64(x92, 0xffffffffffffffff) + var x98 uint64 + var x99 uint64 + x99, x98 = bits.Mul64(x92, 0x7203df6b21c6052b) + var x100 uint64 + var x101 uint64 + x101, x100 = bits.Mul64(x92, 0x53bbf40939d54123) + 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, 0x53bbf40939d54123, uint64(0x0)) + var x119 uint64 + var x120 uint64 + x119, x120 = bits.Sub64(x112, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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, 0x1eb5e412a22b3d3b) + var x7 uint64 + var x8 uint64 + x8, x7 = bits.Mul64(x4, 0x620fc84c3affe0d4) + var x9 uint64 + var x10 uint64 + x10, x9 = bits.Mul64(x4, 0x3464504ade6fa2fa) + var x11 uint64 + var x12 uint64 + x12, x11 = bits.Mul64(x4, 0x901192af7c114f20) + 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, 0x327f9e8872350975) + var x21 uint64 + var x22 uint64 + x22, x21 = bits.Mul64(x19, 0xfffffffeffffffff) + var x23 uint64 + var x24 uint64 + x24, x23 = bits.Mul64(x19, 0xffffffffffffffff) + var x25 uint64 + var x26 uint64 + x26, x25 = bits.Mul64(x19, 0x7203df6b21c6052b) + var x27 uint64 + var x28 uint64 + x28, x27 = bits.Mul64(x19, 0x53bbf40939d54123) + 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, 0x1eb5e412a22b3d3b) + var x47 uint64 + var x48 uint64 + x48, x47 = bits.Mul64(x1, 0x620fc84c3affe0d4) + var x49 uint64 + var x50 uint64 + x50, x49 = bits.Mul64(x1, 0x3464504ade6fa2fa) + var x51 uint64 + var x52 uint64 + x52, x51 = bits.Mul64(x1, 0x901192af7c114f20) + 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, 0x327f9e8872350975) + var x69 uint64 + var x70 uint64 + x70, x69 = bits.Mul64(x67, 0xfffffffeffffffff) + var x71 uint64 + var x72 uint64 + x72, x71 = bits.Mul64(x67, 0xffffffffffffffff) + var x73 uint64 + var x74 uint64 + x74, x73 = bits.Mul64(x67, 0x7203df6b21c6052b) + var x75 uint64 + var x76 uint64 + x76, x75 = bits.Mul64(x67, 0x53bbf40939d54123) + 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, 0x1eb5e412a22b3d3b) + var x95 uint64 + var x96 uint64 + x96, x95 = bits.Mul64(x2, 0x620fc84c3affe0d4) + var x97 uint64 + var x98 uint64 + x98, x97 = bits.Mul64(x2, 0x3464504ade6fa2fa) + var x99 uint64 + var x100 uint64 + x100, x99 = bits.Mul64(x2, 0x901192af7c114f20) + 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, 0x327f9e8872350975) + var x117 uint64 + var x118 uint64 + x118, x117 = bits.Mul64(x115, 0xfffffffeffffffff) + var x119 uint64 + var x120 uint64 + x120, x119 = bits.Mul64(x115, 0xffffffffffffffff) + var x121 uint64 + var x122 uint64 + x122, x121 = bits.Mul64(x115, 0x7203df6b21c6052b) + var x123 uint64 + var x124 uint64 + x124, x123 = bits.Mul64(x115, 0x53bbf40939d54123) + 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, 0x1eb5e412a22b3d3b) + var x143 uint64 + var x144 uint64 + x144, x143 = bits.Mul64(x3, 0x620fc84c3affe0d4) + var x145 uint64 + var x146 uint64 + x146, x145 = bits.Mul64(x3, 0x3464504ade6fa2fa) + var x147 uint64 + var x148 uint64 + x148, x147 = bits.Mul64(x3, 0x901192af7c114f20) + 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, 0x327f9e8872350975) + var x165 uint64 + var x166 uint64 + x166, x165 = bits.Mul64(x163, 0xfffffffeffffffff) + var x167 uint64 + var x168 uint64 + x168, x167 = bits.Mul64(x163, 0xffffffffffffffff) + var x169 uint64 + var x170 uint64 + x170, x169 = bits.Mul64(x163, 0x7203df6b21c6052b) + var x171 uint64 + var x172 uint64 + x172, x171 = bits.Mul64(x163, 0x53bbf40939d54123) + 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, 0x53bbf40939d54123, uint64(0x0)) + var x191 uint64 + var x192 uint64 + x191, x192 = bits.Sub64(x183, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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] = 0xac440bf6c62abedd + out1[1] = 0x8dfc2094de39fad4 + out1[2] = uint64(0x0) + out1[3] = 0x100000000 +} + +// 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] = 0x53bbf40939d54123 + out1[1] = 0x7203df6b21c6052b + out1[2] = 0xffffffffffffffff + out1[3] = 0xfffffffeffffffff + 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, 0x53bbf40939d54123, uint64(0x0)) + var x41 uint64 + var x42 uint64 + x41, x42 = bits.Sub64(x33, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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 & 0x53bbf40939d54123), uint64(0x0)) + var x64 uint64 + var x65 uint64 + x64, x65 = bits.Add64(x55, (x61 & 0x7203df6b21c6052b), 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 & 0xfffffffeffffffff), 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, 0x53bbf40939d54123, uint64(0x0)) + var x104 uint64 + var x105 uint64 + x104, x105 = bits.Sub64(x96, 0x7203df6b21c6052b, 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, 0xfffffffeffffffff, 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] = 0x1aa32707b351756d + out1[1] = 0xabdd671e2a62fa + out1[2] = 0x49280d7dd4009a81 + out1[3] = 0xd730336ee6bb86e8 +} diff --git a/fiat-java/src/FiatSm2.java b/fiat-java/src/FiatSm2.java new file mode 100644 index 00000000000..a443dc0c78c --- /dev/null +++ b/fiat-java/src/FiatSm2.java @@ -0,0 +1,5231 @@ +/* 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 Sm2 32 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: Sm2 */ +/* 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") */ +/* */ +/* 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 FiatSm2 { + +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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_mulx_u32(x9, x10, x8, (arg2[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2_mulx_u32(x11, x12, x8, (arg2[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2_mulx_u32(x13, x14, x8, (arg2[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2_mulx_u32(x15, x16, x8, (arg2[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2_mulx_u32(x17, x18, x8, (arg2[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2_mulx_u32(x19, x20, x8, (arg2[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2_mulx_u32(x21, x22, x8, (arg2[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2_mulx_u32(x23, x24, x8, (arg2[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Sm2_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_Sm2_mulx_u32(x40, x41, (x23).get(), 0xfffffffe); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Sm2_mulx_u32(x42, x43, (x23).get(), 0xffffffff); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Sm2_mulx_u32(x44, x45, (x23).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Sm2_mulx_u32(x46, x47, (x23).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Sm2_mulx_u32(x48, x49, (x23).get(), 0xffffffff); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Sm2_mulx_u32(x50, x51, (x23).get(), 0xffffffff); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Sm2_mulx_u32(x52, x53, (x23).get(), 0xffffffff); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x54, x55, 0x0, (x53).get(), (x50).get()); + int x56 = ((x55).get() + (x51).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x57, x58, 0x0, (x49).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x44).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x61, x62, (x60).get(), (x45).get(), (x42).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x63, x64, (x62).get(), (x43).get(), (x40).get()); + int x65 = ((x64).get() + (x41).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x66, x67, 0x0, (x23).get(), (x52).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x68, x69, (x67).get(), (x25).get(), (x54).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x70, x71, (x69).get(), (x27).get(), x56); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x72, x73, (x71).get(), (x29).get(), (x48).get()); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x74, x75, (x73).get(), (x31).get(), (x57).get()); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x76, x77, (x75).get(), (x33).get(), (x59).get()); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x78, x79, (x77).get(), (x35).get(), (x61).get()); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x80, x81, (x79).get(), (x37).get(), (x63).get()); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x82, x83, (x81).get(), x39, x65); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_Sm2_mulx_u32(x84, x85, x1, (arg2[7])); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_Sm2_mulx_u32(x86, x87, x1, (arg2[6])); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_Sm2_mulx_u32(x88, x89, x1, (arg2[5])); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_Sm2_mulx_u32(x90, x91, x1, (arg2[4])); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_Sm2_mulx_u32(x92, x93, x1, (arg2[3])); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_Sm2_mulx_u32(x94, x95, x1, (arg2[2])); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_Sm2_mulx_u32(x96, x97, x1, (arg2[1])); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_Sm2_mulx_u32(x98, x99, x1, (arg2[0])); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x100, x101, 0x0, (x99).get(), (x96).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x102, x103, (x101).get(), (x97).get(), (x94).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x104, x105, (x103).get(), (x95).get(), (x92).get()); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x106, x107, (x105).get(), (x93).get(), (x90).get()); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x108, x109, (x107).get(), (x91).get(), (x88).get()); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x110, x111, (x109).get(), (x89).get(), (x86).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x112, x113, (x111).get(), (x87).get(), (x84).get()); + int x114 = ((x113).get() + (x85).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x115, x116, 0x0, (x68).get(), (x98).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x117, x118, (x116).get(), (x70).get(), (x100).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x119, x120, (x118).get(), (x72).get(), (x102).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x121, x122, (x120).get(), (x74).get(), (x104).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x123, x124, (x122).get(), (x76).get(), (x106).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x125, x126, (x124).get(), (x78).get(), (x108).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x127, x128, (x126).get(), (x80).get(), (x110).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x129, x130, (x128).get(), (x82).get(), (x112).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x131, x132, (x130).get(), (x83).get(), x114); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_Sm2_mulx_u32(x133, x134, (x115).get(), 0xfffffffe); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_Sm2_mulx_u32(x135, x136, (x115).get(), 0xffffffff); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_Sm2_mulx_u32(x137, x138, (x115).get(), 0xffffffff); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_Sm2_mulx_u32(x139, x140, (x115).get(), 0xffffffff); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_Sm2_mulx_u32(x141, x142, (x115).get(), 0xffffffff); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_Sm2_mulx_u32(x143, x144, (x115).get(), 0xffffffff); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Sm2_mulx_u32(x145, x146, (x115).get(), 0xffffffff); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x147, x148, 0x0, (x146).get(), (x143).get()); + int x149 = ((x148).get() + (x144).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x150, x151, 0x0, (x142).get(), (x139).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x152, x153, (x151).get(), (x140).get(), (x137).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x154, x155, (x153).get(), (x138).get(), (x135).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x156, x157, (x155).get(), (x136).get(), (x133).get()); + int x158 = ((x157).get() + (x134).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x159, x160, 0x0, (x115).get(), (x145).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x161, x162, (x160).get(), (x117).get(), (x147).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x163, x164, (x162).get(), (x119).get(), x149); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x165, x166, (x164).get(), (x121).get(), (x141).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x167, x168, (x166).get(), (x123).get(), (x150).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x169, x170, (x168).get(), (x125).get(), (x152).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x171, x172, (x170).get(), (x127).get(), (x154).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x173, x174, (x172).get(), (x129).get(), (x156).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x175, x176, (x174).get(), (x131).get(), x158); + int x177 = ((x176).get() + (x132).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Sm2_mulx_u32(x178, x179, x2, (arg2[7])); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Sm2_mulx_u32(x180, x181, x2, (arg2[6])); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Sm2_mulx_u32(x182, x183, x2, (arg2[5])); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Sm2_mulx_u32(x184, x185, x2, (arg2[4])); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Sm2_mulx_u32(x186, x187, x2, (arg2[3])); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Sm2_mulx_u32(x188, x189, x2, (arg2[2])); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Sm2_mulx_u32(x190, x191, x2, (arg2[1])); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Sm2_mulx_u32(x192, x193, x2, (arg2[0])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x194, x195, 0x0, (x193).get(), (x190).get()); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x196, x197, (x195).get(), (x191).get(), (x188).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x198, x199, (x197).get(), (x189).get(), (x186).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x200, x201, (x199).get(), (x187).get(), (x184).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x202, x203, (x201).get(), (x185).get(), (x182).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x204, x205, (x203).get(), (x183).get(), (x180).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x206, x207, (x205).get(), (x181).get(), (x178).get()); + int x208 = ((x207).get() + (x179).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x209, x210, 0x0, (x161).get(), (x192).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x211, x212, (x210).get(), (x163).get(), (x194).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x213, x214, (x212).get(), (x165).get(), (x196).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x215, x216, (x214).get(), (x167).get(), (x198).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x217, x218, (x216).get(), (x169).get(), (x200).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x219, x220, (x218).get(), (x171).get(), (x202).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x221, x222, (x220).get(), (x173).get(), (x204).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x223, x224, (x222).get(), (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x225, x226, (x224).get(), x177, x208); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Sm2_mulx_u32(x227, x228, (x209).get(), 0xfffffffe); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Sm2_mulx_u32(x229, x230, (x209).get(), 0xffffffff); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Sm2_mulx_u32(x231, x232, (x209).get(), 0xffffffff); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Sm2_mulx_u32(x233, x234, (x209).get(), 0xffffffff); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Sm2_mulx_u32(x235, x236, (x209).get(), 0xffffffff); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Sm2_mulx_u32(x237, x238, (x209).get(), 0xffffffff); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Sm2_mulx_u32(x239, x240, (x209).get(), 0xffffffff); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x241, x242, 0x0, (x240).get(), (x237).get()); + int x243 = ((x242).get() + (x238).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x244, x245, 0x0, (x236).get(), (x233).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x246, x247, (x245).get(), (x234).get(), (x231).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x248, x249, (x247).get(), (x232).get(), (x229).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x250, x251, (x249).get(), (x230).get(), (x227).get()); + int x252 = ((x251).get() + (x228).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x253, x254, 0x0, (x209).get(), (x239).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x255, x256, (x254).get(), (x211).get(), (x241).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x257, x258, (x256).get(), (x213).get(), x243); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x259, x260, (x258).get(), (x215).get(), (x235).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x261, x262, (x260).get(), (x217).get(), (x244).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x263, x264, (x262).get(), (x219).get(), (x246).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x265, x266, (x264).get(), (x221).get(), (x248).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x267, x268, (x266).get(), (x223).get(), (x250).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x269, x270, (x268).get(), (x225).get(), x252); + int x271 = ((x270).get() + (x226).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_Sm2_mulx_u32(x272, x273, x3, (arg2[7])); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Sm2_mulx_u32(x274, x275, x3, (arg2[6])); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Sm2_mulx_u32(x276, x277, x3, (arg2[5])); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Sm2_mulx_u32(x278, x279, x3, (arg2[4])); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Sm2_mulx_u32(x280, x281, x3, (arg2[3])); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Sm2_mulx_u32(x282, x283, x3, (arg2[2])); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Sm2_mulx_u32(x284, x285, x3, (arg2[1])); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Sm2_mulx_u32(x286, x287, x3, (arg2[0])); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x288, x289, 0x0, (x287).get(), (x284).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x290, x291, (x289).get(), (x285).get(), (x282).get()); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x292, x293, (x291).get(), (x283).get(), (x280).get()); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x294, x295, (x293).get(), (x281).get(), (x278).get()); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x296, x297, (x295).get(), (x279).get(), (x276).get()); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x298, x299, (x297).get(), (x277).get(), (x274).get()); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x300, x301, (x299).get(), (x275).get(), (x272).get()); + int x302 = ((x301).get() + (x273).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x303, x304, 0x0, (x255).get(), (x286).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x305, x306, (x304).get(), (x257).get(), (x288).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x307, x308, (x306).get(), (x259).get(), (x290).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x309, x310, (x308).get(), (x261).get(), (x292).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x311, x312, (x310).get(), (x263).get(), (x294).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x313, x314, (x312).get(), (x265).get(), (x296).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x315, x316, (x314).get(), (x267).get(), (x298).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x317, x318, (x316).get(), (x269).get(), (x300).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x319, x320, (x318).get(), x271, x302); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Sm2_mulx_u32(x321, x322, (x303).get(), 0xfffffffe); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Sm2_mulx_u32(x323, x324, (x303).get(), 0xffffffff); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Sm2_mulx_u32(x325, x326, (x303).get(), 0xffffffff); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Sm2_mulx_u32(x327, x328, (x303).get(), 0xffffffff); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Sm2_mulx_u32(x329, x330, (x303).get(), 0xffffffff); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Sm2_mulx_u32(x331, x332, (x303).get(), 0xffffffff); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Sm2_mulx_u32(x333, x334, (x303).get(), 0xffffffff); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x335, x336, 0x0, (x334).get(), (x331).get()); + int x337 = ((x336).get() + (x332).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x338, x339, 0x0, (x330).get(), (x327).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x340, x341, (x339).get(), (x328).get(), (x325).get()); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x342, x343, (x341).get(), (x326).get(), (x323).get()); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x344, x345, (x343).get(), (x324).get(), (x321).get()); + int x346 = ((x345).get() + (x322).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x347, x348, 0x0, (x303).get(), (x333).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x349, x350, (x348).get(), (x305).get(), (x335).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x351, x352, (x350).get(), (x307).get(), x337); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x353, x354, (x352).get(), (x309).get(), (x329).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x355, x356, (x354).get(), (x311).get(), (x338).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x357, x358, (x356).get(), (x313).get(), (x340).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x359, x360, (x358).get(), (x315).get(), (x342).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x361, x362, (x360).get(), (x317).get(), (x344).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x363, x364, (x362).get(), (x319).get(), x346); + int x365 = ((x364).get() + (x320).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Sm2_mulx_u32(x366, x367, x4, (arg2[7])); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Sm2_mulx_u32(x368, x369, x4, (arg2[6])); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Sm2_mulx_u32(x370, x371, x4, (arg2[5])); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Sm2_mulx_u32(x372, x373, x4, (arg2[4])); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_Sm2_mulx_u32(x374, x375, x4, (arg2[3])); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_Sm2_mulx_u32(x376, x377, x4, (arg2[2])); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_Sm2_mulx_u32(x378, x379, x4, (arg2[1])); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_Sm2_mulx_u32(x380, x381, x4, (arg2[0])); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x382, x383, 0x0, (x381).get(), (x378).get()); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x384, x385, (x383).get(), (x379).get(), (x376).get()); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x386, x387, (x385).get(), (x377).get(), (x374).get()); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x388, x389, (x387).get(), (x375).get(), (x372).get()); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x390, x391, (x389).get(), (x373).get(), (x370).get()); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x392, x393, (x391).get(), (x371).get(), (x368).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x394, x395, (x393).get(), (x369).get(), (x366).get()); + int x396 = ((x395).get() + (x367).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x397, x398, 0x0, (x349).get(), (x380).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x399, x400, (x398).get(), (x351).get(), (x382).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x401, x402, (x400).get(), (x353).get(), (x384).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x403, x404, (x402).get(), (x355).get(), (x386).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x405, x406, (x404).get(), (x357).get(), (x388).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x407, x408, (x406).get(), (x359).get(), (x390).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x409, x410, (x408).get(), (x361).get(), (x392).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x411, x412, (x410).get(), (x363).get(), (x394).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x413, x414, (x412).get(), x365, x396); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_Sm2_mulx_u32(x415, x416, (x397).get(), 0xfffffffe); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_Sm2_mulx_u32(x417, x418, (x397).get(), 0xffffffff); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_Sm2_mulx_u32(x419, x420, (x397).get(), 0xffffffff); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_Sm2_mulx_u32(x421, x422, (x397).get(), 0xffffffff); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_Sm2_mulx_u32(x423, x424, (x397).get(), 0xffffffff); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Sm2_mulx_u32(x425, x426, (x397).get(), 0xffffffff); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Sm2_mulx_u32(x427, x428, (x397).get(), 0xffffffff); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x429, x430, 0x0, (x428).get(), (x425).get()); + int x431 = ((x430).get() + (x426).get()); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x432, x433, 0x0, (x424).get(), (x421).get()); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x434, x435, (x433).get(), (x422).get(), (x419).get()); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x436, x437, (x435).get(), (x420).get(), (x417).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x438, x439, (x437).get(), (x418).get(), (x415).get()); + int x440 = ((x439).get() + (x416).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x441, x442, 0x0, (x397).get(), (x427).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x443, x444, (x442).get(), (x399).get(), (x429).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x445, x446, (x444).get(), (x401).get(), x431); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x447, x448, (x446).get(), (x403).get(), (x423).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x449, x450, (x448).get(), (x405).get(), (x432).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x451, x452, (x450).get(), (x407).get(), (x434).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x453, x454, (x452).get(), (x409).get(), (x436).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x455, x456, (x454).get(), (x411).get(), (x438).get()); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x457, x458, (x456).get(), (x413).get(), x440); + int x459 = ((x458).get() + (x414).get()); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_Sm2_mulx_u32(x460, x461, x5, (arg2[7])); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_Sm2_mulx_u32(x462, x463, x5, (arg2[6])); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Sm2_mulx_u32(x464, x465, x5, (arg2[5])); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_Sm2_mulx_u32(x466, x467, x5, (arg2[4])); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_Sm2_mulx_u32(x468, x469, x5, (arg2[3])); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_Sm2_mulx_u32(x470, x471, x5, (arg2[2])); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_Sm2_mulx_u32(x472, x473, x5, (arg2[1])); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_Sm2_mulx_u32(x474, x475, x5, (arg2[0])); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x476, x477, 0x0, (x475).get(), (x472).get()); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x478, x479, (x477).get(), (x473).get(), (x470).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x480, x481, (x479).get(), (x471).get(), (x468).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x482, x483, (x481).get(), (x469).get(), (x466).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x484, x485, (x483).get(), (x467).get(), (x464).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x486, x487, (x485).get(), (x465).get(), (x462).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x488, x489, (x487).get(), (x463).get(), (x460).get()); + int x490 = ((x489).get() + (x461).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x491, x492, 0x0, (x443).get(), (x474).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x493, x494, (x492).get(), (x445).get(), (x476).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x495, x496, (x494).get(), (x447).get(), (x478).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x497, x498, (x496).get(), (x449).get(), (x480).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x499, x500, (x498).get(), (x451).get(), (x482).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x501, x502, (x500).get(), (x453).get(), (x484).get()); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x503, x504, (x502).get(), (x455).get(), (x486).get()); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x505, x506, (x504).get(), (x457).get(), (x488).get()); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x507, x508, (x506).get(), x459, x490); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Sm2_mulx_u32(x509, x510, (x491).get(), 0xfffffffe); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Sm2_mulx_u32(x511, x512, (x491).get(), 0xffffffff); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Sm2_mulx_u32(x513, x514, (x491).get(), 0xffffffff); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Sm2_mulx_u32(x515, x516, (x491).get(), 0xffffffff); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Sm2_mulx_u32(x517, x518, (x491).get(), 0xffffffff); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Sm2_mulx_u32(x519, x520, (x491).get(), 0xffffffff); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Sm2_mulx_u32(x521, x522, (x491).get(), 0xffffffff); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x523, x524, 0x0, (x522).get(), (x519).get()); + int x525 = ((x524).get() + (x520).get()); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x526, x527, 0x0, (x518).get(), (x515).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x528, x529, (x527).get(), (x516).get(), (x513).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x530, x531, (x529).get(), (x514).get(), (x511).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x532, x533, (x531).get(), (x512).get(), (x509).get()); + int x534 = ((x533).get() + (x510).get()); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x535, x536, 0x0, (x491).get(), (x521).get()); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x537, x538, (x536).get(), (x493).get(), (x523).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x539, x540, (x538).get(), (x495).get(), x525); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x541, x542, (x540).get(), (x497).get(), (x517).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x543, x544, (x542).get(), (x499).get(), (x526).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x545, x546, (x544).get(), (x501).get(), (x528).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x547, x548, (x546).get(), (x503).get(), (x530).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x549, x550, (x548).get(), (x505).get(), (x532).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x551, x552, (x550).get(), (x507).get(), x534); + int x553 = ((x552).get() + (x508).get()); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_Sm2_mulx_u32(x554, x555, x6, (arg2[7])); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_Sm2_mulx_u32(x556, x557, x6, (arg2[6])); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_Sm2_mulx_u32(x558, x559, x6, (arg2[5])); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_Sm2_mulx_u32(x560, x561, x6, (arg2[4])); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_Sm2_mulx_u32(x562, x563, x6, (arg2[3])); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_Sm2_mulx_u32(x564, x565, x6, (arg2[2])); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_Sm2_mulx_u32(x566, x567, x6, (arg2[1])); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_Sm2_mulx_u32(x568, x569, x6, (arg2[0])); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x570, x571, 0x0, (x569).get(), (x566).get()); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x572, x573, (x571).get(), (x567).get(), (x564).get()); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x574, x575, (x573).get(), (x565).get(), (x562).get()); + Box x576 = new Box((int)0); + Box x577 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x576, x577, (x575).get(), (x563).get(), (x560).get()); + Box x578 = new Box((int)0); + Box x579 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x578, x579, (x577).get(), (x561).get(), (x558).get()); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x580, x581, (x579).get(), (x559).get(), (x556).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x582, x583, (x581).get(), (x557).get(), (x554).get()); + int x584 = ((x583).get() + (x555).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x585, x586, 0x0, (x537).get(), (x568).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x587, x588, (x586).get(), (x539).get(), (x570).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x589, x590, (x588).get(), (x541).get(), (x572).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x591, x592, (x590).get(), (x543).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x593, x594, (x592).get(), (x545).get(), (x576).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x595, x596, (x594).get(), (x547).get(), (x578).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x597, x598, (x596).get(), (x549).get(), (x580).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x599, x600, (x598).get(), (x551).get(), (x582).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x601, x602, (x600).get(), x553, x584); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Sm2_mulx_u32(x603, x604, (x585).get(), 0xfffffffe); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Sm2_mulx_u32(x605, x606, (x585).get(), 0xffffffff); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Sm2_mulx_u32(x607, x608, (x585).get(), 0xffffffff); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Sm2_mulx_u32(x609, x610, (x585).get(), 0xffffffff); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Sm2_mulx_u32(x611, x612, (x585).get(), 0xffffffff); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Sm2_mulx_u32(x613, x614, (x585).get(), 0xffffffff); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Sm2_mulx_u32(x615, x616, (x585).get(), 0xffffffff); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x617, x618, 0x0, (x616).get(), (x613).get()); + int x619 = ((x618).get() + (x614).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x620, x621, 0x0, (x612).get(), (x609).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x622, x623, (x621).get(), (x610).get(), (x607).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x624, x625, (x623).get(), (x608).get(), (x605).get()); + Box x626 = new Box((int)0); + Box x627 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x626, x627, (x625).get(), (x606).get(), (x603).get()); + int x628 = ((x627).get() + (x604).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x629, x630, 0x0, (x585).get(), (x615).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x631, x632, (x630).get(), (x587).get(), (x617).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x633, x634, (x632).get(), (x589).get(), x619); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x635, x636, (x634).get(), (x591).get(), (x611).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x637, x638, (x636).get(), (x593).get(), (x620).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x639, x640, (x638).get(), (x595).get(), (x622).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x641, x642, (x640).get(), (x597).get(), (x624).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x643, x644, (x642).get(), (x599).get(), (x626).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x645, x646, (x644).get(), (x601).get(), x628); + int x647 = ((x646).get() + (x602).get()); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_Sm2_mulx_u32(x648, x649, x7, (arg2[7])); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_Sm2_mulx_u32(x650, x651, x7, (arg2[6])); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_Sm2_mulx_u32(x652, x653, x7, (arg2[5])); + Box x654 = new Box((int)0); + Box x655 = new Box((int)0); + fiat_Sm2_mulx_u32(x654, x655, x7, (arg2[4])); + Box x656 = new Box((int)0); + Box x657 = new Box((int)0); + fiat_Sm2_mulx_u32(x656, x657, x7, (arg2[3])); + Box x658 = new Box((int)0); + Box x659 = new Box((int)0); + fiat_Sm2_mulx_u32(x658, x659, x7, (arg2[2])); + Box x660 = new Box((int)0); + Box x661 = new Box((int)0); + fiat_Sm2_mulx_u32(x660, x661, x7, (arg2[1])); + Box x662 = new Box((int)0); + Box x663 = new Box((int)0); + fiat_Sm2_mulx_u32(x662, x663, x7, (arg2[0])); + Box x664 = new Box((int)0); + Box x665 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x664, x665, 0x0, (x663).get(), (x660).get()); + Box x666 = new Box((int)0); + Box x667 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x666, x667, (x665).get(), (x661).get(), (x658).get()); + Box x668 = new Box((int)0); + Box x669 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x668, x669, (x667).get(), (x659).get(), (x656).get()); + Box x670 = new Box((int)0); + Box x671 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x670, x671, (x669).get(), (x657).get(), (x654).get()); + Box x672 = new Box((int)0); + Box x673 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x672, x673, (x671).get(), (x655).get(), (x652).get()); + Box x674 = new Box((int)0); + Box x675 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x674, x675, (x673).get(), (x653).get(), (x650).get()); + Box x676 = new Box((int)0); + Box x677 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x676, x677, (x675).get(), (x651).get(), (x648).get()); + int x678 = ((x677).get() + (x649).get()); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x679, x680, 0x0, (x631).get(), (x662).get()); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x681, x682, (x680).get(), (x633).get(), (x664).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x683, x684, (x682).get(), (x635).get(), (x666).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x685, x686, (x684).get(), (x637).get(), (x668).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x687, x688, (x686).get(), (x639).get(), (x670).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x689, x690, (x688).get(), (x641).get(), (x672).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x691, x692, (x690).get(), (x643).get(), (x674).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x693, x694, (x692).get(), (x645).get(), (x676).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x695, x696, (x694).get(), x647, x678); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_Sm2_mulx_u32(x697, x698, (x679).get(), 0xfffffffe); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Sm2_mulx_u32(x699, x700, (x679).get(), 0xffffffff); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Sm2_mulx_u32(x701, x702, (x679).get(), 0xffffffff); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Sm2_mulx_u32(x703, x704, (x679).get(), 0xffffffff); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Sm2_mulx_u32(x705, x706, (x679).get(), 0xffffffff); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Sm2_mulx_u32(x707, x708, (x679).get(), 0xffffffff); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Sm2_mulx_u32(x709, x710, (x679).get(), 0xffffffff); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x711, x712, 0x0, (x710).get(), (x707).get()); + int x713 = ((x712).get() + (x708).get()); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x714, x715, 0x0, (x706).get(), (x703).get()); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x716, x717, (x715).get(), (x704).get(), (x701).get()); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x718, x719, (x717).get(), (x702).get(), (x699).get()); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x720, x721, (x719).get(), (x700).get(), (x697).get()); + int x722 = ((x721).get() + (x698).get()); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x723, x724, 0x0, (x679).get(), (x709).get()); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x725, x726, (x724).get(), (x681).get(), (x711).get()); + Box x727 = new Box((int)0); + Box x728 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x727, x728, (x726).get(), (x683).get(), x713); + Box x729 = new Box((int)0); + Box x730 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x729, x730, (x728).get(), (x685).get(), (x705).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x731, x732, (x730).get(), (x687).get(), (x714).get()); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x733, x734, (x732).get(), (x689).get(), (x716).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x735, x736, (x734).get(), (x691).get(), (x718).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x737, x738, (x736).get(), (x693).get(), (x720).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x739, x740, (x738).get(), (x695).get(), x722); + int x741 = ((x740).get() + (x696).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x742, x743, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x725).get(), 0xffffffff); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x744, x745, (x743).get(), (x727).get(), 0xffffffff); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x746, x747, (x745).get(), (x729).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x748, x749, (x747).get(), (x731).get(), 0xffffffff); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x750, x751, (x749).get(), (x733).get(), 0xffffffff); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x752, x753, (x751).get(), (x735).get(), 0xffffffff); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x754, x755, (x753).get(), (x737).get(), 0xffffffff); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x756, x757, (x755).get(), (x739).get(), 0xfffffffe); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x758, x759, (x757).get(), x741, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x760 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x760, (x759).get(), (x742).get(), (x725).get()); + Box x761 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x761, (x759).get(), (x744).get(), (x727).get()); + Box x762 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x762, (x759).get(), (x746).get(), (x729).get()); + Box x763 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x763, (x759).get(), (x748).get(), (x731).get()); + Box x764 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x764, (x759).get(), (x750).get(), (x733).get()); + Box x765 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x765, (x759).get(), (x752).get(), (x735).get()); + Box x766 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x766, (x759).get(), (x754).get(), (x737).get()); + Box x767 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x767, (x759).get(), (x756).get(), (x739).get()); + out1[0] = (x760).get(); + out1[1] = (x761).get(); + out1[2] = (x762).get(); + out1[3] = (x763).get(); + out1[4] = (x764).get(); + out1[5] = (x765).get(); + out1[6] = (x766).get(); + out1[7] = (x767).get(); +} + +/** + * The function fiat_Sm2_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_Sm2_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_Sm2_mulx_u32(x9, x10, x8, (arg1[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2_mulx_u32(x11, x12, x8, (arg1[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2_mulx_u32(x13, x14, x8, (arg1[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2_mulx_u32(x15, x16, x8, (arg1[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2_mulx_u32(x17, x18, x8, (arg1[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2_mulx_u32(x19, x20, x8, (arg1[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2_mulx_u32(x21, x22, x8, (arg1[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2_mulx_u32(x23, x24, x8, (arg1[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Sm2_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_Sm2_mulx_u32(x40, x41, (x23).get(), 0xfffffffe); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Sm2_mulx_u32(x42, x43, (x23).get(), 0xffffffff); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Sm2_mulx_u32(x44, x45, (x23).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Sm2_mulx_u32(x46, x47, (x23).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Sm2_mulx_u32(x48, x49, (x23).get(), 0xffffffff); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Sm2_mulx_u32(x50, x51, (x23).get(), 0xffffffff); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Sm2_mulx_u32(x52, x53, (x23).get(), 0xffffffff); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x54, x55, 0x0, (x53).get(), (x50).get()); + int x56 = ((x55).get() + (x51).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x57, x58, 0x0, (x49).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x44).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x61, x62, (x60).get(), (x45).get(), (x42).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x63, x64, (x62).get(), (x43).get(), (x40).get()); + int x65 = ((x64).get() + (x41).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x66, x67, 0x0, (x23).get(), (x52).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x68, x69, (x67).get(), (x25).get(), (x54).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x70, x71, (x69).get(), (x27).get(), x56); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x72, x73, (x71).get(), (x29).get(), (x48).get()); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x74, x75, (x73).get(), (x31).get(), (x57).get()); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x76, x77, (x75).get(), (x33).get(), (x59).get()); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x78, x79, (x77).get(), (x35).get(), (x61).get()); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x80, x81, (x79).get(), (x37).get(), (x63).get()); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x82, x83, (x81).get(), x39, x65); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_Sm2_mulx_u32(x84, x85, x1, (arg1[7])); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_Sm2_mulx_u32(x86, x87, x1, (arg1[6])); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_Sm2_mulx_u32(x88, x89, x1, (arg1[5])); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_Sm2_mulx_u32(x90, x91, x1, (arg1[4])); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_Sm2_mulx_u32(x92, x93, x1, (arg1[3])); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_Sm2_mulx_u32(x94, x95, x1, (arg1[2])); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_Sm2_mulx_u32(x96, x97, x1, (arg1[1])); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_Sm2_mulx_u32(x98, x99, x1, (arg1[0])); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x100, x101, 0x0, (x99).get(), (x96).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x102, x103, (x101).get(), (x97).get(), (x94).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x104, x105, (x103).get(), (x95).get(), (x92).get()); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x106, x107, (x105).get(), (x93).get(), (x90).get()); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x108, x109, (x107).get(), (x91).get(), (x88).get()); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x110, x111, (x109).get(), (x89).get(), (x86).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x112, x113, (x111).get(), (x87).get(), (x84).get()); + int x114 = ((x113).get() + (x85).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x115, x116, 0x0, (x68).get(), (x98).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x117, x118, (x116).get(), (x70).get(), (x100).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x119, x120, (x118).get(), (x72).get(), (x102).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x121, x122, (x120).get(), (x74).get(), (x104).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x123, x124, (x122).get(), (x76).get(), (x106).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x125, x126, (x124).get(), (x78).get(), (x108).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x127, x128, (x126).get(), (x80).get(), (x110).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x129, x130, (x128).get(), (x82).get(), (x112).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x131, x132, (x130).get(), (x83).get(), x114); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_Sm2_mulx_u32(x133, x134, (x115).get(), 0xfffffffe); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_Sm2_mulx_u32(x135, x136, (x115).get(), 0xffffffff); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_Sm2_mulx_u32(x137, x138, (x115).get(), 0xffffffff); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_Sm2_mulx_u32(x139, x140, (x115).get(), 0xffffffff); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_Sm2_mulx_u32(x141, x142, (x115).get(), 0xffffffff); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_Sm2_mulx_u32(x143, x144, (x115).get(), 0xffffffff); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Sm2_mulx_u32(x145, x146, (x115).get(), 0xffffffff); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x147, x148, 0x0, (x146).get(), (x143).get()); + int x149 = ((x148).get() + (x144).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x150, x151, 0x0, (x142).get(), (x139).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x152, x153, (x151).get(), (x140).get(), (x137).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x154, x155, (x153).get(), (x138).get(), (x135).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x156, x157, (x155).get(), (x136).get(), (x133).get()); + int x158 = ((x157).get() + (x134).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x159, x160, 0x0, (x115).get(), (x145).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x161, x162, (x160).get(), (x117).get(), (x147).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x163, x164, (x162).get(), (x119).get(), x149); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x165, x166, (x164).get(), (x121).get(), (x141).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x167, x168, (x166).get(), (x123).get(), (x150).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x169, x170, (x168).get(), (x125).get(), (x152).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x171, x172, (x170).get(), (x127).get(), (x154).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x173, x174, (x172).get(), (x129).get(), (x156).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x175, x176, (x174).get(), (x131).get(), x158); + int x177 = ((x176).get() + (x132).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Sm2_mulx_u32(x178, x179, x2, (arg1[7])); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Sm2_mulx_u32(x180, x181, x2, (arg1[6])); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Sm2_mulx_u32(x182, x183, x2, (arg1[5])); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Sm2_mulx_u32(x184, x185, x2, (arg1[4])); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Sm2_mulx_u32(x186, x187, x2, (arg1[3])); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Sm2_mulx_u32(x188, x189, x2, (arg1[2])); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Sm2_mulx_u32(x190, x191, x2, (arg1[1])); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Sm2_mulx_u32(x192, x193, x2, (arg1[0])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x194, x195, 0x0, (x193).get(), (x190).get()); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x196, x197, (x195).get(), (x191).get(), (x188).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x198, x199, (x197).get(), (x189).get(), (x186).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x200, x201, (x199).get(), (x187).get(), (x184).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x202, x203, (x201).get(), (x185).get(), (x182).get()); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x204, x205, (x203).get(), (x183).get(), (x180).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x206, x207, (x205).get(), (x181).get(), (x178).get()); + int x208 = ((x207).get() + (x179).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x209, x210, 0x0, (x161).get(), (x192).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x211, x212, (x210).get(), (x163).get(), (x194).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x213, x214, (x212).get(), (x165).get(), (x196).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x215, x216, (x214).get(), (x167).get(), (x198).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x217, x218, (x216).get(), (x169).get(), (x200).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x219, x220, (x218).get(), (x171).get(), (x202).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x221, x222, (x220).get(), (x173).get(), (x204).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x223, x224, (x222).get(), (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x225, x226, (x224).get(), x177, x208); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Sm2_mulx_u32(x227, x228, (x209).get(), 0xfffffffe); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Sm2_mulx_u32(x229, x230, (x209).get(), 0xffffffff); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Sm2_mulx_u32(x231, x232, (x209).get(), 0xffffffff); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Sm2_mulx_u32(x233, x234, (x209).get(), 0xffffffff); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Sm2_mulx_u32(x235, x236, (x209).get(), 0xffffffff); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Sm2_mulx_u32(x237, x238, (x209).get(), 0xffffffff); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Sm2_mulx_u32(x239, x240, (x209).get(), 0xffffffff); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x241, x242, 0x0, (x240).get(), (x237).get()); + int x243 = ((x242).get() + (x238).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x244, x245, 0x0, (x236).get(), (x233).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x246, x247, (x245).get(), (x234).get(), (x231).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x248, x249, (x247).get(), (x232).get(), (x229).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x250, x251, (x249).get(), (x230).get(), (x227).get()); + int x252 = ((x251).get() + (x228).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x253, x254, 0x0, (x209).get(), (x239).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x255, x256, (x254).get(), (x211).get(), (x241).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x257, x258, (x256).get(), (x213).get(), x243); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x259, x260, (x258).get(), (x215).get(), (x235).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x261, x262, (x260).get(), (x217).get(), (x244).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x263, x264, (x262).get(), (x219).get(), (x246).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x265, x266, (x264).get(), (x221).get(), (x248).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x267, x268, (x266).get(), (x223).get(), (x250).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x269, x270, (x268).get(), (x225).get(), x252); + int x271 = ((x270).get() + (x226).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_Sm2_mulx_u32(x272, x273, x3, (arg1[7])); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Sm2_mulx_u32(x274, x275, x3, (arg1[6])); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Sm2_mulx_u32(x276, x277, x3, (arg1[5])); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Sm2_mulx_u32(x278, x279, x3, (arg1[4])); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Sm2_mulx_u32(x280, x281, x3, (arg1[3])); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Sm2_mulx_u32(x282, x283, x3, (arg1[2])); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Sm2_mulx_u32(x284, x285, x3, (arg1[1])); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Sm2_mulx_u32(x286, x287, x3, (arg1[0])); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x288, x289, 0x0, (x287).get(), (x284).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x290, x291, (x289).get(), (x285).get(), (x282).get()); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x292, x293, (x291).get(), (x283).get(), (x280).get()); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x294, x295, (x293).get(), (x281).get(), (x278).get()); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x296, x297, (x295).get(), (x279).get(), (x276).get()); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x298, x299, (x297).get(), (x277).get(), (x274).get()); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x300, x301, (x299).get(), (x275).get(), (x272).get()); + int x302 = ((x301).get() + (x273).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x303, x304, 0x0, (x255).get(), (x286).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x305, x306, (x304).get(), (x257).get(), (x288).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x307, x308, (x306).get(), (x259).get(), (x290).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x309, x310, (x308).get(), (x261).get(), (x292).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x311, x312, (x310).get(), (x263).get(), (x294).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x313, x314, (x312).get(), (x265).get(), (x296).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x315, x316, (x314).get(), (x267).get(), (x298).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x317, x318, (x316).get(), (x269).get(), (x300).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x319, x320, (x318).get(), x271, x302); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Sm2_mulx_u32(x321, x322, (x303).get(), 0xfffffffe); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Sm2_mulx_u32(x323, x324, (x303).get(), 0xffffffff); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Sm2_mulx_u32(x325, x326, (x303).get(), 0xffffffff); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Sm2_mulx_u32(x327, x328, (x303).get(), 0xffffffff); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Sm2_mulx_u32(x329, x330, (x303).get(), 0xffffffff); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Sm2_mulx_u32(x331, x332, (x303).get(), 0xffffffff); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Sm2_mulx_u32(x333, x334, (x303).get(), 0xffffffff); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x335, x336, 0x0, (x334).get(), (x331).get()); + int x337 = ((x336).get() + (x332).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x338, x339, 0x0, (x330).get(), (x327).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x340, x341, (x339).get(), (x328).get(), (x325).get()); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x342, x343, (x341).get(), (x326).get(), (x323).get()); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x344, x345, (x343).get(), (x324).get(), (x321).get()); + int x346 = ((x345).get() + (x322).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x347, x348, 0x0, (x303).get(), (x333).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x349, x350, (x348).get(), (x305).get(), (x335).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x351, x352, (x350).get(), (x307).get(), x337); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x353, x354, (x352).get(), (x309).get(), (x329).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x355, x356, (x354).get(), (x311).get(), (x338).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x357, x358, (x356).get(), (x313).get(), (x340).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x359, x360, (x358).get(), (x315).get(), (x342).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x361, x362, (x360).get(), (x317).get(), (x344).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x363, x364, (x362).get(), (x319).get(), x346); + int x365 = ((x364).get() + (x320).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Sm2_mulx_u32(x366, x367, x4, (arg1[7])); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Sm2_mulx_u32(x368, x369, x4, (arg1[6])); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Sm2_mulx_u32(x370, x371, x4, (arg1[5])); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Sm2_mulx_u32(x372, x373, x4, (arg1[4])); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_Sm2_mulx_u32(x374, x375, x4, (arg1[3])); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_Sm2_mulx_u32(x376, x377, x4, (arg1[2])); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_Sm2_mulx_u32(x378, x379, x4, (arg1[1])); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_Sm2_mulx_u32(x380, x381, x4, (arg1[0])); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x382, x383, 0x0, (x381).get(), (x378).get()); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x384, x385, (x383).get(), (x379).get(), (x376).get()); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x386, x387, (x385).get(), (x377).get(), (x374).get()); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x388, x389, (x387).get(), (x375).get(), (x372).get()); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x390, x391, (x389).get(), (x373).get(), (x370).get()); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x392, x393, (x391).get(), (x371).get(), (x368).get()); + Box x394 = new Box((int)0); + Box x395 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x394, x395, (x393).get(), (x369).get(), (x366).get()); + int x396 = ((x395).get() + (x367).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x397, x398, 0x0, (x349).get(), (x380).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x399, x400, (x398).get(), (x351).get(), (x382).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x401, x402, (x400).get(), (x353).get(), (x384).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x403, x404, (x402).get(), (x355).get(), (x386).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x405, x406, (x404).get(), (x357).get(), (x388).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x407, x408, (x406).get(), (x359).get(), (x390).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x409, x410, (x408).get(), (x361).get(), (x392).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x411, x412, (x410).get(), (x363).get(), (x394).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x413, x414, (x412).get(), x365, x396); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_Sm2_mulx_u32(x415, x416, (x397).get(), 0xfffffffe); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_Sm2_mulx_u32(x417, x418, (x397).get(), 0xffffffff); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_Sm2_mulx_u32(x419, x420, (x397).get(), 0xffffffff); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_Sm2_mulx_u32(x421, x422, (x397).get(), 0xffffffff); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_Sm2_mulx_u32(x423, x424, (x397).get(), 0xffffffff); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Sm2_mulx_u32(x425, x426, (x397).get(), 0xffffffff); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Sm2_mulx_u32(x427, x428, (x397).get(), 0xffffffff); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x429, x430, 0x0, (x428).get(), (x425).get()); + int x431 = ((x430).get() + (x426).get()); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x432, x433, 0x0, (x424).get(), (x421).get()); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x434, x435, (x433).get(), (x422).get(), (x419).get()); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x436, x437, (x435).get(), (x420).get(), (x417).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x438, x439, (x437).get(), (x418).get(), (x415).get()); + int x440 = ((x439).get() + (x416).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x441, x442, 0x0, (x397).get(), (x427).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x443, x444, (x442).get(), (x399).get(), (x429).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x445, x446, (x444).get(), (x401).get(), x431); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x447, x448, (x446).get(), (x403).get(), (x423).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x449, x450, (x448).get(), (x405).get(), (x432).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x451, x452, (x450).get(), (x407).get(), (x434).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x453, x454, (x452).get(), (x409).get(), (x436).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x455, x456, (x454).get(), (x411).get(), (x438).get()); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x457, x458, (x456).get(), (x413).get(), x440); + int x459 = ((x458).get() + (x414).get()); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_Sm2_mulx_u32(x460, x461, x5, (arg1[7])); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_Sm2_mulx_u32(x462, x463, x5, (arg1[6])); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Sm2_mulx_u32(x464, x465, x5, (arg1[5])); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_Sm2_mulx_u32(x466, x467, x5, (arg1[4])); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_Sm2_mulx_u32(x468, x469, x5, (arg1[3])); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_Sm2_mulx_u32(x470, x471, x5, (arg1[2])); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_Sm2_mulx_u32(x472, x473, x5, (arg1[1])); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_Sm2_mulx_u32(x474, x475, x5, (arg1[0])); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x476, x477, 0x0, (x475).get(), (x472).get()); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x478, x479, (x477).get(), (x473).get(), (x470).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x480, x481, (x479).get(), (x471).get(), (x468).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x482, x483, (x481).get(), (x469).get(), (x466).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x484, x485, (x483).get(), (x467).get(), (x464).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x486, x487, (x485).get(), (x465).get(), (x462).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x488, x489, (x487).get(), (x463).get(), (x460).get()); + int x490 = ((x489).get() + (x461).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x491, x492, 0x0, (x443).get(), (x474).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x493, x494, (x492).get(), (x445).get(), (x476).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x495, x496, (x494).get(), (x447).get(), (x478).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x497, x498, (x496).get(), (x449).get(), (x480).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x499, x500, (x498).get(), (x451).get(), (x482).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x501, x502, (x500).get(), (x453).get(), (x484).get()); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x503, x504, (x502).get(), (x455).get(), (x486).get()); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x505, x506, (x504).get(), (x457).get(), (x488).get()); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x507, x508, (x506).get(), x459, x490); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Sm2_mulx_u32(x509, x510, (x491).get(), 0xfffffffe); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Sm2_mulx_u32(x511, x512, (x491).get(), 0xffffffff); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Sm2_mulx_u32(x513, x514, (x491).get(), 0xffffffff); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Sm2_mulx_u32(x515, x516, (x491).get(), 0xffffffff); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Sm2_mulx_u32(x517, x518, (x491).get(), 0xffffffff); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Sm2_mulx_u32(x519, x520, (x491).get(), 0xffffffff); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Sm2_mulx_u32(x521, x522, (x491).get(), 0xffffffff); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x523, x524, 0x0, (x522).get(), (x519).get()); + int x525 = ((x524).get() + (x520).get()); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x526, x527, 0x0, (x518).get(), (x515).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x528, x529, (x527).get(), (x516).get(), (x513).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x530, x531, (x529).get(), (x514).get(), (x511).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x532, x533, (x531).get(), (x512).get(), (x509).get()); + int x534 = ((x533).get() + (x510).get()); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x535, x536, 0x0, (x491).get(), (x521).get()); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x537, x538, (x536).get(), (x493).get(), (x523).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x539, x540, (x538).get(), (x495).get(), x525); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x541, x542, (x540).get(), (x497).get(), (x517).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x543, x544, (x542).get(), (x499).get(), (x526).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x545, x546, (x544).get(), (x501).get(), (x528).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x547, x548, (x546).get(), (x503).get(), (x530).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x549, x550, (x548).get(), (x505).get(), (x532).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x551, x552, (x550).get(), (x507).get(), x534); + int x553 = ((x552).get() + (x508).get()); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_Sm2_mulx_u32(x554, x555, x6, (arg1[7])); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_Sm2_mulx_u32(x556, x557, x6, (arg1[6])); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_Sm2_mulx_u32(x558, x559, x6, (arg1[5])); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_Sm2_mulx_u32(x560, x561, x6, (arg1[4])); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_Sm2_mulx_u32(x562, x563, x6, (arg1[3])); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_Sm2_mulx_u32(x564, x565, x6, (arg1[2])); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_Sm2_mulx_u32(x566, x567, x6, (arg1[1])); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_Sm2_mulx_u32(x568, x569, x6, (arg1[0])); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x570, x571, 0x0, (x569).get(), (x566).get()); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x572, x573, (x571).get(), (x567).get(), (x564).get()); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x574, x575, (x573).get(), (x565).get(), (x562).get()); + Box x576 = new Box((int)0); + Box x577 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x576, x577, (x575).get(), (x563).get(), (x560).get()); + Box x578 = new Box((int)0); + Box x579 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x578, x579, (x577).get(), (x561).get(), (x558).get()); + Box x580 = new Box((int)0); + Box x581 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x580, x581, (x579).get(), (x559).get(), (x556).get()); + Box x582 = new Box((int)0); + Box x583 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x582, x583, (x581).get(), (x557).get(), (x554).get()); + int x584 = ((x583).get() + (x555).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x585, x586, 0x0, (x537).get(), (x568).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x587, x588, (x586).get(), (x539).get(), (x570).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x589, x590, (x588).get(), (x541).get(), (x572).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x591, x592, (x590).get(), (x543).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x593, x594, (x592).get(), (x545).get(), (x576).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x595, x596, (x594).get(), (x547).get(), (x578).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x597, x598, (x596).get(), (x549).get(), (x580).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x599, x600, (x598).get(), (x551).get(), (x582).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x601, x602, (x600).get(), x553, x584); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Sm2_mulx_u32(x603, x604, (x585).get(), 0xfffffffe); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Sm2_mulx_u32(x605, x606, (x585).get(), 0xffffffff); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Sm2_mulx_u32(x607, x608, (x585).get(), 0xffffffff); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Sm2_mulx_u32(x609, x610, (x585).get(), 0xffffffff); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Sm2_mulx_u32(x611, x612, (x585).get(), 0xffffffff); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Sm2_mulx_u32(x613, x614, (x585).get(), 0xffffffff); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Sm2_mulx_u32(x615, x616, (x585).get(), 0xffffffff); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x617, x618, 0x0, (x616).get(), (x613).get()); + int x619 = ((x618).get() + (x614).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x620, x621, 0x0, (x612).get(), (x609).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x622, x623, (x621).get(), (x610).get(), (x607).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x624, x625, (x623).get(), (x608).get(), (x605).get()); + Box x626 = new Box((int)0); + Box x627 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x626, x627, (x625).get(), (x606).get(), (x603).get()); + int x628 = ((x627).get() + (x604).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x629, x630, 0x0, (x585).get(), (x615).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x631, x632, (x630).get(), (x587).get(), (x617).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x633, x634, (x632).get(), (x589).get(), x619); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x635, x636, (x634).get(), (x591).get(), (x611).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x637, x638, (x636).get(), (x593).get(), (x620).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x639, x640, (x638).get(), (x595).get(), (x622).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x641, x642, (x640).get(), (x597).get(), (x624).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x643, x644, (x642).get(), (x599).get(), (x626).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x645, x646, (x644).get(), (x601).get(), x628); + int x647 = ((x646).get() + (x602).get()); + Box x648 = new Box((int)0); + Box x649 = new Box((int)0); + fiat_Sm2_mulx_u32(x648, x649, x7, (arg1[7])); + Box x650 = new Box((int)0); + Box x651 = new Box((int)0); + fiat_Sm2_mulx_u32(x650, x651, x7, (arg1[6])); + Box x652 = new Box((int)0); + Box x653 = new Box((int)0); + fiat_Sm2_mulx_u32(x652, x653, x7, (arg1[5])); + Box x654 = new Box((int)0); + Box x655 = new Box((int)0); + fiat_Sm2_mulx_u32(x654, x655, x7, (arg1[4])); + Box x656 = new Box((int)0); + Box x657 = new Box((int)0); + fiat_Sm2_mulx_u32(x656, x657, x7, (arg1[3])); + Box x658 = new Box((int)0); + Box x659 = new Box((int)0); + fiat_Sm2_mulx_u32(x658, x659, x7, (arg1[2])); + Box x660 = new Box((int)0); + Box x661 = new Box((int)0); + fiat_Sm2_mulx_u32(x660, x661, x7, (arg1[1])); + Box x662 = new Box((int)0); + Box x663 = new Box((int)0); + fiat_Sm2_mulx_u32(x662, x663, x7, (arg1[0])); + Box x664 = new Box((int)0); + Box x665 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x664, x665, 0x0, (x663).get(), (x660).get()); + Box x666 = new Box((int)0); + Box x667 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x666, x667, (x665).get(), (x661).get(), (x658).get()); + Box x668 = new Box((int)0); + Box x669 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x668, x669, (x667).get(), (x659).get(), (x656).get()); + Box x670 = new Box((int)0); + Box x671 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x670, x671, (x669).get(), (x657).get(), (x654).get()); + Box x672 = new Box((int)0); + Box x673 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x672, x673, (x671).get(), (x655).get(), (x652).get()); + Box x674 = new Box((int)0); + Box x675 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x674, x675, (x673).get(), (x653).get(), (x650).get()); + Box x676 = new Box((int)0); + Box x677 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x676, x677, (x675).get(), (x651).get(), (x648).get()); + int x678 = ((x677).get() + (x649).get()); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x679, x680, 0x0, (x631).get(), (x662).get()); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x681, x682, (x680).get(), (x633).get(), (x664).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x683, x684, (x682).get(), (x635).get(), (x666).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x685, x686, (x684).get(), (x637).get(), (x668).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x687, x688, (x686).get(), (x639).get(), (x670).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x689, x690, (x688).get(), (x641).get(), (x672).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x691, x692, (x690).get(), (x643).get(), (x674).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x693, x694, (x692).get(), (x645).get(), (x676).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x695, x696, (x694).get(), x647, x678); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_Sm2_mulx_u32(x697, x698, (x679).get(), 0xfffffffe); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Sm2_mulx_u32(x699, x700, (x679).get(), 0xffffffff); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Sm2_mulx_u32(x701, x702, (x679).get(), 0xffffffff); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Sm2_mulx_u32(x703, x704, (x679).get(), 0xffffffff); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Sm2_mulx_u32(x705, x706, (x679).get(), 0xffffffff); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Sm2_mulx_u32(x707, x708, (x679).get(), 0xffffffff); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Sm2_mulx_u32(x709, x710, (x679).get(), 0xffffffff); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x711, x712, 0x0, (x710).get(), (x707).get()); + int x713 = ((x712).get() + (x708).get()); + Box x714 = new Box((int)0); + Box x715 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x714, x715, 0x0, (x706).get(), (x703).get()); + Box x716 = new Box((int)0); + Box x717 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x716, x717, (x715).get(), (x704).get(), (x701).get()); + Box x718 = new Box((int)0); + Box x719 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x718, x719, (x717).get(), (x702).get(), (x699).get()); + Box x720 = new Box((int)0); + Box x721 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x720, x721, (x719).get(), (x700).get(), (x697).get()); + int x722 = ((x721).get() + (x698).get()); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x723, x724, 0x0, (x679).get(), (x709).get()); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x725, x726, (x724).get(), (x681).get(), (x711).get()); + Box x727 = new Box((int)0); + Box x728 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x727, x728, (x726).get(), (x683).get(), x713); + Box x729 = new Box((int)0); + Box x730 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x729, x730, (x728).get(), (x685).get(), (x705).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x731, x732, (x730).get(), (x687).get(), (x714).get()); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x733, x734, (x732).get(), (x689).get(), (x716).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x735, x736, (x734).get(), (x691).get(), (x718).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x737, x738, (x736).get(), (x693).get(), (x720).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x739, x740, (x738).get(), (x695).get(), x722); + int x741 = ((x740).get() + (x696).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x742, x743, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x725).get(), 0xffffffff); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x744, x745, (x743).get(), (x727).get(), 0xffffffff); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x746, x747, (x745).get(), (x729).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x748, x749, (x747).get(), (x731).get(), 0xffffffff); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x750, x751, (x749).get(), (x733).get(), 0xffffffff); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x752, x753, (x751).get(), (x735).get(), 0xffffffff); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x754, x755, (x753).get(), (x737).get(), 0xffffffff); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x756, x757, (x755).get(), (x739).get(), 0xfffffffe); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x758, x759, (x757).get(), x741, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x760 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x760, (x759).get(), (x742).get(), (x725).get()); + Box x761 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x761, (x759).get(), (x744).get(), (x727).get()); + Box x762 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x762, (x759).get(), (x746).get(), (x729).get()); + Box x763 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x763, (x759).get(), (x748).get(), (x731).get()); + Box x764 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x764, (x759).get(), (x750).get(), (x733).get()); + Box x765 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x765, (x759).get(), (x752).get(), (x735).get()); + Box x766 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x766, (x759).get(), (x754).get(), (x737).get()); + Box x767 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x767, (x759).get(), (x756).get(), (x739).get()); + out1[0] = (x760).get(); + out1[1] = (x761).get(); + out1[2] = (x762).get(); + out1[3] = (x763).get(); + out1[4] = (x764).get(); + out1[5] = (x765).get(); + out1[6] = (x766).get(); + out1[7] = (x767).get(); +} + +/** + * The function fiat_Sm2_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_Sm2_add(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x17, x18, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1).get(), 0xffffffff); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x19, x20, (x18).get(), (x3).get(), 0xffffffff); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x21, x22, (x20).get(), (x5).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x23, x24, (x22).get(), (x7).get(), 0xffffffff); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x25, x26, (x24).get(), (x9).get(), 0xffffffff); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x27, x28, (x26).get(), (x11).get(), 0xffffffff); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x29, x30, (x28).get(), (x13).get(), 0xffffffff); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x31, x32, (x30).get(), (x15).get(), 0xfffffffe); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x33, x34, (x32).get(), (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x35 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x35, (x34).get(), (x17).get(), (x1).get()); + Box x36 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x36, (x34).get(), (x19).get(), (x3).get()); + Box x37 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x37, (x34).get(), (x21).get(), (x5).get()); + Box x38 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x38, (x34).get(), (x23).get(), (x7).get()); + Box x39 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x39, (x34).get(), (x25).get(), (x9).get()); + Box x40 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x40, (x34).get(), (x27).get(), (x11).get()); + Box x41 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x41, (x34).get(), (x29).get(), (x13).get()); + Box x42 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_sub(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + fiat_Sm2_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_Sm2_addcarryx_u32(x18, x19, 0x0, (x1).get(), (x17).get()); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), (x17).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), (x17).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x17).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (x17).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), ((x17).get() & 0xfffffffe)); + 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_Sm2_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_Sm2_opp(int[] out1, final int[] arg1) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_subborrowx_u32(x15, x16, (x14).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[7])); + Box x17 = new Box((int)0); + fiat_Sm2_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_Sm2_addcarryx_u32(x18, x19, 0x0, (x1).get(), (x17).get()); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), (x17).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), (x17).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x17).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (x17).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), ((x17).get() & 0xfffffffe)); + 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_Sm2_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_Sm2_from_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[0]); + Box x2 = new Box((int)0); + Box x3 = new Box((int)0); + fiat_Sm2_mulx_u32(x2, x3, x1, 0xfffffffe); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_Sm2_mulx_u32(x4, x5, x1, 0xffffffff); + Box x6 = new Box((int)0); + Box x7 = new Box((int)0); + fiat_Sm2_mulx_u32(x6, x7, x1, 0xffffffff); + Box x8 = new Box((int)0); + Box x9 = new Box((int)0); + fiat_Sm2_mulx_u32(x8, x9, x1, 0xffffffff); + Box x10 = new Box((int)0); + Box x11 = new Box((int)0); + fiat_Sm2_mulx_u32(x10, x11, x1, 0xffffffff); + Box x12 = new Box((int)0); + Box x13 = new Box((int)0); + fiat_Sm2_mulx_u32(x12, x13, x1, 0xffffffff); + Box x14 = new Box((int)0); + Box x15 = new Box((int)0); + fiat_Sm2_mulx_u32(x14, x15, x1, 0xffffffff); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x16, x17, 0x0, (x15).get(), (x12).get()); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x18, x19, 0x0, (x11).get(), (x8).get()); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x20, x21, (x19).get(), (x9).get(), (x6).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x22, x23, (x21).get(), (x7).get(), (x4).get()); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x24, x25, (x23).get(), (x5).get(), (x2).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x26, x27, 0x0, x1, (x14).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x28, x29, (x27).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x16).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x30, x31, (x29).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), ((x17).get() + (x13).get())); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x34, x35, (x33).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x18).get()); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_addcarryx_u32(x42, x43, 0x0, (x28).get(), (arg1[1])); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x44, x45, (x43).get(), (x30).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_addcarryx_u32(x56, x57, (x55).get(), ((x41).get() + ((x25).get() + (x3).get())), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Sm2_mulx_u32(x58, x59, (x42).get(), 0xfffffffe); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Sm2_mulx_u32(x60, x61, (x42).get(), 0xffffffff); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Sm2_mulx_u32(x62, x63, (x42).get(), 0xffffffff); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Sm2_mulx_u32(x64, x65, (x42).get(), 0xffffffff); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Sm2_mulx_u32(x66, x67, (x42).get(), 0xffffffff); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Sm2_mulx_u32(x68, x69, (x42).get(), 0xffffffff); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Sm2_mulx_u32(x70, x71, (x42).get(), 0xffffffff); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x72, x73, 0x0, (x71).get(), (x68).get()); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x74, x75, 0x0, (x67).get(), (x64).get()); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x76, x77, (x75).get(), (x65).get(), (x62).get()); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x78, x79, (x77).get(), (x63).get(), (x60).get()); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x80, x81, (x79).get(), (x61).get(), (x58).get()); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x82, x83, 0x0, (x42).get(), (x70).get()); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x84, x85, (x83).get(), (x44).get(), (x72).get()); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x86, x87, (x85).get(), (x46).get(), ((x73).get() + (x69).get())); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x88, x89, (x87).get(), (x48).get(), (x66).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x90, x91, (x89).get(), (x50).get(), (x74).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x92, x93, (x91).get(), (x52).get(), (x76).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x94, x95, (x93).get(), (x54).get(), (x78).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x96, x97, (x95).get(), (x56).get(), (x80).get()); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x98, x99, (x97).get(), (x57).get(), ((x81).get() + (x59).get())); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x100, x101, 0x0, (x84).get(), (arg1[2])); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x102, x103, (x101).get(), (x86).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x104, x105, (x103).get(), (x88).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_mulx_u32(x116, x117, (x100).get(), 0xfffffffe); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Sm2_mulx_u32(x118, x119, (x100).get(), 0xffffffff); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Sm2_mulx_u32(x120, x121, (x100).get(), 0xffffffff); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Sm2_mulx_u32(x122, x123, (x100).get(), 0xffffffff); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Sm2_mulx_u32(x124, x125, (x100).get(), 0xffffffff); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Sm2_mulx_u32(x126, x127, (x100).get(), 0xffffffff); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Sm2_mulx_u32(x128, x129, (x100).get(), 0xffffffff); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x130, x131, 0x0, (x129).get(), (x126).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x132, x133, 0x0, (x125).get(), (x122).get()); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x134, x135, (x133).get(), (x123).get(), (x120).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x136, x137, (x135).get(), (x121).get(), (x118).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x138, x139, (x137).get(), (x119).get(), (x116).get()); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x140, x141, 0x0, (x100).get(), (x128).get()); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x142, x143, (x141).get(), (x102).get(), (x130).get()); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x144, x145, (x143).get(), (x104).get(), ((x131).get() + (x127).get())); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x146, x147, (x145).get(), (x106).get(), (x124).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x148, x149, (x147).get(), (x108).get(), (x132).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x150, x151, (x149).get(), (x110).get(), (x134).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x152, x153, (x151).get(), (x112).get(), (x136).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x154, x155, (x153).get(), (x114).get(), (x138).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x156, x157, (x155).get(), ((x115).get() + (x99).get()), ((x139).get() + (x117).get())); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x158, x159, 0x0, (x142).get(), (arg1[3])); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x160, x161, (x159).get(), (x144).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x162, x163, (x161).get(), (x146).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x164, x165, (x163).get(), (x148).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_mulx_u32(x174, x175, (x158).get(), 0xfffffffe); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Sm2_mulx_u32(x176, x177, (x158).get(), 0xffffffff); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Sm2_mulx_u32(x178, x179, (x158).get(), 0xffffffff); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Sm2_mulx_u32(x180, x181, (x158).get(), 0xffffffff); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Sm2_mulx_u32(x182, x183, (x158).get(), 0xffffffff); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Sm2_mulx_u32(x184, x185, (x158).get(), 0xffffffff); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Sm2_mulx_u32(x186, x187, (x158).get(), 0xffffffff); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x188, x189, 0x0, (x187).get(), (x184).get()); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x190, x191, 0x0, (x183).get(), (x180).get()); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x192, x193, (x191).get(), (x181).get(), (x178).get()); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x194, x195, (x193).get(), (x179).get(), (x176).get()); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x196, x197, (x195).get(), (x177).get(), (x174).get()); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x198, x199, 0x0, (x158).get(), (x186).get()); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x200, x201, (x199).get(), (x160).get(), (x188).get()); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x202, x203, (x201).get(), (x162).get(), ((x189).get() + (x185).get())); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x204, x205, (x203).get(), (x164).get(), (x182).get()); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x206, x207, (x205).get(), (x166).get(), (x190).get()); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x208, x209, (x207).get(), (x168).get(), (x192).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x210, x211, (x209).get(), (x170).get(), (x194).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x212, x213, (x211).get(), (x172).get(), (x196).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x214, x215, (x213).get(), ((x173).get() + (x157).get()), ((x197).get() + (x175).get())); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x216, x217, 0x0, (x200).get(), (arg1[4])); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x218, x219, (x217).get(), (x202).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x220, x221, (x219).get(), (x204).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x222, x223, (x221).get(), (x206).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x224, x225, (x223).get(), (x208).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_mulx_u32(x232, x233, (x216).get(), 0xfffffffe); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_Sm2_mulx_u32(x234, x235, (x216).get(), 0xffffffff); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_Sm2_mulx_u32(x236, x237, (x216).get(), 0xffffffff); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_Sm2_mulx_u32(x238, x239, (x216).get(), 0xffffffff); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_Sm2_mulx_u32(x240, x241, (x216).get(), 0xffffffff); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_Sm2_mulx_u32(x242, x243, (x216).get(), 0xffffffff); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Sm2_mulx_u32(x244, x245, (x216).get(), 0xffffffff); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x246, x247, 0x0, (x245).get(), (x242).get()); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x248, x249, 0x0, (x241).get(), (x238).get()); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x250, x251, (x249).get(), (x239).get(), (x236).get()); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x252, x253, (x251).get(), (x237).get(), (x234).get()); + Box x254 = new Box((int)0); + Box x255 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x254, x255, (x253).get(), (x235).get(), (x232).get()); + Box x256 = new Box((int)0); + Box x257 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x256, x257, 0x0, (x216).get(), (x244).get()); + Box x258 = new Box((int)0); + Box x259 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x258, x259, (x257).get(), (x218).get(), (x246).get()); + Box x260 = new Box((int)0); + Box x261 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x260, x261, (x259).get(), (x220).get(), ((x247).get() + (x243).get())); + Box x262 = new Box((int)0); + Box x263 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x262, x263, (x261).get(), (x222).get(), (x240).get()); + Box x264 = new Box((int)0); + Box x265 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x264, x265, (x263).get(), (x224).get(), (x248).get()); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x266, x267, (x265).get(), (x226).get(), (x250).get()); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x268, x269, (x267).get(), (x228).get(), (x252).get()); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x270, x271, (x269).get(), (x230).get(), (x254).get()); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x272, x273, (x271).get(), ((x231).get() + (x215).get()), ((x255).get() + (x233).get())); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x274, x275, 0x0, (x258).get(), (arg1[5])); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x276, x277, (x275).get(), (x260).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x278, x279, (x277).get(), (x262).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x280, x281, (x279).get(), (x264).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x282, x283, (x281).get(), (x266).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x284, x285, (x283).get(), (x268).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_mulx_u32(x290, x291, (x274).get(), 0xfffffffe); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Sm2_mulx_u32(x292, x293, (x274).get(), 0xffffffff); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Sm2_mulx_u32(x294, x295, (x274).get(), 0xffffffff); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Sm2_mulx_u32(x296, x297, (x274).get(), 0xffffffff); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Sm2_mulx_u32(x298, x299, (x274).get(), 0xffffffff); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Sm2_mulx_u32(x300, x301, (x274).get(), 0xffffffff); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_Sm2_mulx_u32(x302, x303, (x274).get(), 0xffffffff); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x304, x305, 0x0, (x303).get(), (x300).get()); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x306, x307, 0x0, (x299).get(), (x296).get()); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x308, x309, (x307).get(), (x297).get(), (x294).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x310, x311, (x309).get(), (x295).get(), (x292).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x312, x313, (x311).get(), (x293).get(), (x290).get()); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x314, x315, 0x0, (x274).get(), (x302).get()); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x316, x317, (x315).get(), (x276).get(), (x304).get()); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x318, x319, (x317).get(), (x278).get(), ((x305).get() + (x301).get())); + Box x320 = new Box((int)0); + Box x321 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x320, x321, (x319).get(), (x280).get(), (x298).get()); + Box x322 = new Box((int)0); + Box x323 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x322, x323, (x321).get(), (x282).get(), (x306).get()); + Box x324 = new Box((int)0); + Box x325 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x324, x325, (x323).get(), (x284).get(), (x308).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x326, x327, (x325).get(), (x286).get(), (x310).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x328, x329, (x327).get(), (x288).get(), (x312).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x330, x331, (x329).get(), ((x289).get() + (x273).get()), ((x313).get() + (x291).get())); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x332, x333, 0x0, (x316).get(), (arg1[6])); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x334, x335, (x333).get(), (x318).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x336, x337, (x335).get(), (x320).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x338, x339, (x337).get(), (x322).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x340, x341, (x339).get(), (x324).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x342, x343, (x341).get(), (x326).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x344, x345, (x343).get(), (x328).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Sm2_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_Sm2_mulx_u32(x348, x349, (x332).get(), 0xfffffffe); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Sm2_mulx_u32(x350, x351, (x332).get(), 0xffffffff); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Sm2_mulx_u32(x352, x353, (x332).get(), 0xffffffff); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Sm2_mulx_u32(x354, x355, (x332).get(), 0xffffffff); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Sm2_mulx_u32(x356, x357, (x332).get(), 0xffffffff); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Sm2_mulx_u32(x358, x359, (x332).get(), 0xffffffff); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Sm2_mulx_u32(x360, x361, (x332).get(), 0xffffffff); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x362, x363, 0x0, (x361).get(), (x358).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x364, x365, 0x0, (x357).get(), (x354).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x366, x367, (x365).get(), (x355).get(), (x352).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x368, x369, (x367).get(), (x353).get(), (x350).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x370, x371, (x369).get(), (x351).get(), (x348).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x372, x373, 0x0, (x332).get(), (x360).get()); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x374, x375, (x373).get(), (x334).get(), (x362).get()); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x376, x377, (x375).get(), (x336).get(), ((x363).get() + (x359).get())); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x378, x379, (x377).get(), (x338).get(), (x356).get()); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x380, x381, (x379).get(), (x340).get(), (x364).get()); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x382, x383, (x381).get(), (x342).get(), (x366).get()); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x384, x385, (x383).get(), (x344).get(), (x368).get()); + Box x386 = new Box((int)0); + Box x387 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x386, x387, (x385).get(), (x346).get(), (x370).get()); + Box x388 = new Box((int)0); + Box x389 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x388, x389, (x387).get(), ((x347).get() + (x331).get()), ((x371).get() + (x349).get())); + Box x390 = new Box((int)0); + Box x391 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x390, x391, 0x0, (x374).get(), (arg1[7])); + Box x392 = new Box((int)0); + Box x393 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_addcarryx_u32(x398, x399, (x397).get(), (x382).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x400, x401, (x399).get(), (x384).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x402, x403, (x401).get(), (x386).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x404, x405, (x403).get(), (x388).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Sm2_mulx_u32(x406, x407, (x390).get(), 0xfffffffe); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Sm2_mulx_u32(x408, x409, (x390).get(), 0xffffffff); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Sm2_mulx_u32(x410, x411, (x390).get(), 0xffffffff); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Sm2_mulx_u32(x412, x413, (x390).get(), 0xffffffff); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Sm2_mulx_u32(x414, x415, (x390).get(), 0xffffffff); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Sm2_mulx_u32(x416, x417, (x390).get(), 0xffffffff); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Sm2_mulx_u32(x418, x419, (x390).get(), 0xffffffff); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x420, x421, 0x0, (x419).get(), (x416).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x422, x423, 0x0, (x415).get(), (x412).get()); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x424, x425, (x423).get(), (x413).get(), (x410).get()); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x426, x427, (x425).get(), (x411).get(), (x408).get()); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x428, x429, (x427).get(), (x409).get(), (x406).get()); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x430, x431, 0x0, (x390).get(), (x418).get()); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x432, x433, (x431).get(), (x392).get(), (x420).get()); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x434, x435, (x433).get(), (x394).get(), ((x421).get() + (x417).get())); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x436, x437, (x435).get(), (x396).get(), (x414).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x438, x439, (x437).get(), (x398).get(), (x422).get()); + Box x440 = new Box((int)0); + Box x441 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x440, x441, (x439).get(), (x400).get(), (x424).get()); + Box x442 = new Box((int)0); + Box x443 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x442, x443, (x441).get(), (x402).get(), (x426).get()); + Box x444 = new Box((int)0); + Box x445 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x444, x445, (x443).get(), (x404).get(), (x428).get()); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x446, x447, (x445).get(), ((x405).get() + (x389).get()), ((x429).get() + (x407).get())); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x448, x449, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x432).get(), 0xffffffff); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x450, x451, (x449).get(), (x434).get(), 0xffffffff); + Box x452 = new Box((int)0); + Box x453 = new Box((int)0); + fiat_Sm2_subborrowx_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_Sm2_subborrowx_u32(x454, x455, (x453).get(), (x438).get(), 0xffffffff); + Box x456 = new Box((int)0); + Box x457 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x456, x457, (x455).get(), (x440).get(), 0xffffffff); + Box x458 = new Box((int)0); + Box x459 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x458, x459, (x457).get(), (x442).get(), 0xffffffff); + Box x460 = new Box((int)0); + Box x461 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x460, x461, (x459).get(), (x444).get(), 0xffffffff); + Box x462 = new Box((int)0); + Box x463 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x462, x463, (x461).get(), (x446).get(), 0xfffffffe); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x464, x465, (x463).get(), (x447).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x466 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x466, (x465).get(), (x448).get(), (x432).get()); + Box x467 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x467, (x465).get(), (x450).get(), (x434).get()); + Box x468 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x468, (x465).get(), (x452).get(), (x436).get()); + Box x469 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x469, (x465).get(), (x454).get(), (x438).get()); + Box x470 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x470, (x465).get(), (x456).get(), (x440).get()); + Box x471 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x471, (x465).get(), (x458).get(), (x442).get()); + Box x472 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x472, (x465).get(), (x460).get(), (x444).get()); + Box x473 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x473, (x465).get(), (x462).get(), (x446).get()); + out1[0] = (x466).get(); + out1[1] = (x467).get(); + out1[2] = (x468).get(); + out1[3] = (x469).get(); + out1[4] = (x470).get(); + out1[5] = (x471).get(); + out1[6] = (x472).get(); + out1[7] = (x473).get(); +} + +/** + * The function fiat_Sm2_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_Sm2_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_Sm2_mulx_u32(x9, x10, x8, 0x4); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2_mulx_u32(x11, x12, x8, 0x2); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2_mulx_u32(x13, x14, x8, 0x2); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2_mulx_u32(x15, x16, x8, 0xffffffff); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2_mulx_u32(x17, x18, x8, 0x2); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2_mulx_u32(x19, x20, x8, 0x3); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x21, x22, 0x0, (x20).get(), (x17).get()); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x23, x24, (x22).get(), (x18).get(), (x15).get()); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x25, x26, (x24).get(), (x16).get(), (x13).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x27, x28, (x26).get(), (x14).get(), x8); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x29, x30, (x28).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x8); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x31, x32, (x30).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x33, x34, (x32).get(), (x12).get(), (x9).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Sm2_mulx_u32(x35, x36, (x19).get(), 0xfffffffe); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Sm2_mulx_u32(x37, x38, (x19).get(), 0xffffffff); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_Sm2_mulx_u32(x39, x40, (x19).get(), 0xffffffff); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_Sm2_mulx_u32(x41, x42, (x19).get(), 0xffffffff); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_Sm2_mulx_u32(x43, x44, (x19).get(), 0xffffffff); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_Sm2_mulx_u32(x45, x46, (x19).get(), 0xffffffff); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_Sm2_mulx_u32(x47, x48, (x19).get(), 0xffffffff); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x49, x50, 0x0, (x48).get(), (x45).get()); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x51, x52, 0x0, (x44).get(), (x41).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x53, x54, (x52).get(), (x42).get(), (x39).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x55, x56, (x54).get(), (x40).get(), (x37).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x57, x58, (x56).get(), (x38).get(), (x35).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x59, x60, 0x0, (x19).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x61, x62, (x60).get(), (x21).get(), (x49).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x63, x64, (x62).get(), (x23).get(), ((x50).get() + (x46).get())); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x65, x66, (x64).get(), (x25).get(), (x43).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x67, x68, (x66).get(), (x27).get(), (x51).get()); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x69, x70, (x68).get(), (x29).get(), (x53).get()); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x71, x72, (x70).get(), (x31).get(), (x55).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x73, x74, (x72).get(), (x33).get(), (x57).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x75, x76, (x74).get(), ((x34).get() + (x10).get()), ((x58).get() + (x36).get())); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Sm2_mulx_u32(x77, x78, x1, 0x4); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Sm2_mulx_u32(x79, x80, x1, 0x2); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Sm2_mulx_u32(x81, x82, x1, 0x2); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Sm2_mulx_u32(x83, x84, x1, 0xffffffff); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Sm2_mulx_u32(x85, x86, x1, 0x2); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Sm2_mulx_u32(x87, x88, x1, 0x3); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x89, x90, 0x0, (x88).get(), (x85).get()); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x91, x92, (x90).get(), (x86).get(), (x83).get()); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x93, x94, (x92).get(), (x84).get(), (x81).get()); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x95, x96, (x94).get(), (x82).get(), x1); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x97, x98, (x96).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x1); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x99, x100, (x98).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x79).get()); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x101, x102, (x100).get(), (x80).get(), (x77).get()); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x103, x104, 0x0, (x61).get(), (x87).get()); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x105, x106, (x104).get(), (x63).get(), (x89).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x107, x108, (x106).get(), (x65).get(), (x91).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x109, x110, (x108).get(), (x67).get(), (x93).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x111, x112, (x110).get(), (x69).get(), (x95).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x113, x114, (x112).get(), (x71).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x115, x116, (x114).get(), (x73).get(), (x99).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x117, x118, (x116).get(), (x75).get(), (x101).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Sm2_mulx_u32(x119, x120, (x103).get(), 0xfffffffe); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_Sm2_mulx_u32(x121, x122, (x103).get(), 0xffffffff); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_Sm2_mulx_u32(x123, x124, (x103).get(), 0xffffffff); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_Sm2_mulx_u32(x125, x126, (x103).get(), 0xffffffff); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_Sm2_mulx_u32(x127, x128, (x103).get(), 0xffffffff); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_Sm2_mulx_u32(x129, x130, (x103).get(), 0xffffffff); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_Sm2_mulx_u32(x131, x132, (x103).get(), 0xffffffff); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x133, x134, 0x0, (x132).get(), (x129).get()); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x135, x136, 0x0, (x128).get(), (x125).get()); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x137, x138, (x136).get(), (x126).get(), (x123).get()); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x139, x140, (x138).get(), (x124).get(), (x121).get()); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x141, x142, (x140).get(), (x122).get(), (x119).get()); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x143, x144, 0x0, (x103).get(), (x131).get()); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x145, x146, (x144).get(), (x105).get(), (x133).get()); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x147, x148, (x146).get(), (x107).get(), ((x134).get() + (x130).get())); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x149, x150, (x148).get(), (x109).get(), (x127).get()); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x151, x152, (x150).get(), (x111).get(), (x135).get()); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x153, x154, (x152).get(), (x113).get(), (x137).get()); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x155, x156, (x154).get(), (x115).get(), (x139).get()); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x157, x158, (x156).get(), (x117).get(), (x141).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x159, x160, (x158).get(), (((x118).get() + (x76).get()) + ((x102).get() + (x78).get())), ((x142).get() + (x120).get())); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Sm2_mulx_u32(x161, x162, x2, 0x4); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_Sm2_mulx_u32(x163, x164, x2, 0x2); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_Sm2_mulx_u32(x165, x166, x2, 0x2); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_Sm2_mulx_u32(x167, x168, x2, 0xffffffff); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_Sm2_mulx_u32(x169, x170, x2, 0x2); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_Sm2_mulx_u32(x171, x172, x2, 0x3); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x173, x174, 0x0, (x172).get(), (x169).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x175, x176, (x174).get(), (x170).get(), (x167).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x177, x178, (x176).get(), (x168).get(), (x165).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x179, x180, (x178).get(), (x166).get(), x2); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x181, x182, (x180).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x2); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x183, x184, (x182).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x163).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x185, x186, (x184).get(), (x164).get(), (x161).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x187, x188, 0x0, (x145).get(), (x171).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x189, x190, (x188).get(), (x147).get(), (x173).get()); + Box x191 = new Box((int)0); + Box x192 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x191, x192, (x190).get(), (x149).get(), (x175).get()); + Box x193 = new Box((int)0); + Box x194 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x193, x194, (x192).get(), (x151).get(), (x177).get()); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x195, x196, (x194).get(), (x153).get(), (x179).get()); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x197, x198, (x196).get(), (x155).get(), (x181).get()); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x199, x200, (x198).get(), (x157).get(), (x183).get()); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x201, x202, (x200).get(), (x159).get(), (x185).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_Sm2_mulx_u32(x203, x204, (x187).get(), 0xfffffffe); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_Sm2_mulx_u32(x205, x206, (x187).get(), 0xffffffff); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_Sm2_mulx_u32(x207, x208, (x187).get(), 0xffffffff); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Sm2_mulx_u32(x209, x210, (x187).get(), 0xffffffff); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Sm2_mulx_u32(x211, x212, (x187).get(), 0xffffffff); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Sm2_mulx_u32(x213, x214, (x187).get(), 0xffffffff); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Sm2_mulx_u32(x215, x216, (x187).get(), 0xffffffff); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x217, x218, 0x0, (x216).get(), (x213).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x219, x220, 0x0, (x212).get(), (x209).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x221, x222, (x220).get(), (x210).get(), (x207).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x223, x224, (x222).get(), (x208).get(), (x205).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x225, x226, (x224).get(), (x206).get(), (x203).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x227, x228, 0x0, (x187).get(), (x215).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x229, x230, (x228).get(), (x189).get(), (x217).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x231, x232, (x230).get(), (x191).get(), ((x218).get() + (x214).get())); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x233, x234, (x232).get(), (x193).get(), (x211).get()); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x235, x236, (x234).get(), (x195).get(), (x219).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x237, x238, (x236).get(), (x197).get(), (x221).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x239, x240, (x238).get(), (x199).get(), (x223).get()); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x241, x242, (x240).get(), (x201).get(), (x225).get()); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x243, x244, (x242).get(), (((x202).get() + (x160).get()) + ((x186).get() + (x162).get())), ((x226).get() + (x204).get())); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Sm2_mulx_u32(x245, x246, x3, 0x4); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Sm2_mulx_u32(x247, x248, x3, 0x2); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Sm2_mulx_u32(x249, x250, x3, 0x2); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Sm2_mulx_u32(x251, x252, x3, 0xffffffff); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Sm2_mulx_u32(x253, x254, x3, 0x2); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Sm2_mulx_u32(x255, x256, x3, 0x3); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x257, x258, 0x0, (x256).get(), (x253).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x259, x260, (x258).get(), (x254).get(), (x251).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x261, x262, (x260).get(), (x252).get(), (x249).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x263, x264, (x262).get(), (x250).get(), x3); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x265, x266, (x264).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x3); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x267, x268, (x266).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x247).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x269, x270, (x268).get(), (x248).get(), (x245).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x271, x272, 0x0, (x229).get(), (x255).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x273, x274, (x272).get(), (x231).get(), (x257).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x275, x276, (x274).get(), (x233).get(), (x259).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x277, x278, (x276).get(), (x235).get(), (x261).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x279, x280, (x278).get(), (x237).get(), (x263).get()); + Box x281 = new Box((int)0); + Box x282 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x281, x282, (x280).get(), (x239).get(), (x265).get()); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x283, x284, (x282).get(), (x241).get(), (x267).get()); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x285, x286, (x284).get(), (x243).get(), (x269).get()); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_Sm2_mulx_u32(x287, x288, (x271).get(), 0xfffffffe); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_Sm2_mulx_u32(x289, x290, (x271).get(), 0xffffffff); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_Sm2_mulx_u32(x291, x292, (x271).get(), 0xffffffff); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_Sm2_mulx_u32(x293, x294, (x271).get(), 0xffffffff); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Sm2_mulx_u32(x295, x296, (x271).get(), 0xffffffff); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Sm2_mulx_u32(x297, x298, (x271).get(), 0xffffffff); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Sm2_mulx_u32(x299, x300, (x271).get(), 0xffffffff); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x301, x302, 0x0, (x300).get(), (x297).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x303, x304, 0x0, (x296).get(), (x293).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x305, x306, (x304).get(), (x294).get(), (x291).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x307, x308, (x306).get(), (x292).get(), (x289).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x309, x310, (x308).get(), (x290).get(), (x287).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x311, x312, 0x0, (x271).get(), (x299).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x313, x314, (x312).get(), (x273).get(), (x301).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x315, x316, (x314).get(), (x275).get(), ((x302).get() + (x298).get())); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x317, x318, (x316).get(), (x277).get(), (x295).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x319, x320, (x318).get(), (x279).get(), (x303).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x321, x322, (x320).get(), (x281).get(), (x305).get()); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x323, x324, (x322).get(), (x283).get(), (x307).get()); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x325, x326, (x324).get(), (x285).get(), (x309).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x327, x328, (x326).get(), (((x286).get() + (x244).get()) + ((x270).get() + (x246).get())), ((x310).get() + (x288).get())); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Sm2_mulx_u32(x329, x330, x4, 0x4); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Sm2_mulx_u32(x331, x332, x4, 0x2); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Sm2_mulx_u32(x333, x334, x4, 0x2); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Sm2_mulx_u32(x335, x336, x4, 0xffffffff); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_Sm2_mulx_u32(x337, x338, x4, 0x2); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_Sm2_mulx_u32(x339, x340, x4, 0x3); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x341, x342, 0x0, (x340).get(), (x337).get()); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x343, x344, (x342).get(), (x338).get(), (x335).get()); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x345, x346, (x344).get(), (x336).get(), (x333).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x347, x348, (x346).get(), (x334).get(), x4); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x349, x350, (x348).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x4); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x351, x352, (x350).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x331).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x353, x354, (x352).get(), (x332).get(), (x329).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x355, x356, 0x0, (x313).get(), (x339).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x357, x358, (x356).get(), (x315).get(), (x341).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x359, x360, (x358).get(), (x317).get(), (x343).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x361, x362, (x360).get(), (x319).get(), (x345).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x363, x364, (x362).get(), (x321).get(), (x347).get()); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x365, x366, (x364).get(), (x323).get(), (x349).get()); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x367, x368, (x366).get(), (x325).get(), (x351).get()); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x369, x370, (x368).get(), (x327).get(), (x353).get()); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_Sm2_mulx_u32(x371, x372, (x355).get(), 0xfffffffe); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_Sm2_mulx_u32(x373, x374, (x355).get(), 0xffffffff); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Sm2_mulx_u32(x375, x376, (x355).get(), 0xffffffff); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Sm2_mulx_u32(x377, x378, (x355).get(), 0xffffffff); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Sm2_mulx_u32(x379, x380, (x355).get(), 0xffffffff); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Sm2_mulx_u32(x381, x382, (x355).get(), 0xffffffff); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Sm2_mulx_u32(x383, x384, (x355).get(), 0xffffffff); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x385, x386, 0x0, (x384).get(), (x381).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x387, x388, 0x0, (x380).get(), (x377).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x389, x390, (x388).get(), (x378).get(), (x375).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x391, x392, (x390).get(), (x376).get(), (x373).get()); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x393, x394, (x392).get(), (x374).get(), (x371).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x395, x396, 0x0, (x355).get(), (x383).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x397, x398, (x396).get(), (x357).get(), (x385).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x399, x400, (x398).get(), (x359).get(), ((x386).get() + (x382).get())); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x401, x402, (x400).get(), (x361).get(), (x379).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x403, x404, (x402).get(), (x363).get(), (x387).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x405, x406, (x404).get(), (x365).get(), (x389).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x407, x408, (x406).get(), (x367).get(), (x391).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x409, x410, (x408).get(), (x369).get(), (x393).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x411, x412, (x410).get(), (((x370).get() + (x328).get()) + ((x354).get() + (x330).get())), ((x394).get() + (x372).get())); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_Sm2_mulx_u32(x413, x414, x5, 0x4); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_Sm2_mulx_u32(x415, x416, x5, 0x2); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_Sm2_mulx_u32(x417, x418, x5, 0x2); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_Sm2_mulx_u32(x419, x420, x5, 0xffffffff); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_Sm2_mulx_u32(x421, x422, x5, 0x2); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_Sm2_mulx_u32(x423, x424, x5, 0x3); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x425, x426, 0x0, (x424).get(), (x421).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x427, x428, (x426).get(), (x422).get(), (x419).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x429, x430, (x428).get(), (x420).get(), (x417).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x431, x432, (x430).get(), (x418).get(), x5); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x433, x434, (x432).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x5); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x435, x436, (x434).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x415).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x437, x438, (x436).get(), (x416).get(), (x413).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x439, x440, 0x0, (x397).get(), (x423).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x441, x442, (x440).get(), (x399).get(), (x425).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x443, x444, (x442).get(), (x401).get(), (x427).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x445, x446, (x444).get(), (x403).get(), (x429).get()); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x447, x448, (x446).get(), (x405).get(), (x431).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x449, x450, (x448).get(), (x407).get(), (x433).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x451, x452, (x450).get(), (x409).get(), (x435).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x453, x454, (x452).get(), (x411).get(), (x437).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Sm2_mulx_u32(x455, x456, (x439).get(), 0xfffffffe); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Sm2_mulx_u32(x457, x458, (x439).get(), 0xffffffff); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Sm2_mulx_u32(x459, x460, (x439).get(), 0xffffffff); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Sm2_mulx_u32(x461, x462, (x439).get(), 0xffffffff); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Sm2_mulx_u32(x463, x464, (x439).get(), 0xffffffff); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Sm2_mulx_u32(x465, x466, (x439).get(), 0xffffffff); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Sm2_mulx_u32(x467, x468, (x439).get(), 0xffffffff); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x469, x470, 0x0, (x468).get(), (x465).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x471, x472, 0x0, (x464).get(), (x461).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x473, x474, (x472).get(), (x462).get(), (x459).get()); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x475, x476, (x474).get(), (x460).get(), (x457).get()); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x477, x478, (x476).get(), (x458).get(), (x455).get()); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x479, x480, 0x0, (x439).get(), (x467).get()); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x481, x482, (x480).get(), (x441).get(), (x469).get()); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x483, x484, (x482).get(), (x443).get(), ((x470).get() + (x466).get())); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x485, x486, (x484).get(), (x445).get(), (x463).get()); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x487, x488, (x486).get(), (x447).get(), (x471).get()); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x489, x490, (x488).get(), (x449).get(), (x473).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x491, x492, (x490).get(), (x451).get(), (x475).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x493, x494, (x492).get(), (x453).get(), (x477).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x495, x496, (x494).get(), (((x454).get() + (x412).get()) + ((x438).get() + (x414).get())), ((x478).get() + (x456).get())); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Sm2_mulx_u32(x497, x498, x6, 0x4); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Sm2_mulx_u32(x499, x500, x6, 0x2); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Sm2_mulx_u32(x501, x502, x6, 0x2); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Sm2_mulx_u32(x503, x504, x6, 0xffffffff); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Sm2_mulx_u32(x505, x506, x6, 0x2); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Sm2_mulx_u32(x507, x508, x6, 0x3); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x509, x510, 0x0, (x508).get(), (x505).get()); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x511, x512, (x510).get(), (x506).get(), (x503).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x513, x514, (x512).get(), (x504).get(), (x501).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x515, x516, (x514).get(), (x502).get(), x6); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x517, x518, (x516).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x6); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x519, x520, (x518).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x499).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x521, x522, (x520).get(), (x500).get(), (x497).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x523, x524, 0x0, (x481).get(), (x507).get()); + Box x525 = new Box((int)0); + Box x526 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x525, x526, (x524).get(), (x483).get(), (x509).get()); + Box x527 = new Box((int)0); + Box x528 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x527, x528, (x526).get(), (x485).get(), (x511).get()); + Box x529 = new Box((int)0); + Box x530 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x529, x530, (x528).get(), (x487).get(), (x513).get()); + Box x531 = new Box((int)0); + Box x532 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x531, x532, (x530).get(), (x489).get(), (x515).get()); + Box x533 = new Box((int)0); + Box x534 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x533, x534, (x532).get(), (x491).get(), (x517).get()); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x535, x536, (x534).get(), (x493).get(), (x519).get()); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x537, x538, (x536).get(), (x495).get(), (x521).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_Sm2_mulx_u32(x539, x540, (x523).get(), 0xfffffffe); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_Sm2_mulx_u32(x541, x542, (x523).get(), 0xffffffff); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Sm2_mulx_u32(x543, x544, (x523).get(), 0xffffffff); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Sm2_mulx_u32(x545, x546, (x523).get(), 0xffffffff); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Sm2_mulx_u32(x547, x548, (x523).get(), 0xffffffff); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Sm2_mulx_u32(x549, x550, (x523).get(), 0xffffffff); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Sm2_mulx_u32(x551, x552, (x523).get(), 0xffffffff); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x553, x554, 0x0, (x552).get(), (x549).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x555, x556, 0x0, (x548).get(), (x545).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x557, x558, (x556).get(), (x546).get(), (x543).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x559, x560, (x558).get(), (x544).get(), (x541).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x561, x562, (x560).get(), (x542).get(), (x539).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x563, x564, 0x0, (x523).get(), (x551).get()); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x565, x566, (x564).get(), (x525).get(), (x553).get()); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x567, x568, (x566).get(), (x527).get(), ((x554).get() + (x550).get())); + Box x569 = new Box((int)0); + Box x570 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x569, x570, (x568).get(), (x529).get(), (x547).get()); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x571, x572, (x570).get(), (x531).get(), (x555).get()); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x573, x574, (x572).get(), (x533).get(), (x557).get()); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x575, x576, (x574).get(), (x535).get(), (x559).get()); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x577, x578, (x576).get(), (x537).get(), (x561).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x579, x580, (x578).get(), (((x538).get() + (x496).get()) + ((x522).get() + (x498).get())), ((x562).get() + (x540).get())); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Sm2_mulx_u32(x581, x582, x7, 0x4); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Sm2_mulx_u32(x583, x584, x7, 0x2); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Sm2_mulx_u32(x585, x586, x7, 0x2); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Sm2_mulx_u32(x587, x588, x7, 0xffffffff); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Sm2_mulx_u32(x589, x590, x7, 0x2); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Sm2_mulx_u32(x591, x592, x7, 0x3); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x593, x594, 0x0, (x592).get(), (x589).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x595, x596, (x594).get(), (x590).get(), (x587).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x597, x598, (x596).get(), (x588).get(), (x585).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x599, x600, (x598).get(), (x586).get(), x7); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x601, x602, (x600).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x7); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x603, x604, (x602).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x583).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x605, x606, (x604).get(), (x584).get(), (x581).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x607, x608, 0x0, (x565).get(), (x591).get()); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x609, x610, (x608).get(), (x567).get(), (x593).get()); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x611, x612, (x610).get(), (x569).get(), (x595).get()); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x613, x614, (x612).get(), (x571).get(), (x597).get()); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x615, x616, (x614).get(), (x573).get(), (x599).get()); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x617, x618, (x616).get(), (x575).get(), (x601).get()); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x619, x620, (x618).get(), (x577).get(), (x603).get()); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x621, x622, (x620).get(), (x579).get(), (x605).get()); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_Sm2_mulx_u32(x623, x624, (x607).get(), 0xfffffffe); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_Sm2_mulx_u32(x625, x626, (x607).get(), 0xffffffff); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Sm2_mulx_u32(x627, x628, (x607).get(), 0xffffffff); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Sm2_mulx_u32(x629, x630, (x607).get(), 0xffffffff); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Sm2_mulx_u32(x631, x632, (x607).get(), 0xffffffff); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Sm2_mulx_u32(x633, x634, (x607).get(), 0xffffffff); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Sm2_mulx_u32(x635, x636, (x607).get(), 0xffffffff); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x637, x638, 0x0, (x636).get(), (x633).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x639, x640, 0x0, (x632).get(), (x629).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x641, x642, (x640).get(), (x630).get(), (x627).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x643, x644, (x642).get(), (x628).get(), (x625).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x645, x646, (x644).get(), (x626).get(), (x623).get()); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x647, x648, 0x0, (x607).get(), (x635).get()); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x649, x650, (x648).get(), (x609).get(), (x637).get()); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x651, x652, (x650).get(), (x611).get(), ((x638).get() + (x634).get())); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x653, x654, (x652).get(), (x613).get(), (x631).get()); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x655, x656, (x654).get(), (x615).get(), (x639).get()); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x657, x658, (x656).get(), (x617).get(), (x641).get()); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x659, x660, (x658).get(), (x619).get(), (x643).get()); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x661, x662, (x660).get(), (x621).get(), (x645).get()); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x663, x664, (x662).get(), (((x622).get() + (x580).get()) + ((x606).get() + (x582).get())), ((x646).get() + (x624).get())); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x665, x666, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x649).get(), 0xffffffff); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x667, x668, (x666).get(), (x651).get(), 0xffffffff); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x669, x670, (x668).get(), (x653).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x671, x672, (x670).get(), (x655).get(), 0xffffffff); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x673, x674, (x672).get(), (x657).get(), 0xffffffff); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x675, x676, (x674).get(), (x659).get(), 0xffffffff); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x677, x678, (x676).get(), (x661).get(), 0xffffffff); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x679, x680, (x678).get(), (x663).get(), 0xfffffffe); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x681, x682, (x680).get(), (x664).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x683 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x683, (x682).get(), (x665).get(), (x649).get()); + Box x684 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x684, (x682).get(), (x667).get(), (x651).get()); + Box x685 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x685, (x682).get(), (x669).get(), (x653).get()); + Box x686 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x686, (x682).get(), (x671).get(), (x655).get()); + Box x687 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x687, (x682).get(), (x673).get(), (x657).get()); + Box x688 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x688, (x682).get(), (x675).get(), (x659).get()); + Box x689 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x689, (x682).get(), (x677).get(), (x661).get()); + Box x690 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x690, (x682).get(), (x679).get(), (x663).get()); + out1[0] = (x683).get(); + out1[1] = (x684).get(); + out1[2] = (x685).get(); + out1[3] = (x686).get(); + out1[4] = (x687).get(); + out1[5] = (x688).get(); + out1[6] = (x689).get(); + out1[7] = (x690).get(); +} + +/** + * The function fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_selectznz(int[] out1, int arg1, final int[] arg2, final int[] arg3) { + Box x1 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x1, arg1, (arg2[0]), (arg3[0])); + Box x2 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x2, arg1, (arg2[1]), (arg3[1])); + Box x3 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x3, arg1, (arg2[2]), (arg3[2])); + Box x4 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x4, arg1, (arg2[3]), (arg3[3])); + Box x5 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x5, arg1, (arg2[4]), (arg3[4])); + Box x6 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x6, arg1, (arg2[5]), (arg3[5])); + Box x7 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x7, arg1, (arg2[6]), (arg3[6])); + Box x8 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_set_one(int[] out1) { + out1[0] = 0x1; + out1[1] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[2] = 0xffffffff; + out1[3] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + 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] = 0x1; +} + +/** + * The function fiat_Sm2_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_Sm2_msat(int[] out1) { + out1[0] = 0xffffffff; + out1[1] = 0xffffffff; + out1[2] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); + out1[3] = 0xffffffff; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffffe; + out1[8] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_addcarryx_u32(x4, x5, 0x0, (~arg1), 0x1); + Box x6 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x6, x3, arg1, (x4).get()); + Box x7 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x7, x3, (arg2[0]), (arg3[0])); + Box x8 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x8, x3, (arg2[1]), (arg3[1])); + Box x9 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x9, x3, (arg2[2]), (arg3[2])); + Box x10 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x10, x3, (arg2[3]), (arg3[3])); + Box x11 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x11, x3, (arg2[4]), (arg3[4])); + Box x12 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x12, x3, (arg2[5]), (arg3[5])); + Box x13 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x13, x3, (arg2[6]), (arg3[6])); + Box x14 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x14, x3, (arg2[7]), (arg3[7])); + Box x15 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x15, x3, (arg2[8]), (arg3[8])); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x16, x17, 0x0, 0x1, (~(arg2[0]))); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[8]))); + Box x34 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x34, x3, (arg3[0]), (x16).get()); + Box x35 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x35, x3, (arg3[1]), (x18).get()); + Box x36 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x36, x3, (arg3[2]), (x20).get()); + Box x37 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x37, x3, (arg3[3]), (x22).get()); + Box x38 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x38, x3, (arg3[4]), (x24).get()); + Box x39 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x39, x3, (arg3[5]), (x26).get()); + Box x40 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x40, x3, (arg3[6]), (x28).get()); + Box x41 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x41, x3, (arg3[7]), (x30).get()); + Box x42 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x42, x3, (arg3[8]), (x32).get()); + Box x43 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x43, x3, (arg4[0]), (arg5[0])); + Box x44 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x44, x3, (arg4[1]), (arg5[1])); + Box x45 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x45, x3, (arg4[2]), (arg5[2])); + Box x46 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x46, x3, (arg4[3]), (arg5[3])); + Box x47 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x47, x3, (arg4[4]), (arg5[4])); + Box x48 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x48, x3, (arg4[5]), (arg5[5])); + Box x49 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x49, x3, (arg4[6]), (arg5[6])); + Box x50 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x50, x3, (arg4[7]), (arg5[7])); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x51, x52, 0x0, (x43).get(), (x43).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x53, x54, (x52).get(), (x44).get(), (x44).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x55, x56, (x54).get(), (x45).get(), (x45).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x57, x58, (x56).get(), (x46).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x61, x62, (x60).get(), (x48).get(), (x48).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x63, x64, (x62).get(), (x49).get(), (x49).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x65, x66, (x64).get(), (x50).get(), (x50).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x67, x68, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x51).get(), 0xffffffff); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x69, x70, (x68).get(), (x53).get(), 0xffffffff); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x71, x72, (x70).get(), (x55).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x73, x74, (x72).get(), (x57).get(), 0xffffffff); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x75, x76, (x74).get(), (x59).get(), 0xffffffff); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x77, x78, (x76).get(), (x61).get(), 0xffffffff); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x79, x80, (x78).get(), (x63).get(), 0xffffffff); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x81, x82, (x80).get(), (x65).get(), 0xfffffffe); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_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_Sm2_subborrowx_u32(x107, x108, (x106).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x85); + Box x109 = new Box((int)0); + fiat_Sm2_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_Sm2_addcarryx_u32(x110, x111, 0x0, (x93).get(), (x109).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x112, x113, (x111).get(), (x95).get(), (x109).get()); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x114, x115, (x113).get(), (x97).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x116, x117, (x115).get(), (x99).get(), (x109).get()); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x118, x119, (x117).get(), (x101).get(), (x109).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x120, x121, (x119).get(), (x103).get(), (x109).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x122, x123, (x121).get(), (x105).get(), (x109).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x124, x125, (x123).get(), (x107).get(), ((x109).get() & 0xfffffffe)); + Box x126 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x126, x3, (arg5[0]), (x110).get()); + Box x127 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x127, x3, (arg5[1]), (x112).get()); + Box x128 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x128, x3, (arg5[2]), (x114).get()); + Box x129 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x129, x3, (arg5[3]), (x116).get()); + Box x130 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x130, x3, (arg5[4]), (x118).get()); + Box x131 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x131, x3, (arg5[5]), (x120).get()); + Box x132 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x132, x3, (arg5[6]), (x122).get()); + Box x133 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x133, x3, (arg5[7]), (x124).get()); + int x134 = ((x34).get() & 0x1); + Box x135 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x135, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x7).get()); + Box x136 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x136, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x8).get()); + Box x137 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x137, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x9).get()); + Box x138 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x138, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x139 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x139, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x140 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x140, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x12).get()); + Box x141 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x141, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x13).get()); + Box x142 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x142, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x143 = new Box((int)0); + fiat_Sm2_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_Sm2_addcarryx_u32(x144, x145, 0x0, (x34).get(), (x135).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x146, x147, (x145).get(), (x35).get(), (x136).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x148, x149, (x147).get(), (x36).get(), (x137).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x150, x151, (x149).get(), (x37).get(), (x138).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x152, x153, (x151).get(), (x38).get(), (x139).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x154, x155, (x153).get(), (x39).get(), (x140).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x156, x157, (x155).get(), (x40).get(), (x141).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x158, x159, (x157).get(), (x41).get(), (x142).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x160, x161, (x159).get(), (x42).get(), (x143).get()); + Box x162 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x162, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x43).get()); + Box x163 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x163, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x44).get()); + Box x164 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x164, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x45).get()); + Box x165 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x165, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x46).get()); + Box x166 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x166, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x47).get()); + Box x167 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x167, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x48).get()); + Box x168 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x168, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x49).get()); + Box x169 = new Box((int)0); + fiat_Sm2_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_Sm2_addcarryx_u32(x170, x171, 0x0, (x126).get(), (x162).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x172, x173, (x171).get(), (x127).get(), (x163).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x174, x175, (x173).get(), (x128).get(), (x164).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x176, x177, (x175).get(), (x129).get(), (x165).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x166).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x180, x181, (x179).get(), (x131).get(), (x167).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x182, x183, (x181).get(), (x132).get(), (x168).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Sm2_addcarryx_u32(x184, x185, (x183).get(), (x133).get(), (x169).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x186, x187, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x170).get(), 0xffffffff); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x188, x189, (x187).get(), (x172).get(), 0xffffffff); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Sm2_subborrowx_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_Sm2_subborrowx_u32(x192, x193, (x191).get(), (x176).get(), 0xffffffff); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x194, x195, (x193).get(), (x178).get(), 0xffffffff); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x196, x197, (x195).get(), (x180).get(), 0xffffffff); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x198, x199, (x197).get(), (x182).get(), 0xffffffff); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2_subborrowx_u32(x200, x201, (x199).get(), (x184).get(), 0xfffffffe); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_cmovznz_u32(x215, (x84).get(), (x67).get(), (x51).get()); + Box x216 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x216, (x84).get(), (x69).get(), (x53).get()); + Box x217 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x217, (x84).get(), (x71).get(), (x55).get()); + Box x218 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x218, (x84).get(), (x73).get(), (x57).get()); + Box x219 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x219, (x84).get(), (x75).get(), (x59).get()); + Box x220 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x220, (x84).get(), (x77).get(), (x61).get()); + Box x221 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x221, (x84).get(), (x79).get(), (x63).get()); + Box x222 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x222, (x84).get(), (x81).get(), (x65).get()); + Box x223 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x223, (x203).get(), (x186).get(), (x170).get()); + Box x224 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x224, (x203).get(), (x188).get(), (x172).get()); + Box x225 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x225, (x203).get(), (x190).get(), (x174).get()); + Box x226 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x226, (x203).get(), (x192).get(), (x176).get()); + Box x227 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x227, (x203).get(), (x194).get(), (x178).get()); + Box x228 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x228, (x203).get(), (x196).get(), (x180).get()); + Box x229 = new Box((int)0); + fiat_Sm2_cmovznz_u32(x229, (x203).get(), (x198).get(), (x182).get()); + Box x230 = new Box((int)0); + fiat_Sm2_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_Sm2_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_Sm2_divstep_precomp(int[] out1) { + out1[0] = 0x8ffffffe; + out1[1] = 0x50000002; + out1[2] = 0x9ffffffe; + out1[3] = 0xe8000000; + out1[4] = 0x8ffffffe; + out1[5] = 0xd0000001; + out1[6] = 0x1ffffffd; + out1[7] = 0x28000001; +} + +} diff --git a/fiat-java/src/FiatSm2Scalar.java b/fiat-java/src/FiatSm2Scalar.java new file mode 100644 index 00000000000..06cdc97d5af --- /dev/null +++ b/fiat-java/src/FiatSm2Scalar.java @@ -0,0 +1,5647 @@ +/* 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 Sm2Scalar 32 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */ +/* curve description: Sm2Scalar */ +/* 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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") */ +/* */ +/* 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 FiatSm2Scalar { + +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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x9, x10, x8, (arg2[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x11, x12, x8, (arg2[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x13, x14, x8, (arg2[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x15, x16, x8, (arg2[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x17, x18, x8, (arg2[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x19, x20, x8, (arg2[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x21, x22, x8, (arg2[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x23, x24, x8, (arg2[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x40, x41, (x23).get(), 0x72350975); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x42, x43, (x40).get(), 0xfffffffe); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x44, x45, (x40).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x46, x47, (x40).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x48, x49, (x40).get(), 0xffffffff); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x50, x51, (x40).get(), 0x7203df6b); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x52, x53, (x40).get(), 0x21c6052b); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x54, x55, (x40).get(), 0x53bbf409); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x56, x57, (x40).get(), 0x39d54123); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x58, x59, 0x0, (x57).get(), (x54).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x60, x61, (x59).get(), (x55).get(), (x52).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x62, x63, (x61).get(), (x53).get(), (x50).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x64, x65, (x63).get(), (x51).get(), (x48).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x66, x67, (x65).get(), (x49).get(), (x46).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x68, x69, (x67).get(), (x47).get(), (x44).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x73, x74, 0x0, (x23).get(), (x56).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x75, x76, (x74).get(), (x25).get(), (x58).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x77, x78, (x76).get(), (x27).get(), (x60).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x79, x80, (x78).get(), (x29).get(), (x62).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x81, x82, (x80).get(), (x31).get(), (x64).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x83, x84, (x82).get(), (x33).get(), (x66).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x85, x86, (x84).get(), (x35).get(), (x68).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x87, x88, (x86).get(), (x37).get(), (x70).get()); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x89, x90, (x88).get(), x39, x72); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x91, x92, x1, (arg2[7])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x93, x94, x1, (arg2[6])); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x95, x96, x1, (arg2[5])); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x97, x98, x1, (arg2[4])); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x99, x100, x1, (arg2[3])); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x101, x102, x1, (arg2[2])); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x103, x104, x1, (arg2[1])); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x105, x106, x1, (arg2[0])); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x107, x108, 0x0, (x106).get(), (x103).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x109, x110, (x108).get(), (x104).get(), (x101).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x111, x112, (x110).get(), (x102).get(), (x99).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x113, x114, (x112).get(), (x100).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x115, x116, (x114).get(), (x98).get(), (x95).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x117, x118, (x116).get(), (x96).get(), (x93).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x122, x123, 0x0, (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x124, x125, (x123).get(), (x77).get(), (x107).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x126, x127, (x125).get(), (x79).get(), (x109).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x128, x129, (x127).get(), (x81).get(), (x111).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x130, x131, (x129).get(), (x83).get(), (x113).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x132, x133, (x131).get(), (x85).get(), (x115).get()); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x134, x135, (x133).get(), (x87).get(), (x117).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x136, x137, (x135).get(), (x89).get(), (x119).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x138, x139, (x137).get(), (x90).get(), x121); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x140, x141, (x122).get(), 0x72350975); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x142, x143, (x140).get(), 0xfffffffe); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x144, x145, (x140).get(), 0xffffffff); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x146, x147, (x140).get(), 0xffffffff); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x148, x149, (x140).get(), 0xffffffff); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x150, x151, (x140).get(), 0x7203df6b); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x152, x153, (x140).get(), 0x21c6052b); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x154, x155, (x140).get(), 0x53bbf409); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x156, x157, (x140).get(), 0x39d54123); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x158, x159, 0x0, (x157).get(), (x154).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x160, x161, (x159).get(), (x155).get(), (x152).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x162, x163, (x161).get(), (x153).get(), (x150).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x164, x165, (x163).get(), (x151).get(), (x148).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x166, x167, (x165).get(), (x149).get(), (x146).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x168, x169, (x167).get(), (x147).get(), (x144).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x173, x174, 0x0, (x122).get(), (x156).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x175, x176, (x174).get(), (x124).get(), (x158).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x177, x178, (x176).get(), (x126).get(), (x160).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x179, x180, (x178).get(), (x128).get(), (x162).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x181, x182, (x180).get(), (x130).get(), (x164).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x183, x184, (x182).get(), (x132).get(), (x166).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x185, x186, (x184).get(), (x134).get(), (x168).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x187, x188, (x186).get(), (x136).get(), (x170).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x192, x193, x2, (arg2[7])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x194, x195, x2, (arg2[6])); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x196, x197, x2, (arg2[5])); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x198, x199, x2, (arg2[4])); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x200, x201, x2, (arg2[3])); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x202, x203, x2, (arg2[2])); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x204, x205, x2, (arg2[1])); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x206, x207, x2, (arg2[0])); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x208, x209, 0x0, (x207).get(), (x204).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x210, x211, (x209).get(), (x205).get(), (x202).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x212, x213, (x211).get(), (x203).get(), (x200).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x214, x215, (x213).get(), (x201).get(), (x198).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x216, x217, (x215).get(), (x199).get(), (x196).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x218, x219, (x217).get(), (x197).get(), (x194).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x223, x224, 0x0, (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x225, x226, (x224).get(), (x177).get(), (x208).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x227, x228, (x226).get(), (x179).get(), (x210).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x229, x230, (x228).get(), (x181).get(), (x212).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x231, x232, (x230).get(), (x183).get(), (x214).get()); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x233, x234, (x232).get(), (x185).get(), (x216).get()); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x235, x236, (x234).get(), (x187).get(), (x218).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x237, x238, (x236).get(), (x189).get(), (x220).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x239, x240, (x238).get(), x191, x222); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x241, x242, (x223).get(), 0x72350975); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x243, x244, (x241).get(), 0xfffffffe); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x245, x246, (x241).get(), 0xffffffff); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x247, x248, (x241).get(), 0xffffffff); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x249, x250, (x241).get(), 0xffffffff); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x251, x252, (x241).get(), 0x7203df6b); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x253, x254, (x241).get(), 0x21c6052b); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x255, x256, (x241).get(), 0x53bbf409); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x257, x258, (x241).get(), 0x39d54123); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x259, x260, 0x0, (x258).get(), (x255).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x261, x262, (x260).get(), (x256).get(), (x253).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x263, x264, (x262).get(), (x254).get(), (x251).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x265, x266, (x264).get(), (x252).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x267, x268, (x266).get(), (x250).get(), (x247).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x269, x270, (x268).get(), (x248).get(), (x245).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x274, x275, 0x0, (x223).get(), (x257).get()); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x276, x277, (x275).get(), (x225).get(), (x259).get()); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x278, x279, (x277).get(), (x227).get(), (x261).get()); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x280, x281, (x279).get(), (x229).get(), (x263).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x282, x283, (x281).get(), (x231).get(), (x265).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x284, x285, (x283).get(), (x233).get(), (x267).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x286, x287, (x285).get(), (x235).get(), (x269).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x288, x289, (x287).get(), (x237).get(), (x271).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x293, x294, x3, (arg2[7])); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x295, x296, x3, (arg2[6])); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x297, x298, x3, (arg2[5])); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x299, x300, x3, (arg2[4])); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x301, x302, x3, (arg2[3])); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x303, x304, x3, (arg2[2])); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x305, x306, x3, (arg2[1])); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x307, x308, x3, (arg2[0])); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x309, x310, 0x0, (x308).get(), (x305).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x311, x312, (x310).get(), (x306).get(), (x303).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x313, x314, (x312).get(), (x304).get(), (x301).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x315, x316, (x314).get(), (x302).get(), (x299).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x317, x318, (x316).get(), (x300).get(), (x297).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x319, x320, (x318).get(), (x298).get(), (x295).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x324, x325, 0x0, (x276).get(), (x307).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x326, x327, (x325).get(), (x278).get(), (x309).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x328, x329, (x327).get(), (x280).get(), (x311).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x330, x331, (x329).get(), (x282).get(), (x313).get()); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x332, x333, (x331).get(), (x284).get(), (x315).get()); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x334, x335, (x333).get(), (x286).get(), (x317).get()); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x336, x337, (x335).get(), (x288).get(), (x319).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x338, x339, (x337).get(), (x290).get(), (x321).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x340, x341, (x339).get(), x292, x323); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x342, x343, (x324).get(), 0x72350975); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x344, x345, (x342).get(), 0xfffffffe); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x346, x347, (x342).get(), 0xffffffff); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x348, x349, (x342).get(), 0xffffffff); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x350, x351, (x342).get(), 0xffffffff); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x352, x353, (x342).get(), 0x7203df6b); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x354, x355, (x342).get(), 0x21c6052b); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x356, x357, (x342).get(), 0x53bbf409); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x358, x359, (x342).get(), 0x39d54123); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x360, x361, 0x0, (x359).get(), (x356).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x362, x363, (x361).get(), (x357).get(), (x354).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x364, x365, (x363).get(), (x355).get(), (x352).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x366, x367, (x365).get(), (x353).get(), (x350).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x368, x369, (x367).get(), (x351).get(), (x348).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x370, x371, (x369).get(), (x349).get(), (x346).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x375, x376, 0x0, (x324).get(), (x358).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x377, x378, (x376).get(), (x326).get(), (x360).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x379, x380, (x378).get(), (x328).get(), (x362).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x381, x382, (x380).get(), (x330).get(), (x364).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x383, x384, (x382).get(), (x332).get(), (x366).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x385, x386, (x384).get(), (x334).get(), (x368).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x387, x388, (x386).get(), (x336).get(), (x370).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x389, x390, (x388).get(), (x338).get(), (x372).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x394, x395, x4, (arg2[7])); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x396, x397, x4, (arg2[6])); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x398, x399, x4, (arg2[5])); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x400, x401, x4, (arg2[4])); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x402, x403, x4, (arg2[3])); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x404, x405, x4, (arg2[2])); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x406, x407, x4, (arg2[1])); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x408, x409, x4, (arg2[0])); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x410, x411, 0x0, (x409).get(), (x406).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x412, x413, (x411).get(), (x407).get(), (x404).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x414, x415, (x413).get(), (x405).get(), (x402).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x416, x417, (x415).get(), (x403).get(), (x400).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x418, x419, (x417).get(), (x401).get(), (x398).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x420, x421, (x419).get(), (x399).get(), (x396).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x425, x426, 0x0, (x377).get(), (x408).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x427, x428, (x426).get(), (x379).get(), (x410).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x429, x430, (x428).get(), (x381).get(), (x412).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x431, x432, (x430).get(), (x383).get(), (x414).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x433, x434, (x432).get(), (x385).get(), (x416).get()); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x435, x436, (x434).get(), (x387).get(), (x418).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x437, x438, (x436).get(), (x389).get(), (x420).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x439, x440, (x438).get(), (x391).get(), (x422).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x441, x442, (x440).get(), x393, x424); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x443, x444, (x425).get(), 0x72350975); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x445, x446, (x443).get(), 0xfffffffe); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x447, x448, (x443).get(), 0xffffffff); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x449, x450, (x443).get(), 0xffffffff); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x451, x452, (x443).get(), 0xffffffff); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x453, x454, (x443).get(), 0x7203df6b); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x455, x456, (x443).get(), 0x21c6052b); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x457, x458, (x443).get(), 0x53bbf409); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x459, x460, (x443).get(), 0x39d54123); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x461, x462, 0x0, (x460).get(), (x457).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x463, x464, (x462).get(), (x458).get(), (x455).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x465, x466, (x464).get(), (x456).get(), (x453).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x467, x468, (x466).get(), (x454).get(), (x451).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x469, x470, (x468).get(), (x452).get(), (x449).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x471, x472, (x470).get(), (x450).get(), (x447).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x476, x477, 0x0, (x425).get(), (x459).get()); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x478, x479, (x477).get(), (x427).get(), (x461).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x480, x481, (x479).get(), (x429).get(), (x463).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x482, x483, (x481).get(), (x431).get(), (x465).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x484, x485, (x483).get(), (x433).get(), (x467).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x486, x487, (x485).get(), (x435).get(), (x469).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x488, x489, (x487).get(), (x437).get(), (x471).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x490, x491, (x489).get(), (x439).get(), (x473).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x495, x496, x5, (arg2[7])); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x497, x498, x5, (arg2[6])); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x499, x500, x5, (arg2[5])); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x501, x502, x5, (arg2[4])); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x503, x504, x5, (arg2[3])); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x505, x506, x5, (arg2[2])); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x507, x508, x5, (arg2[1])); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x509, x510, x5, (arg2[0])); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x511, x512, 0x0, (x510).get(), (x507).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x513, x514, (x512).get(), (x508).get(), (x505).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x515, x516, (x514).get(), (x506).get(), (x503).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x517, x518, (x516).get(), (x504).get(), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x519, x520, (x518).get(), (x502).get(), (x499).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x521, x522, (x520).get(), (x500).get(), (x497).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x526, x527, 0x0, (x478).get(), (x509).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x528, x529, (x527).get(), (x480).get(), (x511).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x530, x531, (x529).get(), (x482).get(), (x513).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x532, x533, (x531).get(), (x484).get(), (x515).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x534, x535, (x533).get(), (x486).get(), (x517).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x536, x537, (x535).get(), (x488).get(), (x519).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x538, x539, (x537).get(), (x490).get(), (x521).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x540, x541, (x539).get(), (x492).get(), (x523).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x542, x543, (x541).get(), x494, x525); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x544, x545, (x526).get(), 0x72350975); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x546, x547, (x544).get(), 0xfffffffe); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x548, x549, (x544).get(), 0xffffffff); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x550, x551, (x544).get(), 0xffffffff); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x552, x553, (x544).get(), 0xffffffff); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x554, x555, (x544).get(), 0x7203df6b); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x556, x557, (x544).get(), 0x21c6052b); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x558, x559, (x544).get(), 0x53bbf409); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x560, x561, (x544).get(), 0x39d54123); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x562, x563, 0x0, (x561).get(), (x558).get()); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x564, x565, (x563).get(), (x559).get(), (x556).get()); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x566, x567, (x565).get(), (x557).get(), (x554).get()); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x568, x569, (x567).get(), (x555).get(), (x552).get()); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x570, x571, (x569).get(), (x553).get(), (x550).get()); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x572, x573, (x571).get(), (x551).get(), (x548).get()); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x577, x578, 0x0, (x526).get(), (x560).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x579, x580, (x578).get(), (x528).get(), (x562).get()); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x581, x582, (x580).get(), (x530).get(), (x564).get()); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x583, x584, (x582).get(), (x532).get(), (x566).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x585, x586, (x584).get(), (x534).get(), (x568).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x587, x588, (x586).get(), (x536).get(), (x570).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x589, x590, (x588).get(), (x538).get(), (x572).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x591, x592, (x590).get(), (x540).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x596, x597, x6, (arg2[7])); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x598, x599, x6, (arg2[6])); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x600, x601, x6, (arg2[5])); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x602, x603, x6, (arg2[4])); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x604, x605, x6, (arg2[3])); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x606, x607, x6, (arg2[2])); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x608, x609, x6, (arg2[1])); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x610, x611, x6, (arg2[0])); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x612, x613, 0x0, (x611).get(), (x608).get()); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x614, x615, (x613).get(), (x609).get(), (x606).get()); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x616, x617, (x615).get(), (x607).get(), (x604).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x618, x619, (x617).get(), (x605).get(), (x602).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x620, x621, (x619).get(), (x603).get(), (x600).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x622, x623, (x621).get(), (x601).get(), (x598).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x627, x628, 0x0, (x579).get(), (x610).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x629, x630, (x628).get(), (x581).get(), (x612).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x631, x632, (x630).get(), (x583).get(), (x614).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x633, x634, (x632).get(), (x585).get(), (x616).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x635, x636, (x634).get(), (x587).get(), (x618).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x637, x638, (x636).get(), (x589).get(), (x620).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x639, x640, (x638).get(), (x591).get(), (x622).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x641, x642, (x640).get(), (x593).get(), (x624).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x643, x644, (x642).get(), x595, x626); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x645, x646, (x627).get(), 0x72350975); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x647, x648, (x645).get(), 0xfffffffe); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x649, x650, (x645).get(), 0xffffffff); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x651, x652, (x645).get(), 0xffffffff); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x653, x654, (x645).get(), 0xffffffff); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x655, x656, (x645).get(), 0x7203df6b); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x657, x658, (x645).get(), 0x21c6052b); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x659, x660, (x645).get(), 0x53bbf409); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x661, x662, (x645).get(), 0x39d54123); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x663, x664, 0x0, (x662).get(), (x659).get()); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x665, x666, (x664).get(), (x660).get(), (x657).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x667, x668, (x666).get(), (x658).get(), (x655).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x669, x670, (x668).get(), (x656).get(), (x653).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x671, x672, (x670).get(), (x654).get(), (x651).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x673, x674, (x672).get(), (x652).get(), (x649).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x678, x679, 0x0, (x627).get(), (x661).get()); + Box x680 = new Box((int)0); + Box x681 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x680, x681, (x679).get(), (x629).get(), (x663).get()); + Box x682 = new Box((int)0); + Box x683 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x682, x683, (x681).get(), (x631).get(), (x665).get()); + Box x684 = new Box((int)0); + Box x685 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x684, x685, (x683).get(), (x633).get(), (x667).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x686, x687, (x685).get(), (x635).get(), (x669).get()); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x688, x689, (x687).get(), (x637).get(), (x671).get()); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x690, x691, (x689).get(), (x639).get(), (x673).get()); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x692, x693, (x691).get(), (x641).get(), (x675).get()); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x697, x698, x7, (arg2[7])); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x699, x700, x7, (arg2[6])); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x701, x702, x7, (arg2[5])); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x703, x704, x7, (arg2[4])); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x705, x706, x7, (arg2[3])); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x707, x708, x7, (arg2[2])); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x709, x710, x7, (arg2[1])); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x711, x712, x7, (arg2[0])); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x713, x714, 0x0, (x712).get(), (x709).get()); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x715, x716, (x714).get(), (x710).get(), (x707).get()); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x717, x718, (x716).get(), (x708).get(), (x705).get()); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x719, x720, (x718).get(), (x706).get(), (x703).get()); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x721, x722, (x720).get(), (x704).get(), (x701).get()); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x723, x724, (x722).get(), (x702).get(), (x699).get()); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x728, x729, 0x0, (x680).get(), (x711).get()); + Box x730 = new Box((int)0); + Box x731 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x730, x731, (x729).get(), (x682).get(), (x713).get()); + Box x732 = new Box((int)0); + Box x733 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x732, x733, (x731).get(), (x684).get(), (x715).get()); + Box x734 = new Box((int)0); + Box x735 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x734, x735, (x733).get(), (x686).get(), (x717).get()); + Box x736 = new Box((int)0); + Box x737 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x736, x737, (x735).get(), (x688).get(), (x719).get()); + Box x738 = new Box((int)0); + Box x739 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x738, x739, (x737).get(), (x690).get(), (x721).get()); + Box x740 = new Box((int)0); + Box x741 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x740, x741, (x739).get(), (x692).get(), (x723).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x742, x743, (x741).get(), (x694).get(), (x725).get()); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x744, x745, (x743).get(), x696, x727); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x746, x747, (x728).get(), 0x72350975); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x748, x749, (x746).get(), 0xfffffffe); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x750, x751, (x746).get(), 0xffffffff); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x752, x753, (x746).get(), 0xffffffff); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x754, x755, (x746).get(), 0xffffffff); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x756, x757, (x746).get(), 0x7203df6b); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x758, x759, (x746).get(), 0x21c6052b); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x760, x761, (x746).get(), 0x53bbf409); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x762, x763, (x746).get(), 0x39d54123); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x764, x765, 0x0, (x763).get(), (x760).get()); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x766, x767, (x765).get(), (x761).get(), (x758).get()); + Box x768 = new Box((int)0); + Box x769 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x768, x769, (x767).get(), (x759).get(), (x756).get()); + Box x770 = new Box((int)0); + Box x771 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x770, x771, (x769).get(), (x757).get(), (x754).get()); + Box x772 = new Box((int)0); + Box x773 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x772, x773, (x771).get(), (x755).get(), (x752).get()); + Box x774 = new Box((int)0); + Box x775 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x774, x775, (x773).get(), (x753).get(), (x750).get()); + Box x776 = new Box((int)0); + Box x777 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x779, x780, 0x0, (x728).get(), (x762).get()); + Box x781 = new Box((int)0); + Box x782 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x781, x782, (x780).get(), (x730).get(), (x764).get()); + Box x783 = new Box((int)0); + Box x784 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x783, x784, (x782).get(), (x732).get(), (x766).get()); + Box x785 = new Box((int)0); + Box x786 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x785, x786, (x784).get(), (x734).get(), (x768).get()); + Box x787 = new Box((int)0); + Box x788 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x787, x788, (x786).get(), (x736).get(), (x770).get()); + Box x789 = new Box((int)0); + Box x790 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x789, x790, (x788).get(), (x738).get(), (x772).get()); + Box x791 = new Box((int)0); + Box x792 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x791, x792, (x790).get(), (x740).get(), (x774).get()); + Box x793 = new Box((int)0); + Box x794 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x793, x794, (x792).get(), (x742).get(), (x776).get()); + Box x795 = new Box((int)0); + Box x796 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_subborrowx_u32(x798, x799, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x781).get(), 0x39d54123); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x800, x801, (x799).get(), (x783).get(), 0x53bbf409); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x802, x803, (x801).get(), (x785).get(), 0x21c6052b); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x804, x805, (x803).get(), (x787).get(), 0x7203df6b); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x806, x807, (x805).get(), (x789).get(), 0xffffffff); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x808, x809, (x807).get(), (x791).get(), 0xffffffff); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x810, x811, (x809).get(), (x793).get(), 0xffffffff); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x812, x813, (x811).get(), (x795).get(), 0xfffffffe); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x814, x815, (x813).get(), x797, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x816 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x816, (x815).get(), (x798).get(), (x781).get()); + Box x817 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x817, (x815).get(), (x800).get(), (x783).get()); + Box x818 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x818, (x815).get(), (x802).get(), (x785).get()); + Box x819 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x819, (x815).get(), (x804).get(), (x787).get()); + Box x820 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x820, (x815).get(), (x806).get(), (x789).get()); + Box x821 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x821, (x815).get(), (x808).get(), (x791).get()); + Box x822 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x822, (x815).get(), (x810).get(), (x793).get()); + Box x823 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x9, x10, x8, (arg1[7])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x11, x12, x8, (arg1[6])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x13, x14, x8, (arg1[5])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x15, x16, x8, (arg1[4])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x17, x18, x8, (arg1[3])); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x19, x20, x8, (arg1[2])); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x21, x22, x8, (arg1[1])); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x23, x24, x8, (arg1[0])); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x40, x41, (x23).get(), 0x72350975); + Box x42 = new Box((int)0); + Box x43 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x42, x43, (x40).get(), 0xfffffffe); + Box x44 = new Box((int)0); + Box x45 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x44, x45, (x40).get(), 0xffffffff); + Box x46 = new Box((int)0); + Box x47 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x46, x47, (x40).get(), 0xffffffff); + Box x48 = new Box((int)0); + Box x49 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x48, x49, (x40).get(), 0xffffffff); + Box x50 = new Box((int)0); + Box x51 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x50, x51, (x40).get(), 0x7203df6b); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x52, x53, (x40).get(), 0x21c6052b); + Box x54 = new Box((int)0); + Box x55 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x54, x55, (x40).get(), 0x53bbf409); + Box x56 = new Box((int)0); + Box x57 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x56, x57, (x40).get(), 0x39d54123); + Box x58 = new Box((int)0); + Box x59 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x58, x59, 0x0, (x57).get(), (x54).get()); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x60, x61, (x59).get(), (x55).get(), (x52).get()); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x62, x63, (x61).get(), (x53).get(), (x50).get()); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x64, x65, (x63).get(), (x51).get(), (x48).get()); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x66, x67, (x65).get(), (x49).get(), (x46).get()); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x68, x69, (x67).get(), (x47).get(), (x44).get()); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x73, x74, 0x0, (x23).get(), (x56).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x75, x76, (x74).get(), (x25).get(), (x58).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x77, x78, (x76).get(), (x27).get(), (x60).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x79, x80, (x78).get(), (x29).get(), (x62).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x81, x82, (x80).get(), (x31).get(), (x64).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x83, x84, (x82).get(), (x33).get(), (x66).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x85, x86, (x84).get(), (x35).get(), (x68).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x87, x88, (x86).get(), (x37).get(), (x70).get()); + Box x89 = new Box((int)0); + Box x90 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x89, x90, (x88).get(), x39, x72); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x91, x92, x1, (arg1[7])); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x93, x94, x1, (arg1[6])); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x95, x96, x1, (arg1[5])); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x97, x98, x1, (arg1[4])); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x99, x100, x1, (arg1[3])); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x101, x102, x1, (arg1[2])); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x103, x104, x1, (arg1[1])); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x105, x106, x1, (arg1[0])); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x107, x108, 0x0, (x106).get(), (x103).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x109, x110, (x108).get(), (x104).get(), (x101).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x111, x112, (x110).get(), (x102).get(), (x99).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x113, x114, (x112).get(), (x100).get(), (x97).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x115, x116, (x114).get(), (x98).get(), (x95).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x117, x118, (x116).get(), (x96).get(), (x93).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x122, x123, 0x0, (x75).get(), (x105).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x124, x125, (x123).get(), (x77).get(), (x107).get()); + Box x126 = new Box((int)0); + Box x127 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x126, x127, (x125).get(), (x79).get(), (x109).get()); + Box x128 = new Box((int)0); + Box x129 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x128, x129, (x127).get(), (x81).get(), (x111).get()); + Box x130 = new Box((int)0); + Box x131 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x130, x131, (x129).get(), (x83).get(), (x113).get()); + Box x132 = new Box((int)0); + Box x133 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x132, x133, (x131).get(), (x85).get(), (x115).get()); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x134, x135, (x133).get(), (x87).get(), (x117).get()); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x136, x137, (x135).get(), (x89).get(), (x119).get()); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x138, x139, (x137).get(), (x90).get(), x121); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x140, x141, (x122).get(), 0x72350975); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x142, x143, (x140).get(), 0xfffffffe); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x144, x145, (x140).get(), 0xffffffff); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x146, x147, (x140).get(), 0xffffffff); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x148, x149, (x140).get(), 0xffffffff); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x150, x151, (x140).get(), 0x7203df6b); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x152, x153, (x140).get(), 0x21c6052b); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x154, x155, (x140).get(), 0x53bbf409); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x156, x157, (x140).get(), 0x39d54123); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x158, x159, 0x0, (x157).get(), (x154).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x160, x161, (x159).get(), (x155).get(), (x152).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x162, x163, (x161).get(), (x153).get(), (x150).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x164, x165, (x163).get(), (x151).get(), (x148).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x166, x167, (x165).get(), (x149).get(), (x146).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x168, x169, (x167).get(), (x147).get(), (x144).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x173, x174, 0x0, (x122).get(), (x156).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x175, x176, (x174).get(), (x124).get(), (x158).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x177, x178, (x176).get(), (x126).get(), (x160).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x179, x180, (x178).get(), (x128).get(), (x162).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x181, x182, (x180).get(), (x130).get(), (x164).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x183, x184, (x182).get(), (x132).get(), (x166).get()); + Box x185 = new Box((int)0); + Box x186 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x185, x186, (x184).get(), (x134).get(), (x168).get()); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x187, x188, (x186).get(), (x136).get(), (x170).get()); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x192, x193, x2, (arg1[7])); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x194, x195, x2, (arg1[6])); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x196, x197, x2, (arg1[5])); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x198, x199, x2, (arg1[4])); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x200, x201, x2, (arg1[3])); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x202, x203, x2, (arg1[2])); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x204, x205, x2, (arg1[1])); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x206, x207, x2, (arg1[0])); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x208, x209, 0x0, (x207).get(), (x204).get()); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x210, x211, (x209).get(), (x205).get(), (x202).get()); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x212, x213, (x211).get(), (x203).get(), (x200).get()); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x214, x215, (x213).get(), (x201).get(), (x198).get()); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x216, x217, (x215).get(), (x199).get(), (x196).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x218, x219, (x217).get(), (x197).get(), (x194).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x223, x224, 0x0, (x175).get(), (x206).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x225, x226, (x224).get(), (x177).get(), (x208).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x227, x228, (x226).get(), (x179).get(), (x210).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x229, x230, (x228).get(), (x181).get(), (x212).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x231, x232, (x230).get(), (x183).get(), (x214).get()); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x233, x234, (x232).get(), (x185).get(), (x216).get()); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x235, x236, (x234).get(), (x187).get(), (x218).get()); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x237, x238, (x236).get(), (x189).get(), (x220).get()); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x239, x240, (x238).get(), x191, x222); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x241, x242, (x223).get(), 0x72350975); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x243, x244, (x241).get(), 0xfffffffe); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x245, x246, (x241).get(), 0xffffffff); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x247, x248, (x241).get(), 0xffffffff); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x249, x250, (x241).get(), 0xffffffff); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x251, x252, (x241).get(), 0x7203df6b); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x253, x254, (x241).get(), 0x21c6052b); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x255, x256, (x241).get(), 0x53bbf409); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x257, x258, (x241).get(), 0x39d54123); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x259, x260, 0x0, (x258).get(), (x255).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x261, x262, (x260).get(), (x256).get(), (x253).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x263, x264, (x262).get(), (x254).get(), (x251).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x265, x266, (x264).get(), (x252).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x267, x268, (x266).get(), (x250).get(), (x247).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x269, x270, (x268).get(), (x248).get(), (x245).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x274, x275, 0x0, (x223).get(), (x257).get()); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x276, x277, (x275).get(), (x225).get(), (x259).get()); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x278, x279, (x277).get(), (x227).get(), (x261).get()); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x280, x281, (x279).get(), (x229).get(), (x263).get()); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x282, x283, (x281).get(), (x231).get(), (x265).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x284, x285, (x283).get(), (x233).get(), (x267).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x286, x287, (x285).get(), (x235).get(), (x269).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x288, x289, (x287).get(), (x237).get(), (x271).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x293, x294, x3, (arg1[7])); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x295, x296, x3, (arg1[6])); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x297, x298, x3, (arg1[5])); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x299, x300, x3, (arg1[4])); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x301, x302, x3, (arg1[3])); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x303, x304, x3, (arg1[2])); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x305, x306, x3, (arg1[1])); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x307, x308, x3, (arg1[0])); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x309, x310, 0x0, (x308).get(), (x305).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x311, x312, (x310).get(), (x306).get(), (x303).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x313, x314, (x312).get(), (x304).get(), (x301).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x315, x316, (x314).get(), (x302).get(), (x299).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x317, x318, (x316).get(), (x300).get(), (x297).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x319, x320, (x318).get(), (x298).get(), (x295).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x324, x325, 0x0, (x276).get(), (x307).get()); + Box x326 = new Box((int)0); + Box x327 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x326, x327, (x325).get(), (x278).get(), (x309).get()); + Box x328 = new Box((int)0); + Box x329 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x328, x329, (x327).get(), (x280).get(), (x311).get()); + Box x330 = new Box((int)0); + Box x331 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x330, x331, (x329).get(), (x282).get(), (x313).get()); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x332, x333, (x331).get(), (x284).get(), (x315).get()); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x334, x335, (x333).get(), (x286).get(), (x317).get()); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x336, x337, (x335).get(), (x288).get(), (x319).get()); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x338, x339, (x337).get(), (x290).get(), (x321).get()); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x340, x341, (x339).get(), x292, x323); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x342, x343, (x324).get(), 0x72350975); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x344, x345, (x342).get(), 0xfffffffe); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x346, x347, (x342).get(), 0xffffffff); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x348, x349, (x342).get(), 0xffffffff); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x350, x351, (x342).get(), 0xffffffff); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x352, x353, (x342).get(), 0x7203df6b); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x354, x355, (x342).get(), 0x21c6052b); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x356, x357, (x342).get(), 0x53bbf409); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x358, x359, (x342).get(), 0x39d54123); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x360, x361, 0x0, (x359).get(), (x356).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x362, x363, (x361).get(), (x357).get(), (x354).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x364, x365, (x363).get(), (x355).get(), (x352).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x366, x367, (x365).get(), (x353).get(), (x350).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x368, x369, (x367).get(), (x351).get(), (x348).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x370, x371, (x369).get(), (x349).get(), (x346).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x375, x376, 0x0, (x324).get(), (x358).get()); + Box x377 = new Box((int)0); + Box x378 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x377, x378, (x376).get(), (x326).get(), (x360).get()); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x379, x380, (x378).get(), (x328).get(), (x362).get()); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x381, x382, (x380).get(), (x330).get(), (x364).get()); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x383, x384, (x382).get(), (x332).get(), (x366).get()); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x385, x386, (x384).get(), (x334).get(), (x368).get()); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x387, x388, (x386).get(), (x336).get(), (x370).get()); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x389, x390, (x388).get(), (x338).get(), (x372).get()); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x394, x395, x4, (arg1[7])); + Box x396 = new Box((int)0); + Box x397 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x396, x397, x4, (arg1[6])); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x398, x399, x4, (arg1[5])); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x400, x401, x4, (arg1[4])); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x402, x403, x4, (arg1[3])); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x404, x405, x4, (arg1[2])); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x406, x407, x4, (arg1[1])); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x408, x409, x4, (arg1[0])); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x410, x411, 0x0, (x409).get(), (x406).get()); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x412, x413, (x411).get(), (x407).get(), (x404).get()); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x414, x415, (x413).get(), (x405).get(), (x402).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x416, x417, (x415).get(), (x403).get(), (x400).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x418, x419, (x417).get(), (x401).get(), (x398).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x420, x421, (x419).get(), (x399).get(), (x396).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x425, x426, 0x0, (x377).get(), (x408).get()); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x427, x428, (x426).get(), (x379).get(), (x410).get()); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x429, x430, (x428).get(), (x381).get(), (x412).get()); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x431, x432, (x430).get(), (x383).get(), (x414).get()); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x433, x434, (x432).get(), (x385).get(), (x416).get()); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x435, x436, (x434).get(), (x387).get(), (x418).get()); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x437, x438, (x436).get(), (x389).get(), (x420).get()); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x439, x440, (x438).get(), (x391).get(), (x422).get()); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x441, x442, (x440).get(), x393, x424); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x443, x444, (x425).get(), 0x72350975); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x445, x446, (x443).get(), 0xfffffffe); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x447, x448, (x443).get(), 0xffffffff); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x449, x450, (x443).get(), 0xffffffff); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x451, x452, (x443).get(), 0xffffffff); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x453, x454, (x443).get(), 0x7203df6b); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x455, x456, (x443).get(), 0x21c6052b); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x457, x458, (x443).get(), 0x53bbf409); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x459, x460, (x443).get(), 0x39d54123); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x461, x462, 0x0, (x460).get(), (x457).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x463, x464, (x462).get(), (x458).get(), (x455).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x465, x466, (x464).get(), (x456).get(), (x453).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x467, x468, (x466).get(), (x454).get(), (x451).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x469, x470, (x468).get(), (x452).get(), (x449).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x471, x472, (x470).get(), (x450).get(), (x447).get()); + Box x473 = new Box((int)0); + Box x474 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x476, x477, 0x0, (x425).get(), (x459).get()); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x478, x479, (x477).get(), (x427).get(), (x461).get()); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x480, x481, (x479).get(), (x429).get(), (x463).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x482, x483, (x481).get(), (x431).get(), (x465).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x484, x485, (x483).get(), (x433).get(), (x467).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x486, x487, (x485).get(), (x435).get(), (x469).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x488, x489, (x487).get(), (x437).get(), (x471).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x490, x491, (x489).get(), (x439).get(), (x473).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x495, x496, x5, (arg1[7])); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x497, x498, x5, (arg1[6])); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x499, x500, x5, (arg1[5])); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x501, x502, x5, (arg1[4])); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x503, x504, x5, (arg1[3])); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x505, x506, x5, (arg1[2])); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x507, x508, x5, (arg1[1])); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x509, x510, x5, (arg1[0])); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x511, x512, 0x0, (x510).get(), (x507).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x513, x514, (x512).get(), (x508).get(), (x505).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x515, x516, (x514).get(), (x506).get(), (x503).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x517, x518, (x516).get(), (x504).get(), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x519, x520, (x518).get(), (x502).get(), (x499).get()); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x521, x522, (x520).get(), (x500).get(), (x497).get()); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x526, x527, 0x0, (x478).get(), (x509).get()); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x528, x529, (x527).get(), (x480).get(), (x511).get()); + Box x530 = new Box((int)0); + Box x531 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x530, x531, (x529).get(), (x482).get(), (x513).get()); + Box x532 = new Box((int)0); + Box x533 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x532, x533, (x531).get(), (x484).get(), (x515).get()); + Box x534 = new Box((int)0); + Box x535 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x534, x535, (x533).get(), (x486).get(), (x517).get()); + Box x536 = new Box((int)0); + Box x537 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x536, x537, (x535).get(), (x488).get(), (x519).get()); + Box x538 = new Box((int)0); + Box x539 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x538, x539, (x537).get(), (x490).get(), (x521).get()); + Box x540 = new Box((int)0); + Box x541 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x540, x541, (x539).get(), (x492).get(), (x523).get()); + Box x542 = new Box((int)0); + Box x543 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x542, x543, (x541).get(), x494, x525); + Box x544 = new Box((int)0); + Box x545 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x544, x545, (x526).get(), 0x72350975); + Box x546 = new Box((int)0); + Box x547 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x546, x547, (x544).get(), 0xfffffffe); + Box x548 = new Box((int)0); + Box x549 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x548, x549, (x544).get(), 0xffffffff); + Box x550 = new Box((int)0); + Box x551 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x550, x551, (x544).get(), 0xffffffff); + Box x552 = new Box((int)0); + Box x553 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x552, x553, (x544).get(), 0xffffffff); + Box x554 = new Box((int)0); + Box x555 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x554, x555, (x544).get(), 0x7203df6b); + Box x556 = new Box((int)0); + Box x557 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x556, x557, (x544).get(), 0x21c6052b); + Box x558 = new Box((int)0); + Box x559 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x558, x559, (x544).get(), 0x53bbf409); + Box x560 = new Box((int)0); + Box x561 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x560, x561, (x544).get(), 0x39d54123); + Box x562 = new Box((int)0); + Box x563 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x562, x563, 0x0, (x561).get(), (x558).get()); + Box x564 = new Box((int)0); + Box x565 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x564, x565, (x563).get(), (x559).get(), (x556).get()); + Box x566 = new Box((int)0); + Box x567 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x566, x567, (x565).get(), (x557).get(), (x554).get()); + Box x568 = new Box((int)0); + Box x569 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x568, x569, (x567).get(), (x555).get(), (x552).get()); + Box x570 = new Box((int)0); + Box x571 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x570, x571, (x569).get(), (x553).get(), (x550).get()); + Box x572 = new Box((int)0); + Box x573 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x572, x573, (x571).get(), (x551).get(), (x548).get()); + Box x574 = new Box((int)0); + Box x575 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x577, x578, 0x0, (x526).get(), (x560).get()); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x579, x580, (x578).get(), (x528).get(), (x562).get()); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x581, x582, (x580).get(), (x530).get(), (x564).get()); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x583, x584, (x582).get(), (x532).get(), (x566).get()); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x585, x586, (x584).get(), (x534).get(), (x568).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x587, x588, (x586).get(), (x536).get(), (x570).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x589, x590, (x588).get(), (x538).get(), (x572).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x591, x592, (x590).get(), (x540).get(), (x574).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x596, x597, x6, (arg1[7])); + Box x598 = new Box((int)0); + Box x599 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x598, x599, x6, (arg1[6])); + Box x600 = new Box((int)0); + Box x601 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x600, x601, x6, (arg1[5])); + Box x602 = new Box((int)0); + Box x603 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x602, x603, x6, (arg1[4])); + Box x604 = new Box((int)0); + Box x605 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x604, x605, x6, (arg1[3])); + Box x606 = new Box((int)0); + Box x607 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x606, x607, x6, (arg1[2])); + Box x608 = new Box((int)0); + Box x609 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x608, x609, x6, (arg1[1])); + Box x610 = new Box((int)0); + Box x611 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x610, x611, x6, (arg1[0])); + Box x612 = new Box((int)0); + Box x613 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x612, x613, 0x0, (x611).get(), (x608).get()); + Box x614 = new Box((int)0); + Box x615 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x614, x615, (x613).get(), (x609).get(), (x606).get()); + Box x616 = new Box((int)0); + Box x617 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x616, x617, (x615).get(), (x607).get(), (x604).get()); + Box x618 = new Box((int)0); + Box x619 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x618, x619, (x617).get(), (x605).get(), (x602).get()); + Box x620 = new Box((int)0); + Box x621 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x620, x621, (x619).get(), (x603).get(), (x600).get()); + Box x622 = new Box((int)0); + Box x623 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x622, x623, (x621).get(), (x601).get(), (x598).get()); + Box x624 = new Box((int)0); + Box x625 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x627, x628, 0x0, (x579).get(), (x610).get()); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x629, x630, (x628).get(), (x581).get(), (x612).get()); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x631, x632, (x630).get(), (x583).get(), (x614).get()); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x633, x634, (x632).get(), (x585).get(), (x616).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x635, x636, (x634).get(), (x587).get(), (x618).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x637, x638, (x636).get(), (x589).get(), (x620).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x639, x640, (x638).get(), (x591).get(), (x622).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x641, x642, (x640).get(), (x593).get(), (x624).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x643, x644, (x642).get(), x595, x626); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x645, x646, (x627).get(), 0x72350975); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x647, x648, (x645).get(), 0xfffffffe); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x649, x650, (x645).get(), 0xffffffff); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x651, x652, (x645).get(), 0xffffffff); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x653, x654, (x645).get(), 0xffffffff); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x655, x656, (x645).get(), 0x7203df6b); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x657, x658, (x645).get(), 0x21c6052b); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x659, x660, (x645).get(), 0x53bbf409); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x661, x662, (x645).get(), 0x39d54123); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x663, x664, 0x0, (x662).get(), (x659).get()); + Box x665 = new Box((int)0); + Box x666 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x665, x666, (x664).get(), (x660).get(), (x657).get()); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x667, x668, (x666).get(), (x658).get(), (x655).get()); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x669, x670, (x668).get(), (x656).get(), (x653).get()); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x671, x672, (x670).get(), (x654).get(), (x651).get()); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x673, x674, (x672).get(), (x652).get(), (x649).get()); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x678, x679, 0x0, (x627).get(), (x661).get()); + Box x680 = new Box((int)0); + Box x681 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x680, x681, (x679).get(), (x629).get(), (x663).get()); + Box x682 = new Box((int)0); + Box x683 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x682, x683, (x681).get(), (x631).get(), (x665).get()); + Box x684 = new Box((int)0); + Box x685 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x684, x685, (x683).get(), (x633).get(), (x667).get()); + Box x686 = new Box((int)0); + Box x687 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x686, x687, (x685).get(), (x635).get(), (x669).get()); + Box x688 = new Box((int)0); + Box x689 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x688, x689, (x687).get(), (x637).get(), (x671).get()); + Box x690 = new Box((int)0); + Box x691 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x690, x691, (x689).get(), (x639).get(), (x673).get()); + Box x692 = new Box((int)0); + Box x693 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x692, x693, (x691).get(), (x641).get(), (x675).get()); + Box x694 = new Box((int)0); + Box x695 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x697, x698, x7, (arg1[7])); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x699, x700, x7, (arg1[6])); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x701, x702, x7, (arg1[5])); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x703, x704, x7, (arg1[4])); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x705, x706, x7, (arg1[3])); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x707, x708, x7, (arg1[2])); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x709, x710, x7, (arg1[1])); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x711, x712, x7, (arg1[0])); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x713, x714, 0x0, (x712).get(), (x709).get()); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x715, x716, (x714).get(), (x710).get(), (x707).get()); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x717, x718, (x716).get(), (x708).get(), (x705).get()); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x719, x720, (x718).get(), (x706).get(), (x703).get()); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x721, x722, (x720).get(), (x704).get(), (x701).get()); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x723, x724, (x722).get(), (x702).get(), (x699).get()); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x728, x729, 0x0, (x680).get(), (x711).get()); + Box x730 = new Box((int)0); + Box x731 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x730, x731, (x729).get(), (x682).get(), (x713).get()); + Box x732 = new Box((int)0); + Box x733 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x732, x733, (x731).get(), (x684).get(), (x715).get()); + Box x734 = new Box((int)0); + Box x735 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x734, x735, (x733).get(), (x686).get(), (x717).get()); + Box x736 = new Box((int)0); + Box x737 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x736, x737, (x735).get(), (x688).get(), (x719).get()); + Box x738 = new Box((int)0); + Box x739 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x738, x739, (x737).get(), (x690).get(), (x721).get()); + Box x740 = new Box((int)0); + Box x741 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x740, x741, (x739).get(), (x692).get(), (x723).get()); + Box x742 = new Box((int)0); + Box x743 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x742, x743, (x741).get(), (x694).get(), (x725).get()); + Box x744 = new Box((int)0); + Box x745 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x744, x745, (x743).get(), x696, x727); + Box x746 = new Box((int)0); + Box x747 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x746, x747, (x728).get(), 0x72350975); + Box x748 = new Box((int)0); + Box x749 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x748, x749, (x746).get(), 0xfffffffe); + Box x750 = new Box((int)0); + Box x751 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x750, x751, (x746).get(), 0xffffffff); + Box x752 = new Box((int)0); + Box x753 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x752, x753, (x746).get(), 0xffffffff); + Box x754 = new Box((int)0); + Box x755 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x754, x755, (x746).get(), 0xffffffff); + Box x756 = new Box((int)0); + Box x757 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x756, x757, (x746).get(), 0x7203df6b); + Box x758 = new Box((int)0); + Box x759 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x758, x759, (x746).get(), 0x21c6052b); + Box x760 = new Box((int)0); + Box x761 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x760, x761, (x746).get(), 0x53bbf409); + Box x762 = new Box((int)0); + Box x763 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x762, x763, (x746).get(), 0x39d54123); + Box x764 = new Box((int)0); + Box x765 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x764, x765, 0x0, (x763).get(), (x760).get()); + Box x766 = new Box((int)0); + Box x767 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x766, x767, (x765).get(), (x761).get(), (x758).get()); + Box x768 = new Box((int)0); + Box x769 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x768, x769, (x767).get(), (x759).get(), (x756).get()); + Box x770 = new Box((int)0); + Box x771 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x770, x771, (x769).get(), (x757).get(), (x754).get()); + Box x772 = new Box((int)0); + Box x773 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x772, x773, (x771).get(), (x755).get(), (x752).get()); + Box x774 = new Box((int)0); + Box x775 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x774, x775, (x773).get(), (x753).get(), (x750).get()); + Box x776 = new Box((int)0); + Box x777 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x779, x780, 0x0, (x728).get(), (x762).get()); + Box x781 = new Box((int)0); + Box x782 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x781, x782, (x780).get(), (x730).get(), (x764).get()); + Box x783 = new Box((int)0); + Box x784 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x783, x784, (x782).get(), (x732).get(), (x766).get()); + Box x785 = new Box((int)0); + Box x786 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x785, x786, (x784).get(), (x734).get(), (x768).get()); + Box x787 = new Box((int)0); + Box x788 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x787, x788, (x786).get(), (x736).get(), (x770).get()); + Box x789 = new Box((int)0); + Box x790 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x789, x790, (x788).get(), (x738).get(), (x772).get()); + Box x791 = new Box((int)0); + Box x792 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x791, x792, (x790).get(), (x740).get(), (x774).get()); + Box x793 = new Box((int)0); + Box x794 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x793, x794, (x792).get(), (x742).get(), (x776).get()); + Box x795 = new Box((int)0); + Box x796 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_subborrowx_u32(x798, x799, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x781).get(), 0x39d54123); + Box x800 = new Box((int)0); + Box x801 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x800, x801, (x799).get(), (x783).get(), 0x53bbf409); + Box x802 = new Box((int)0); + Box x803 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x802, x803, (x801).get(), (x785).get(), 0x21c6052b); + Box x804 = new Box((int)0); + Box x805 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x804, x805, (x803).get(), (x787).get(), 0x7203df6b); + Box x806 = new Box((int)0); + Box x807 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x806, x807, (x805).get(), (x789).get(), 0xffffffff); + Box x808 = new Box((int)0); + Box x809 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x808, x809, (x807).get(), (x791).get(), 0xffffffff); + Box x810 = new Box((int)0); + Box x811 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x810, x811, (x809).get(), (x793).get(), 0xffffffff); + Box x812 = new Box((int)0); + Box x813 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x812, x813, (x811).get(), (x795).get(), 0xfffffffe); + Box x814 = new Box((int)0); + Box x815 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x814, x815, (x813).get(), x797, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x816 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x816, (x815).get(), (x798).get(), (x781).get()); + Box x817 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x817, (x815).get(), (x800).get(), (x783).get()); + Box x818 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x818, (x815).get(), (x802).get(), (x785).get()); + Box x819 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x819, (x815).get(), (x804).get(), (x787).get()); + Box x820 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x820, (x815).get(), (x806).get(), (x789).get()); + Box x821 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x821, (x815).get(), (x808).get(), (x791).get()); + Box x822 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x822, (x815).get(), (x810).get(), (x793).get()); + Box x823 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_add(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x17, x18, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x1).get(), 0x39d54123); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x19, x20, (x18).get(), (x3).get(), 0x53bbf409); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x21, x22, (x20).get(), (x5).get(), 0x21c6052b); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x23, x24, (x22).get(), (x7).get(), 0x7203df6b); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x25, x26, (x24).get(), (x9).get(), 0xffffffff); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x27, x28, (x26).get(), (x11).get(), 0xffffffff); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x29, x30, (x28).get(), (x13).get(), 0xffffffff); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x31, x32, (x30).get(), (x15).get(), 0xfffffffe); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x33, x34, (x32).get(), (x16).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x35 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x35, (x34).get(), (x17).get(), (x1).get()); + Box x36 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x36, (x34).get(), (x19).get(), (x3).get()); + Box x37 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x37, (x34).get(), (x21).get(), (x5).get()); + Box x38 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x38, (x34).get(), (x23).get(), (x7).get()); + Box x39 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x39, (x34).get(), (x25).get(), (x9).get()); + Box x40 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x40, (x34).get(), (x27).get(), (x11).get()); + Box x41 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x41, (x34).get(), (x29).get(), (x13).get()); + Box x42 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_sub(int[] out1, final int[] arg1, final int[] arg2) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x1, x2, 0x0, (arg1[0]), (arg2[0])); + Box x3 = new Box((int)0); + Box x4 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x3, x4, (x2).get(), (arg1[1]), (arg2[1])); + Box x5 = new Box((int)0); + Box x6 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x5, x6, (x4).get(), (arg1[2]), (arg2[2])); + Box x7 = new Box((int)0); + Box x8 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x7, x8, (x6).get(), (arg1[3]), (arg2[3])); + Box x9 = new Box((int)0); + Box x10 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x9, x10, (x8).get(), (arg1[4]), (arg2[4])); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x11, x12, (x10).get(), (arg1[5]), (arg2[5])); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x13, x14, (x12).get(), (arg1[6]), (arg2[6])); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x15, x16, (x14).get(), (arg1[7]), (arg2[7])); + Box x17 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0x39d54123)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0x53bbf409)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0x21c6052b)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0x7203df6b)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x17).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (x17).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), ((x17).get() & 0xfffffffe)); + 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_Sm2Scalar_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_Sm2Scalar_opp(int[] out1, final int[] arg1) { + Box x1 = new Box((int)0); + Box x2 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_subborrowx_u32(x15, x16, (x14).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (arg1[7])); + Box x17 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x18, x19, 0x0, (x1).get(), ((x17).get() & 0x39d54123)); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x20, x21, (x19).get(), (x3).get(), ((x17).get() & 0x53bbf409)); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x22, x23, (x21).get(), (x5).get(), ((x17).get() & 0x21c6052b)); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x24, x25, (x23).get(), (x7).get(), ((x17).get() & 0x7203df6b)); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x26, x27, (x25).get(), (x9).get(), (x17).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x17).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x30, x31, (x29).get(), (x13).get(), (x17).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x32, x33, (x31).get(), (x15).get(), ((x17).get() & 0xfffffffe)); + 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_Sm2Scalar_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_Sm2Scalar_from_montgomery(int[] out1, final int[] arg1) { + int x1 = (arg1[0]); + Box x2 = new Box((int)0); + Box x3 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x2, x3, x1, 0x72350975); + Box x4 = new Box((int)0); + Box x5 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x4, x5, (x2).get(), 0xfffffffe); + Box x6 = new Box((int)0); + Box x7 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x6, x7, (x2).get(), 0xffffffff); + Box x8 = new Box((int)0); + Box x9 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x8, x9, (x2).get(), 0xffffffff); + Box x10 = new Box((int)0); + Box x11 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x10, x11, (x2).get(), 0xffffffff); + Box x12 = new Box((int)0); + Box x13 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x12, x13, (x2).get(), 0x7203df6b); + Box x14 = new Box((int)0); + Box x15 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x14, x15, (x2).get(), 0x21c6052b); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x16, x17, (x2).get(), 0x53bbf409); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x18, x19, (x2).get(), 0x39d54123); + Box x20 = new Box((int)0); + Box x21 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x20, x21, 0x0, (x19).get(), (x16).get()); + Box x22 = new Box((int)0); + Box x23 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x22, x23, (x21).get(), (x17).get(), (x14).get()); + Box x24 = new Box((int)0); + Box x25 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x24, x25, (x23).get(), (x15).get(), (x12).get()); + Box x26 = new Box((int)0); + Box x27 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x26, x27, (x25).get(), (x13).get(), (x10).get()); + Box x28 = new Box((int)0); + Box x29 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x28, x29, (x27).get(), (x11).get(), (x8).get()); + Box x30 = new Box((int)0); + Box x31 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x30, x31, (x29).get(), (x9).get(), (x6).get()); + Box x32 = new Box((int)0); + Box x33 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x32, x33, (x31).get(), (x7).get(), (x4).get()); + Box x34 = new Box((int)0); + Box x35 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x34, x35, 0x0, x1, (x18).get()); + Box x36 = new Box((int)0); + Box x37 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x50, x51, 0x0, (x36).get(), (arg1[1])); + Box x52 = new Box((int)0); + Box x53 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x58, x59, (x57).get(), (x44).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x60 = new Box((int)0); + Box x61 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x60, x61, (x59).get(), (x46).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x62 = new Box((int)0); + Box x63 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x62, x63, (x61).get(), (x48).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x64 = new Box((int)0); + Box x65 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x64, x65, (x63).get(), ((x49).get() + ((x33).get() + (x5).get())), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x66 = new Box((int)0); + Box x67 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x66, x67, (x50).get(), 0x72350975); + Box x68 = new Box((int)0); + Box x69 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x68, x69, (x66).get(), 0xfffffffe); + Box x70 = new Box((int)0); + Box x71 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x70, x71, (x66).get(), 0xffffffff); + Box x72 = new Box((int)0); + Box x73 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x72, x73, (x66).get(), 0xffffffff); + Box x74 = new Box((int)0); + Box x75 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x74, x75, (x66).get(), 0xffffffff); + Box x76 = new Box((int)0); + Box x77 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x76, x77, (x66).get(), 0x7203df6b); + Box x78 = new Box((int)0); + Box x79 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x78, x79, (x66).get(), 0x21c6052b); + Box x80 = new Box((int)0); + Box x81 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x80, x81, (x66).get(), 0x53bbf409); + Box x82 = new Box((int)0); + Box x83 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x82, x83, (x66).get(), 0x39d54123); + Box x84 = new Box((int)0); + Box x85 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x84, x85, 0x0, (x83).get(), (x80).get()); + Box x86 = new Box((int)0); + Box x87 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x86, x87, (x85).get(), (x81).get(), (x78).get()); + Box x88 = new Box((int)0); + Box x89 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x88, x89, (x87).get(), (x79).get(), (x76).get()); + Box x90 = new Box((int)0); + Box x91 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x90, x91, (x89).get(), (x77).get(), (x74).get()); + Box x92 = new Box((int)0); + Box x93 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x92, x93, (x91).get(), (x75).get(), (x72).get()); + Box x94 = new Box((int)0); + Box x95 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x94, x95, (x93).get(), (x73).get(), (x70).get()); + Box x96 = new Box((int)0); + Box x97 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x96, x97, (x95).get(), (x71).get(), (x68).get()); + Box x98 = new Box((int)0); + Box x99 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x98, x99, 0x0, (x50).get(), (x82).get()); + Box x100 = new Box((int)0); + Box x101 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x100, x101, (x99).get(), (x52).get(), (x84).get()); + Box x102 = new Box((int)0); + Box x103 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x102, x103, (x101).get(), (x54).get(), (x86).get()); + Box x104 = new Box((int)0); + Box x105 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x104, x105, (x103).get(), (x56).get(), (x88).get()); + Box x106 = new Box((int)0); + Box x107 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x106, x107, (x105).get(), (x58).get(), (x90).get()); + Box x108 = new Box((int)0); + Box x109 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x108, x109, (x107).get(), (x60).get(), (x92).get()); + Box x110 = new Box((int)0); + Box x111 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x110, x111, (x109).get(), (x62).get(), (x94).get()); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x112, x113, (x111).get(), (x64).get(), (x96).get()); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x114, x115, (x113).get(), (x65).get(), ((x97).get() + (x69).get())); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x116, x117, 0x0, (x100).get(), (arg1[2])); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x132, x133, (x116).get(), 0x72350975); + Box x134 = new Box((int)0); + Box x135 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x134, x135, (x132).get(), 0xfffffffe); + Box x136 = new Box((int)0); + Box x137 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x136, x137, (x132).get(), 0xffffffff); + Box x138 = new Box((int)0); + Box x139 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x138, x139, (x132).get(), 0xffffffff); + Box x140 = new Box((int)0); + Box x141 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x140, x141, (x132).get(), 0xffffffff); + Box x142 = new Box((int)0); + Box x143 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x142, x143, (x132).get(), 0x7203df6b); + Box x144 = new Box((int)0); + Box x145 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x144, x145, (x132).get(), 0x21c6052b); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x146, x147, (x132).get(), 0x53bbf409); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x148, x149, (x132).get(), 0x39d54123); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x150, x151, 0x0, (x149).get(), (x146).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x152, x153, (x151).get(), (x147).get(), (x144).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x154, x155, (x153).get(), (x145).get(), (x142).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x156, x157, (x155).get(), (x143).get(), (x140).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x158, x159, (x157).get(), (x141).get(), (x138).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x160, x161, (x159).get(), (x139).get(), (x136).get()); + Box x162 = new Box((int)0); + Box x163 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x162, x163, (x161).get(), (x137).get(), (x134).get()); + Box x164 = new Box((int)0); + Box x165 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x164, x165, 0x0, (x116).get(), (x148).get()); + Box x166 = new Box((int)0); + Box x167 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x166, x167, (x165).get(), (x118).get(), (x150).get()); + Box x168 = new Box((int)0); + Box x169 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x168, x169, (x167).get(), (x120).get(), (x152).get()); + Box x170 = new Box((int)0); + Box x171 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x170, x171, (x169).get(), (x122).get(), (x154).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x172, x173, (x171).get(), (x124).get(), (x156).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x174, x175, (x173).get(), (x126).get(), (x158).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x176, x177, (x175).get(), (x128).get(), (x160).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x162).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x180, x181, (x179).get(), ((x131).get() + (x115).get()), ((x163).get() + (x135).get())); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x182, x183, 0x0, (x166).get(), (arg1[3])); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x184, x185, (x183).get(), (x168).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x198, x199, (x182).get(), 0x72350975); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x200, x201, (x198).get(), 0xfffffffe); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x202, x203, (x198).get(), 0xffffffff); + Box x204 = new Box((int)0); + Box x205 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x204, x205, (x198).get(), 0xffffffff); + Box x206 = new Box((int)0); + Box x207 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x206, x207, (x198).get(), 0xffffffff); + Box x208 = new Box((int)0); + Box x209 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x208, x209, (x198).get(), 0x7203df6b); + Box x210 = new Box((int)0); + Box x211 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x210, x211, (x198).get(), 0x21c6052b); + Box x212 = new Box((int)0); + Box x213 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x212, x213, (x198).get(), 0x53bbf409); + Box x214 = new Box((int)0); + Box x215 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x214, x215, (x198).get(), 0x39d54123); + Box x216 = new Box((int)0); + Box x217 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x216, x217, 0x0, (x215).get(), (x212).get()); + Box x218 = new Box((int)0); + Box x219 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x218, x219, (x217).get(), (x213).get(), (x210).get()); + Box x220 = new Box((int)0); + Box x221 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x220, x221, (x219).get(), (x211).get(), (x208).get()); + Box x222 = new Box((int)0); + Box x223 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x222, x223, (x221).get(), (x209).get(), (x206).get()); + Box x224 = new Box((int)0); + Box x225 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x224, x225, (x223).get(), (x207).get(), (x204).get()); + Box x226 = new Box((int)0); + Box x227 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x226, x227, (x225).get(), (x205).get(), (x202).get()); + Box x228 = new Box((int)0); + Box x229 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x228, x229, (x227).get(), (x203).get(), (x200).get()); + Box x230 = new Box((int)0); + Box x231 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x230, x231, 0x0, (x182).get(), (x214).get()); + Box x232 = new Box((int)0); + Box x233 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x232, x233, (x231).get(), (x184).get(), (x216).get()); + Box x234 = new Box((int)0); + Box x235 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x234, x235, (x233).get(), (x186).get(), (x218).get()); + Box x236 = new Box((int)0); + Box x237 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x236, x237, (x235).get(), (x188).get(), (x220).get()); + Box x238 = new Box((int)0); + Box x239 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x238, x239, (x237).get(), (x190).get(), (x222).get()); + Box x240 = new Box((int)0); + Box x241 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x240, x241, (x239).get(), (x192).get(), (x224).get()); + Box x242 = new Box((int)0); + Box x243 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x242, x243, (x241).get(), (x194).get(), (x226).get()); + Box x244 = new Box((int)0); + Box x245 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x244, x245, (x243).get(), (x196).get(), (x228).get()); + Box x246 = new Box((int)0); + Box x247 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x246, x247, (x245).get(), ((x197).get() + (x181).get()), ((x229).get() + (x201).get())); + Box x248 = new Box((int)0); + Box x249 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x248, x249, 0x0, (x232).get(), (arg1[4])); + Box x250 = new Box((int)0); + Box x251 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x250, x251, (x249).get(), (x234).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x252 = new Box((int)0); + Box x253 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x264, x265, (x248).get(), 0x72350975); + Box x266 = new Box((int)0); + Box x267 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x266, x267, (x264).get(), 0xfffffffe); + Box x268 = new Box((int)0); + Box x269 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x268, x269, (x264).get(), 0xffffffff); + Box x270 = new Box((int)0); + Box x271 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x270, x271, (x264).get(), 0xffffffff); + Box x272 = new Box((int)0); + Box x273 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x272, x273, (x264).get(), 0xffffffff); + Box x274 = new Box((int)0); + Box x275 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x274, x275, (x264).get(), 0x7203df6b); + Box x276 = new Box((int)0); + Box x277 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x276, x277, (x264).get(), 0x21c6052b); + Box x278 = new Box((int)0); + Box x279 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x278, x279, (x264).get(), 0x53bbf409); + Box x280 = new Box((int)0); + Box x281 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x280, x281, (x264).get(), 0x39d54123); + Box x282 = new Box((int)0); + Box x283 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x282, x283, 0x0, (x281).get(), (x278).get()); + Box x284 = new Box((int)0); + Box x285 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x284, x285, (x283).get(), (x279).get(), (x276).get()); + Box x286 = new Box((int)0); + Box x287 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x286, x287, (x285).get(), (x277).get(), (x274).get()); + Box x288 = new Box((int)0); + Box x289 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x288, x289, (x287).get(), (x275).get(), (x272).get()); + Box x290 = new Box((int)0); + Box x291 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x290, x291, (x289).get(), (x273).get(), (x270).get()); + Box x292 = new Box((int)0); + Box x293 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x292, x293, (x291).get(), (x271).get(), (x268).get()); + Box x294 = new Box((int)0); + Box x295 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x294, x295, (x293).get(), (x269).get(), (x266).get()); + Box x296 = new Box((int)0); + Box x297 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x296, x297, 0x0, (x248).get(), (x280).get()); + Box x298 = new Box((int)0); + Box x299 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x298, x299, (x297).get(), (x250).get(), (x282).get()); + Box x300 = new Box((int)0); + Box x301 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x300, x301, (x299).get(), (x252).get(), (x284).get()); + Box x302 = new Box((int)0); + Box x303 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x302, x303, (x301).get(), (x254).get(), (x286).get()); + Box x304 = new Box((int)0); + Box x305 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x304, x305, (x303).get(), (x256).get(), (x288).get()); + Box x306 = new Box((int)0); + Box x307 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x306, x307, (x305).get(), (x258).get(), (x290).get()); + Box x308 = new Box((int)0); + Box x309 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x308, x309, (x307).get(), (x260).get(), (x292).get()); + Box x310 = new Box((int)0); + Box x311 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x310, x311, (x309).get(), (x262).get(), (x294).get()); + Box x312 = new Box((int)0); + Box x313 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x312, x313, (x311).get(), ((x263).get() + (x247).get()), ((x295).get() + (x267).get())); + Box x314 = new Box((int)0); + Box x315 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x314, x315, 0x0, (x298).get(), (arg1[5])); + Box x316 = new Box((int)0); + Box x317 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x316, x317, (x315).get(), (x300).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x318 = new Box((int)0); + Box x319 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x330, x331, (x314).get(), 0x72350975); + Box x332 = new Box((int)0); + Box x333 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x332, x333, (x330).get(), 0xfffffffe); + Box x334 = new Box((int)0); + Box x335 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x334, x335, (x330).get(), 0xffffffff); + Box x336 = new Box((int)0); + Box x337 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x336, x337, (x330).get(), 0xffffffff); + Box x338 = new Box((int)0); + Box x339 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x338, x339, (x330).get(), 0xffffffff); + Box x340 = new Box((int)0); + Box x341 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x340, x341, (x330).get(), 0x7203df6b); + Box x342 = new Box((int)0); + Box x343 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x342, x343, (x330).get(), 0x21c6052b); + Box x344 = new Box((int)0); + Box x345 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x344, x345, (x330).get(), 0x53bbf409); + Box x346 = new Box((int)0); + Box x347 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x346, x347, (x330).get(), 0x39d54123); + Box x348 = new Box((int)0); + Box x349 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x348, x349, 0x0, (x347).get(), (x344).get()); + Box x350 = new Box((int)0); + Box x351 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x350, x351, (x349).get(), (x345).get(), (x342).get()); + Box x352 = new Box((int)0); + Box x353 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x352, x353, (x351).get(), (x343).get(), (x340).get()); + Box x354 = new Box((int)0); + Box x355 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x354, x355, (x353).get(), (x341).get(), (x338).get()); + Box x356 = new Box((int)0); + Box x357 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x356, x357, (x355).get(), (x339).get(), (x336).get()); + Box x358 = new Box((int)0); + Box x359 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x358, x359, (x357).get(), (x337).get(), (x334).get()); + Box x360 = new Box((int)0); + Box x361 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x360, x361, (x359).get(), (x335).get(), (x332).get()); + Box x362 = new Box((int)0); + Box x363 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x362, x363, 0x0, (x314).get(), (x346).get()); + Box x364 = new Box((int)0); + Box x365 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x364, x365, (x363).get(), (x316).get(), (x348).get()); + Box x366 = new Box((int)0); + Box x367 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x366, x367, (x365).get(), (x318).get(), (x350).get()); + Box x368 = new Box((int)0); + Box x369 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x368, x369, (x367).get(), (x320).get(), (x352).get()); + Box x370 = new Box((int)0); + Box x371 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x370, x371, (x369).get(), (x322).get(), (x354).get()); + Box x372 = new Box((int)0); + Box x373 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x372, x373, (x371).get(), (x324).get(), (x356).get()); + Box x374 = new Box((int)0); + Box x375 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x374, x375, (x373).get(), (x326).get(), (x358).get()); + Box x376 = new Box((int)0); + Box x377 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x376, x377, (x375).get(), (x328).get(), (x360).get()); + Box x378 = new Box((int)0); + Box x379 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x378, x379, (x377).get(), ((x329).get() + (x313).get()), ((x361).get() + (x333).get())); + Box x380 = new Box((int)0); + Box x381 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x380, x381, 0x0, (x364).get(), (arg1[6])); + Box x382 = new Box((int)0); + Box x383 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x382, x383, (x381).get(), (x366).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x384 = new Box((int)0); + Box x385 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x396, x397, (x380).get(), 0x72350975); + Box x398 = new Box((int)0); + Box x399 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x398, x399, (x396).get(), 0xfffffffe); + Box x400 = new Box((int)0); + Box x401 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x400, x401, (x396).get(), 0xffffffff); + Box x402 = new Box((int)0); + Box x403 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x402, x403, (x396).get(), 0xffffffff); + Box x404 = new Box((int)0); + Box x405 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x404, x405, (x396).get(), 0xffffffff); + Box x406 = new Box((int)0); + Box x407 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x406, x407, (x396).get(), 0x7203df6b); + Box x408 = new Box((int)0); + Box x409 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x408, x409, (x396).get(), 0x21c6052b); + Box x410 = new Box((int)0); + Box x411 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x410, x411, (x396).get(), 0x53bbf409); + Box x412 = new Box((int)0); + Box x413 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x412, x413, (x396).get(), 0x39d54123); + Box x414 = new Box((int)0); + Box x415 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x414, x415, 0x0, (x413).get(), (x410).get()); + Box x416 = new Box((int)0); + Box x417 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x416, x417, (x415).get(), (x411).get(), (x408).get()); + Box x418 = new Box((int)0); + Box x419 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x418, x419, (x417).get(), (x409).get(), (x406).get()); + Box x420 = new Box((int)0); + Box x421 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x420, x421, (x419).get(), (x407).get(), (x404).get()); + Box x422 = new Box((int)0); + Box x423 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x422, x423, (x421).get(), (x405).get(), (x402).get()); + Box x424 = new Box((int)0); + Box x425 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x424, x425, (x423).get(), (x403).get(), (x400).get()); + Box x426 = new Box((int)0); + Box x427 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x426, x427, (x425).get(), (x401).get(), (x398).get()); + Box x428 = new Box((int)0); + Box x429 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x428, x429, 0x0, (x380).get(), (x412).get()); + Box x430 = new Box((int)0); + Box x431 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x430, x431, (x429).get(), (x382).get(), (x414).get()); + Box x432 = new Box((int)0); + Box x433 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x432, x433, (x431).get(), (x384).get(), (x416).get()); + Box x434 = new Box((int)0); + Box x435 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x434, x435, (x433).get(), (x386).get(), (x418).get()); + Box x436 = new Box((int)0); + Box x437 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x436, x437, (x435).get(), (x388).get(), (x420).get()); + Box x438 = new Box((int)0); + Box x439 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x438, x439, (x437).get(), (x390).get(), (x422).get()); + Box x440 = new Box((int)0); + Box x441 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x440, x441, (x439).get(), (x392).get(), (x424).get()); + Box x442 = new Box((int)0); + Box x443 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x442, x443, (x441).get(), (x394).get(), (x426).get()); + Box x444 = new Box((int)0); + Box x445 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x444, x445, (x443).get(), ((x395).get() + (x379).get()), ((x427).get() + (x399).get())); + Box x446 = new Box((int)0); + Box x447 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x446, x447, 0x0, (x430).get(), (arg1[7])); + Box x448 = new Box((int)0); + Box x449 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x448, x449, (x447).get(), (x432).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x450 = new Box((int)0); + Box x451 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x462, x463, (x446).get(), 0x72350975); + Box x464 = new Box((int)0); + Box x465 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x464, x465, (x462).get(), 0xfffffffe); + Box x466 = new Box((int)0); + Box x467 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x466, x467, (x462).get(), 0xffffffff); + Box x468 = new Box((int)0); + Box x469 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x468, x469, (x462).get(), 0xffffffff); + Box x470 = new Box((int)0); + Box x471 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x470, x471, (x462).get(), 0xffffffff); + Box x472 = new Box((int)0); + Box x473 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x472, x473, (x462).get(), 0x7203df6b); + Box x474 = new Box((int)0); + Box x475 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x474, x475, (x462).get(), 0x21c6052b); + Box x476 = new Box((int)0); + Box x477 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x476, x477, (x462).get(), 0x53bbf409); + Box x478 = new Box((int)0); + Box x479 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x478, x479, (x462).get(), 0x39d54123); + Box x480 = new Box((int)0); + Box x481 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x480, x481, 0x0, (x479).get(), (x476).get()); + Box x482 = new Box((int)0); + Box x483 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x482, x483, (x481).get(), (x477).get(), (x474).get()); + Box x484 = new Box((int)0); + Box x485 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x484, x485, (x483).get(), (x475).get(), (x472).get()); + Box x486 = new Box((int)0); + Box x487 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x486, x487, (x485).get(), (x473).get(), (x470).get()); + Box x488 = new Box((int)0); + Box x489 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x488, x489, (x487).get(), (x471).get(), (x468).get()); + Box x490 = new Box((int)0); + Box x491 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x490, x491, (x489).get(), (x469).get(), (x466).get()); + Box x492 = new Box((int)0); + Box x493 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x492, x493, (x491).get(), (x467).get(), (x464).get()); + Box x494 = new Box((int)0); + Box x495 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x494, x495, 0x0, (x446).get(), (x478).get()); + Box x496 = new Box((int)0); + Box x497 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x496, x497, (x495).get(), (x448).get(), (x480).get()); + Box x498 = new Box((int)0); + Box x499 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x498, x499, (x497).get(), (x450).get(), (x482).get()); + Box x500 = new Box((int)0); + Box x501 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x500, x501, (x499).get(), (x452).get(), (x484).get()); + Box x502 = new Box((int)0); + Box x503 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x502, x503, (x501).get(), (x454).get(), (x486).get()); + Box x504 = new Box((int)0); + Box x505 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x504, x505, (x503).get(), (x456).get(), (x488).get()); + Box x506 = new Box((int)0); + Box x507 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x506, x507, (x505).get(), (x458).get(), (x490).get()); + Box x508 = new Box((int)0); + Box x509 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x508, x509, (x507).get(), (x460).get(), (x492).get()); + Box x510 = new Box((int)0); + Box x511 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x510, x511, (x509).get(), ((x461).get() + (x445).get()), ((x493).get() + (x465).get())); + Box x512 = new Box((int)0); + Box x513 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x512, x513, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x496).get(), 0x39d54123); + Box x514 = new Box((int)0); + Box x515 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x514, x515, (x513).get(), (x498).get(), 0x53bbf409); + Box x516 = new Box((int)0); + Box x517 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x516, x517, (x515).get(), (x500).get(), 0x21c6052b); + Box x518 = new Box((int)0); + Box x519 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x518, x519, (x517).get(), (x502).get(), 0x7203df6b); + Box x520 = new Box((int)0); + Box x521 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x520, x521, (x519).get(), (x504).get(), 0xffffffff); + Box x522 = new Box((int)0); + Box x523 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x522, x523, (x521).get(), (x506).get(), 0xffffffff); + Box x524 = new Box((int)0); + Box x525 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x524, x525, (x523).get(), (x508).get(), 0xffffffff); + Box x526 = new Box((int)0); + Box x527 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x526, x527, (x525).get(), (x510).get(), 0xfffffffe); + Box x528 = new Box((int)0); + Box x529 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x528, x529, (x527).get(), (x511).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x530 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x530, (x529).get(), (x512).get(), (x496).get()); + Box x531 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x531, (x529).get(), (x514).get(), (x498).get()); + Box x532 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x532, (x529).get(), (x516).get(), (x500).get()); + Box x533 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x533, (x529).get(), (x518).get(), (x502).get()); + Box x534 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x534, (x529).get(), (x520).get(), (x504).get()); + Box x535 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x535, (x529).get(), (x522).get(), (x506).get()); + Box x536 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x536, (x529).get(), (x524).get(), (x508).get()); + Box x537 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x537, (x529).get(), (x526).get(), (x510).get()); + out1[0] = (x530).get(); + out1[1] = (x531).get(); + out1[2] = (x532).get(); + out1[3] = (x533).get(); + out1[4] = (x534).get(); + out1[5] = (x535).get(); + out1[6] = (x536).get(); + out1[7] = (x537).get(); +} + +/** + * The function fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_mulx_u32(x9, x10, x8, 0x1eb5e412); + Box x11 = new Box((int)0); + Box x12 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x11, x12, x8, 0xa22b3d3b); + Box x13 = new Box((int)0); + Box x14 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x13, x14, x8, 0x620fc84c); + Box x15 = new Box((int)0); + Box x16 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x15, x16, x8, 0x3affe0d4); + Box x17 = new Box((int)0); + Box x18 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x17, x18, x8, 0x3464504a); + Box x19 = new Box((int)0); + Box x20 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x19, x20, x8, 0xde6fa2fa); + Box x21 = new Box((int)0); + Box x22 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x21, x22, x8, 0x901192af); + Box x23 = new Box((int)0); + Box x24 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x23, x24, x8, 0x7c114f20); + Box x25 = new Box((int)0); + Box x26 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x25, x26, 0x0, (x24).get(), (x21).get()); + Box x27 = new Box((int)0); + Box x28 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x27, x28, (x26).get(), (x22).get(), (x19).get()); + Box x29 = new Box((int)0); + Box x30 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x29, x30, (x28).get(), (x20).get(), (x17).get()); + Box x31 = new Box((int)0); + Box x32 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x31, x32, (x30).get(), (x18).get(), (x15).get()); + Box x33 = new Box((int)0); + Box x34 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x33, x34, (x32).get(), (x16).get(), (x13).get()); + Box x35 = new Box((int)0); + Box x36 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x35, x36, (x34).get(), (x14).get(), (x11).get()); + Box x37 = new Box((int)0); + Box x38 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x37, x38, (x36).get(), (x12).get(), (x9).get()); + Box x39 = new Box((int)0); + Box x40 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x39, x40, (x23).get(), 0x72350975); + Box x41 = new Box((int)0); + Box x42 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x41, x42, (x39).get(), 0xfffffffe); + Box x43 = new Box((int)0); + Box x44 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x43, x44, (x39).get(), 0xffffffff); + Box x45 = new Box((int)0); + Box x46 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x45, x46, (x39).get(), 0xffffffff); + Box x47 = new Box((int)0); + Box x48 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x47, x48, (x39).get(), 0xffffffff); + Box x49 = new Box((int)0); + Box x50 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x49, x50, (x39).get(), 0x7203df6b); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x51, x52, (x39).get(), 0x21c6052b); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x53, x54, (x39).get(), 0x53bbf409); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x55, x56, (x39).get(), 0x39d54123); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x57, x58, 0x0, (x56).get(), (x53).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x59, x60, (x58).get(), (x54).get(), (x51).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x61, x62, (x60).get(), (x52).get(), (x49).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x63, x64, (x62).get(), (x50).get(), (x47).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x65, x66, (x64).get(), (x48).get(), (x45).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x67, x68, (x66).get(), (x46).get(), (x43).get()); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x69, x70, (x68).get(), (x44).get(), (x41).get()); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x71, x72, 0x0, (x23).get(), (x55).get()); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x73, x74, (x72).get(), (x25).get(), (x57).get()); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x75, x76, (x74).get(), (x27).get(), (x59).get()); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x77, x78, (x76).get(), (x29).get(), (x61).get()); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x79, x80, (x78).get(), (x31).get(), (x63).get()); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x81, x82, (x80).get(), (x33).get(), (x65).get()); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x83, x84, (x82).get(), (x35).get(), (x67).get()); + Box x85 = new Box((int)0); + Box x86 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x85, x86, (x84).get(), (x37).get(), (x69).get()); + Box x87 = new Box((int)0); + Box x88 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x89, x90, x1, 0x1eb5e412); + Box x91 = new Box((int)0); + Box x92 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x91, x92, x1, 0xa22b3d3b); + Box x93 = new Box((int)0); + Box x94 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x93, x94, x1, 0x620fc84c); + Box x95 = new Box((int)0); + Box x96 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x95, x96, x1, 0x3affe0d4); + Box x97 = new Box((int)0); + Box x98 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x97, x98, x1, 0x3464504a); + Box x99 = new Box((int)0); + Box x100 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x99, x100, x1, 0xde6fa2fa); + Box x101 = new Box((int)0); + Box x102 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x101, x102, x1, 0x901192af); + Box x103 = new Box((int)0); + Box x104 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x103, x104, x1, 0x7c114f20); + Box x105 = new Box((int)0); + Box x106 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x105, x106, 0x0, (x104).get(), (x101).get()); + Box x107 = new Box((int)0); + Box x108 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x107, x108, (x106).get(), (x102).get(), (x99).get()); + Box x109 = new Box((int)0); + Box x110 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x109, x110, (x108).get(), (x100).get(), (x97).get()); + Box x111 = new Box((int)0); + Box x112 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x111, x112, (x110).get(), (x98).get(), (x95).get()); + Box x113 = new Box((int)0); + Box x114 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x113, x114, (x112).get(), (x96).get(), (x93).get()); + Box x115 = new Box((int)0); + Box x116 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x115, x116, (x114).get(), (x94).get(), (x91).get()); + Box x117 = new Box((int)0); + Box x118 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x117, x118, (x116).get(), (x92).get(), (x89).get()); + Box x119 = new Box((int)0); + Box x120 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x119, x120, 0x0, (x73).get(), (x103).get()); + Box x121 = new Box((int)0); + Box x122 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x121, x122, (x120).get(), (x75).get(), (x105).get()); + Box x123 = new Box((int)0); + Box x124 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x123, x124, (x122).get(), (x77).get(), (x107).get()); + Box x125 = new Box((int)0); + Box x126 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x125, x126, (x124).get(), (x79).get(), (x109).get()); + Box x127 = new Box((int)0); + Box x128 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x127, x128, (x126).get(), (x81).get(), (x111).get()); + Box x129 = new Box((int)0); + Box x130 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x129, x130, (x128).get(), (x83).get(), (x113).get()); + Box x131 = new Box((int)0); + Box x132 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x131, x132, (x130).get(), (x85).get(), (x115).get()); + Box x133 = new Box((int)0); + Box x134 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x133, x134, (x132).get(), (x87).get(), (x117).get()); + Box x135 = new Box((int)0); + Box x136 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x135, x136, (x119).get(), 0x72350975); + Box x137 = new Box((int)0); + Box x138 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x137, x138, (x135).get(), 0xfffffffe); + Box x139 = new Box((int)0); + Box x140 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x139, x140, (x135).get(), 0xffffffff); + Box x141 = new Box((int)0); + Box x142 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x141, x142, (x135).get(), 0xffffffff); + Box x143 = new Box((int)0); + Box x144 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x143, x144, (x135).get(), 0xffffffff); + Box x145 = new Box((int)0); + Box x146 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x145, x146, (x135).get(), 0x7203df6b); + Box x147 = new Box((int)0); + Box x148 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x147, x148, (x135).get(), 0x21c6052b); + Box x149 = new Box((int)0); + Box x150 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x149, x150, (x135).get(), 0x53bbf409); + Box x151 = new Box((int)0); + Box x152 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x151, x152, (x135).get(), 0x39d54123); + Box x153 = new Box((int)0); + Box x154 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x153, x154, 0x0, (x152).get(), (x149).get()); + Box x155 = new Box((int)0); + Box x156 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x155, x156, (x154).get(), (x150).get(), (x147).get()); + Box x157 = new Box((int)0); + Box x158 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x157, x158, (x156).get(), (x148).get(), (x145).get()); + Box x159 = new Box((int)0); + Box x160 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x159, x160, (x158).get(), (x146).get(), (x143).get()); + Box x161 = new Box((int)0); + Box x162 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x161, x162, (x160).get(), (x144).get(), (x141).get()); + Box x163 = new Box((int)0); + Box x164 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x163, x164, (x162).get(), (x142).get(), (x139).get()); + Box x165 = new Box((int)0); + Box x166 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x165, x166, (x164).get(), (x140).get(), (x137).get()); + Box x167 = new Box((int)0); + Box x168 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x167, x168, 0x0, (x119).get(), (x151).get()); + Box x169 = new Box((int)0); + Box x170 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x169, x170, (x168).get(), (x121).get(), (x153).get()); + Box x171 = new Box((int)0); + Box x172 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x171, x172, (x170).get(), (x123).get(), (x155).get()); + Box x173 = new Box((int)0); + Box x174 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x173, x174, (x172).get(), (x125).get(), (x157).get()); + Box x175 = new Box((int)0); + Box x176 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x175, x176, (x174).get(), (x127).get(), (x159).get()); + Box x177 = new Box((int)0); + Box x178 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x177, x178, (x176).get(), (x129).get(), (x161).get()); + Box x179 = new Box((int)0); + Box x180 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x179, x180, (x178).get(), (x131).get(), (x163).get()); + Box x181 = new Box((int)0); + Box x182 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x181, x182, (x180).get(), (x133).get(), (x165).get()); + Box x183 = new Box((int)0); + Box x184 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x185, x186, x2, 0x1eb5e412); + Box x187 = new Box((int)0); + Box x188 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x187, x188, x2, 0xa22b3d3b); + Box x189 = new Box((int)0); + Box x190 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x189, x190, x2, 0x620fc84c); + Box x191 = new Box((int)0); + Box x192 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x191, x192, x2, 0x3affe0d4); + Box x193 = new Box((int)0); + Box x194 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x193, x194, x2, 0x3464504a); + Box x195 = new Box((int)0); + Box x196 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x195, x196, x2, 0xde6fa2fa); + Box x197 = new Box((int)0); + Box x198 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x197, x198, x2, 0x901192af); + Box x199 = new Box((int)0); + Box x200 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x199, x200, x2, 0x7c114f20); + Box x201 = new Box((int)0); + Box x202 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x201, x202, 0x0, (x200).get(), (x197).get()); + Box x203 = new Box((int)0); + Box x204 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x203, x204, (x202).get(), (x198).get(), (x195).get()); + Box x205 = new Box((int)0); + Box x206 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x205, x206, (x204).get(), (x196).get(), (x193).get()); + Box x207 = new Box((int)0); + Box x208 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x207, x208, (x206).get(), (x194).get(), (x191).get()); + Box x209 = new Box((int)0); + Box x210 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x209, x210, (x208).get(), (x192).get(), (x189).get()); + Box x211 = new Box((int)0); + Box x212 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x211, x212, (x210).get(), (x190).get(), (x187).get()); + Box x213 = new Box((int)0); + Box x214 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x213, x214, (x212).get(), (x188).get(), (x185).get()); + Box x215 = new Box((int)0); + Box x216 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x215, x216, 0x0, (x169).get(), (x199).get()); + Box x217 = new Box((int)0); + Box x218 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x217, x218, (x216).get(), (x171).get(), (x201).get()); + Box x219 = new Box((int)0); + Box x220 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x219, x220, (x218).get(), (x173).get(), (x203).get()); + Box x221 = new Box((int)0); + Box x222 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x221, x222, (x220).get(), (x175).get(), (x205).get()); + Box x223 = new Box((int)0); + Box x224 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x223, x224, (x222).get(), (x177).get(), (x207).get()); + Box x225 = new Box((int)0); + Box x226 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x225, x226, (x224).get(), (x179).get(), (x209).get()); + Box x227 = new Box((int)0); + Box x228 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x227, x228, (x226).get(), (x181).get(), (x211).get()); + Box x229 = new Box((int)0); + Box x230 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x229, x230, (x228).get(), (x183).get(), (x213).get()); + Box x231 = new Box((int)0); + Box x232 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x231, x232, (x215).get(), 0x72350975); + Box x233 = new Box((int)0); + Box x234 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x233, x234, (x231).get(), 0xfffffffe); + Box x235 = new Box((int)0); + Box x236 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x235, x236, (x231).get(), 0xffffffff); + Box x237 = new Box((int)0); + Box x238 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x237, x238, (x231).get(), 0xffffffff); + Box x239 = new Box((int)0); + Box x240 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x239, x240, (x231).get(), 0xffffffff); + Box x241 = new Box((int)0); + Box x242 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x241, x242, (x231).get(), 0x7203df6b); + Box x243 = new Box((int)0); + Box x244 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x243, x244, (x231).get(), 0x21c6052b); + Box x245 = new Box((int)0); + Box x246 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x245, x246, (x231).get(), 0x53bbf409); + Box x247 = new Box((int)0); + Box x248 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x247, x248, (x231).get(), 0x39d54123); + Box x249 = new Box((int)0); + Box x250 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x249, x250, 0x0, (x248).get(), (x245).get()); + Box x251 = new Box((int)0); + Box x252 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x251, x252, (x250).get(), (x246).get(), (x243).get()); + Box x253 = new Box((int)0); + Box x254 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x253, x254, (x252).get(), (x244).get(), (x241).get()); + Box x255 = new Box((int)0); + Box x256 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x255, x256, (x254).get(), (x242).get(), (x239).get()); + Box x257 = new Box((int)0); + Box x258 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x257, x258, (x256).get(), (x240).get(), (x237).get()); + Box x259 = new Box((int)0); + Box x260 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x259, x260, (x258).get(), (x238).get(), (x235).get()); + Box x261 = new Box((int)0); + Box x262 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x261, x262, (x260).get(), (x236).get(), (x233).get()); + Box x263 = new Box((int)0); + Box x264 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x263, x264, 0x0, (x215).get(), (x247).get()); + Box x265 = new Box((int)0); + Box x266 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x265, x266, (x264).get(), (x217).get(), (x249).get()); + Box x267 = new Box((int)0); + Box x268 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x267, x268, (x266).get(), (x219).get(), (x251).get()); + Box x269 = new Box((int)0); + Box x270 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x269, x270, (x268).get(), (x221).get(), (x253).get()); + Box x271 = new Box((int)0); + Box x272 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x271, x272, (x270).get(), (x223).get(), (x255).get()); + Box x273 = new Box((int)0); + Box x274 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x273, x274, (x272).get(), (x225).get(), (x257).get()); + Box x275 = new Box((int)0); + Box x276 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x275, x276, (x274).get(), (x227).get(), (x259).get()); + Box x277 = new Box((int)0); + Box x278 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x277, x278, (x276).get(), (x229).get(), (x261).get()); + Box x279 = new Box((int)0); + Box x280 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x281, x282, x3, 0x1eb5e412); + Box x283 = new Box((int)0); + Box x284 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x283, x284, x3, 0xa22b3d3b); + Box x285 = new Box((int)0); + Box x286 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x285, x286, x3, 0x620fc84c); + Box x287 = new Box((int)0); + Box x288 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x287, x288, x3, 0x3affe0d4); + Box x289 = new Box((int)0); + Box x290 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x289, x290, x3, 0x3464504a); + Box x291 = new Box((int)0); + Box x292 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x291, x292, x3, 0xde6fa2fa); + Box x293 = new Box((int)0); + Box x294 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x293, x294, x3, 0x901192af); + Box x295 = new Box((int)0); + Box x296 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x295, x296, x3, 0x7c114f20); + Box x297 = new Box((int)0); + Box x298 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x297, x298, 0x0, (x296).get(), (x293).get()); + Box x299 = new Box((int)0); + Box x300 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x299, x300, (x298).get(), (x294).get(), (x291).get()); + Box x301 = new Box((int)0); + Box x302 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x301, x302, (x300).get(), (x292).get(), (x289).get()); + Box x303 = new Box((int)0); + Box x304 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x303, x304, (x302).get(), (x290).get(), (x287).get()); + Box x305 = new Box((int)0); + Box x306 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x305, x306, (x304).get(), (x288).get(), (x285).get()); + Box x307 = new Box((int)0); + Box x308 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x307, x308, (x306).get(), (x286).get(), (x283).get()); + Box x309 = new Box((int)0); + Box x310 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x309, x310, (x308).get(), (x284).get(), (x281).get()); + Box x311 = new Box((int)0); + Box x312 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x311, x312, 0x0, (x265).get(), (x295).get()); + Box x313 = new Box((int)0); + Box x314 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x313, x314, (x312).get(), (x267).get(), (x297).get()); + Box x315 = new Box((int)0); + Box x316 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x315, x316, (x314).get(), (x269).get(), (x299).get()); + Box x317 = new Box((int)0); + Box x318 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x317, x318, (x316).get(), (x271).get(), (x301).get()); + Box x319 = new Box((int)0); + Box x320 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x319, x320, (x318).get(), (x273).get(), (x303).get()); + Box x321 = new Box((int)0); + Box x322 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x321, x322, (x320).get(), (x275).get(), (x305).get()); + Box x323 = new Box((int)0); + Box x324 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x323, x324, (x322).get(), (x277).get(), (x307).get()); + Box x325 = new Box((int)0); + Box x326 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x325, x326, (x324).get(), (x279).get(), (x309).get()); + Box x327 = new Box((int)0); + Box x328 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x327, x328, (x311).get(), 0x72350975); + Box x329 = new Box((int)0); + Box x330 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x329, x330, (x327).get(), 0xfffffffe); + Box x331 = new Box((int)0); + Box x332 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x331, x332, (x327).get(), 0xffffffff); + Box x333 = new Box((int)0); + Box x334 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x333, x334, (x327).get(), 0xffffffff); + Box x335 = new Box((int)0); + Box x336 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x335, x336, (x327).get(), 0xffffffff); + Box x337 = new Box((int)0); + Box x338 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x337, x338, (x327).get(), 0x7203df6b); + Box x339 = new Box((int)0); + Box x340 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x339, x340, (x327).get(), 0x21c6052b); + Box x341 = new Box((int)0); + Box x342 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x341, x342, (x327).get(), 0x53bbf409); + Box x343 = new Box((int)0); + Box x344 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x343, x344, (x327).get(), 0x39d54123); + Box x345 = new Box((int)0); + Box x346 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x345, x346, 0x0, (x344).get(), (x341).get()); + Box x347 = new Box((int)0); + Box x348 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x347, x348, (x346).get(), (x342).get(), (x339).get()); + Box x349 = new Box((int)0); + Box x350 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x349, x350, (x348).get(), (x340).get(), (x337).get()); + Box x351 = new Box((int)0); + Box x352 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x351, x352, (x350).get(), (x338).get(), (x335).get()); + Box x353 = new Box((int)0); + Box x354 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x353, x354, (x352).get(), (x336).get(), (x333).get()); + Box x355 = new Box((int)0); + Box x356 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x355, x356, (x354).get(), (x334).get(), (x331).get()); + Box x357 = new Box((int)0); + Box x358 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x357, x358, (x356).get(), (x332).get(), (x329).get()); + Box x359 = new Box((int)0); + Box x360 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x359, x360, 0x0, (x311).get(), (x343).get()); + Box x361 = new Box((int)0); + Box x362 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x361, x362, (x360).get(), (x313).get(), (x345).get()); + Box x363 = new Box((int)0); + Box x364 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x363, x364, (x362).get(), (x315).get(), (x347).get()); + Box x365 = new Box((int)0); + Box x366 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x365, x366, (x364).get(), (x317).get(), (x349).get()); + Box x367 = new Box((int)0); + Box x368 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x367, x368, (x366).get(), (x319).get(), (x351).get()); + Box x369 = new Box((int)0); + Box x370 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x369, x370, (x368).get(), (x321).get(), (x353).get()); + Box x371 = new Box((int)0); + Box x372 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x371, x372, (x370).get(), (x323).get(), (x355).get()); + Box x373 = new Box((int)0); + Box x374 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x373, x374, (x372).get(), (x325).get(), (x357).get()); + Box x375 = new Box((int)0); + Box x376 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x377, x378, x4, 0x1eb5e412); + Box x379 = new Box((int)0); + Box x380 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x379, x380, x4, 0xa22b3d3b); + Box x381 = new Box((int)0); + Box x382 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x381, x382, x4, 0x620fc84c); + Box x383 = new Box((int)0); + Box x384 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x383, x384, x4, 0x3affe0d4); + Box x385 = new Box((int)0); + Box x386 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x385, x386, x4, 0x3464504a); + Box x387 = new Box((int)0); + Box x388 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x387, x388, x4, 0xde6fa2fa); + Box x389 = new Box((int)0); + Box x390 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x389, x390, x4, 0x901192af); + Box x391 = new Box((int)0); + Box x392 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x391, x392, x4, 0x7c114f20); + Box x393 = new Box((int)0); + Box x394 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x393, x394, 0x0, (x392).get(), (x389).get()); + Box x395 = new Box((int)0); + Box x396 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x395, x396, (x394).get(), (x390).get(), (x387).get()); + Box x397 = new Box((int)0); + Box x398 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x397, x398, (x396).get(), (x388).get(), (x385).get()); + Box x399 = new Box((int)0); + Box x400 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x399, x400, (x398).get(), (x386).get(), (x383).get()); + Box x401 = new Box((int)0); + Box x402 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x401, x402, (x400).get(), (x384).get(), (x381).get()); + Box x403 = new Box((int)0); + Box x404 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x403, x404, (x402).get(), (x382).get(), (x379).get()); + Box x405 = new Box((int)0); + Box x406 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x405, x406, (x404).get(), (x380).get(), (x377).get()); + Box x407 = new Box((int)0); + Box x408 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x407, x408, 0x0, (x361).get(), (x391).get()); + Box x409 = new Box((int)0); + Box x410 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x409, x410, (x408).get(), (x363).get(), (x393).get()); + Box x411 = new Box((int)0); + Box x412 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x411, x412, (x410).get(), (x365).get(), (x395).get()); + Box x413 = new Box((int)0); + Box x414 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x413, x414, (x412).get(), (x367).get(), (x397).get()); + Box x415 = new Box((int)0); + Box x416 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x415, x416, (x414).get(), (x369).get(), (x399).get()); + Box x417 = new Box((int)0); + Box x418 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x417, x418, (x416).get(), (x371).get(), (x401).get()); + Box x419 = new Box((int)0); + Box x420 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x419, x420, (x418).get(), (x373).get(), (x403).get()); + Box x421 = new Box((int)0); + Box x422 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x421, x422, (x420).get(), (x375).get(), (x405).get()); + Box x423 = new Box((int)0); + Box x424 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x423, x424, (x407).get(), 0x72350975); + Box x425 = new Box((int)0); + Box x426 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x425, x426, (x423).get(), 0xfffffffe); + Box x427 = new Box((int)0); + Box x428 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x427, x428, (x423).get(), 0xffffffff); + Box x429 = new Box((int)0); + Box x430 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x429, x430, (x423).get(), 0xffffffff); + Box x431 = new Box((int)0); + Box x432 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x431, x432, (x423).get(), 0xffffffff); + Box x433 = new Box((int)0); + Box x434 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x433, x434, (x423).get(), 0x7203df6b); + Box x435 = new Box((int)0); + Box x436 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x435, x436, (x423).get(), 0x21c6052b); + Box x437 = new Box((int)0); + Box x438 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x437, x438, (x423).get(), 0x53bbf409); + Box x439 = new Box((int)0); + Box x440 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x439, x440, (x423).get(), 0x39d54123); + Box x441 = new Box((int)0); + Box x442 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x441, x442, 0x0, (x440).get(), (x437).get()); + Box x443 = new Box((int)0); + Box x444 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x443, x444, (x442).get(), (x438).get(), (x435).get()); + Box x445 = new Box((int)0); + Box x446 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x445, x446, (x444).get(), (x436).get(), (x433).get()); + Box x447 = new Box((int)0); + Box x448 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x447, x448, (x446).get(), (x434).get(), (x431).get()); + Box x449 = new Box((int)0); + Box x450 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x449, x450, (x448).get(), (x432).get(), (x429).get()); + Box x451 = new Box((int)0); + Box x452 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x451, x452, (x450).get(), (x430).get(), (x427).get()); + Box x453 = new Box((int)0); + Box x454 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x453, x454, (x452).get(), (x428).get(), (x425).get()); + Box x455 = new Box((int)0); + Box x456 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x455, x456, 0x0, (x407).get(), (x439).get()); + Box x457 = new Box((int)0); + Box x458 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x457, x458, (x456).get(), (x409).get(), (x441).get()); + Box x459 = new Box((int)0); + Box x460 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x459, x460, (x458).get(), (x411).get(), (x443).get()); + Box x461 = new Box((int)0); + Box x462 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x461, x462, (x460).get(), (x413).get(), (x445).get()); + Box x463 = new Box((int)0); + Box x464 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x463, x464, (x462).get(), (x415).get(), (x447).get()); + Box x465 = new Box((int)0); + Box x466 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x465, x466, (x464).get(), (x417).get(), (x449).get()); + Box x467 = new Box((int)0); + Box x468 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x467, x468, (x466).get(), (x419).get(), (x451).get()); + Box x469 = new Box((int)0); + Box x470 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x469, x470, (x468).get(), (x421).get(), (x453).get()); + Box x471 = new Box((int)0); + Box x472 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x473, x474, x5, 0x1eb5e412); + Box x475 = new Box((int)0); + Box x476 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x475, x476, x5, 0xa22b3d3b); + Box x477 = new Box((int)0); + Box x478 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x477, x478, x5, 0x620fc84c); + Box x479 = new Box((int)0); + Box x480 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x479, x480, x5, 0x3affe0d4); + Box x481 = new Box((int)0); + Box x482 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x481, x482, x5, 0x3464504a); + Box x483 = new Box((int)0); + Box x484 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x483, x484, x5, 0xde6fa2fa); + Box x485 = new Box((int)0); + Box x486 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x485, x486, x5, 0x901192af); + Box x487 = new Box((int)0); + Box x488 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x487, x488, x5, 0x7c114f20); + Box x489 = new Box((int)0); + Box x490 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x489, x490, 0x0, (x488).get(), (x485).get()); + Box x491 = new Box((int)0); + Box x492 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x491, x492, (x490).get(), (x486).get(), (x483).get()); + Box x493 = new Box((int)0); + Box x494 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x493, x494, (x492).get(), (x484).get(), (x481).get()); + Box x495 = new Box((int)0); + Box x496 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x495, x496, (x494).get(), (x482).get(), (x479).get()); + Box x497 = new Box((int)0); + Box x498 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x497, x498, (x496).get(), (x480).get(), (x477).get()); + Box x499 = new Box((int)0); + Box x500 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x499, x500, (x498).get(), (x478).get(), (x475).get()); + Box x501 = new Box((int)0); + Box x502 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x501, x502, (x500).get(), (x476).get(), (x473).get()); + Box x503 = new Box((int)0); + Box x504 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x503, x504, 0x0, (x457).get(), (x487).get()); + Box x505 = new Box((int)0); + Box x506 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x505, x506, (x504).get(), (x459).get(), (x489).get()); + Box x507 = new Box((int)0); + Box x508 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x507, x508, (x506).get(), (x461).get(), (x491).get()); + Box x509 = new Box((int)0); + Box x510 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x509, x510, (x508).get(), (x463).get(), (x493).get()); + Box x511 = new Box((int)0); + Box x512 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x511, x512, (x510).get(), (x465).get(), (x495).get()); + Box x513 = new Box((int)0); + Box x514 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x513, x514, (x512).get(), (x467).get(), (x497).get()); + Box x515 = new Box((int)0); + Box x516 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x515, x516, (x514).get(), (x469).get(), (x499).get()); + Box x517 = new Box((int)0); + Box x518 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x517, x518, (x516).get(), (x471).get(), (x501).get()); + Box x519 = new Box((int)0); + Box x520 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x519, x520, (x503).get(), 0x72350975); + Box x521 = new Box((int)0); + Box x522 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x521, x522, (x519).get(), 0xfffffffe); + Box x523 = new Box((int)0); + Box x524 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x523, x524, (x519).get(), 0xffffffff); + Box x525 = new Box((int)0); + Box x526 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x525, x526, (x519).get(), 0xffffffff); + Box x527 = new Box((int)0); + Box x528 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x527, x528, (x519).get(), 0xffffffff); + Box x529 = new Box((int)0); + Box x530 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x529, x530, (x519).get(), 0x7203df6b); + Box x531 = new Box((int)0); + Box x532 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x531, x532, (x519).get(), 0x21c6052b); + Box x533 = new Box((int)0); + Box x534 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x533, x534, (x519).get(), 0x53bbf409); + Box x535 = new Box((int)0); + Box x536 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x535, x536, (x519).get(), 0x39d54123); + Box x537 = new Box((int)0); + Box x538 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x537, x538, 0x0, (x536).get(), (x533).get()); + Box x539 = new Box((int)0); + Box x540 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x539, x540, (x538).get(), (x534).get(), (x531).get()); + Box x541 = new Box((int)0); + Box x542 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x541, x542, (x540).get(), (x532).get(), (x529).get()); + Box x543 = new Box((int)0); + Box x544 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x543, x544, (x542).get(), (x530).get(), (x527).get()); + Box x545 = new Box((int)0); + Box x546 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x545, x546, (x544).get(), (x528).get(), (x525).get()); + Box x547 = new Box((int)0); + Box x548 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x547, x548, (x546).get(), (x526).get(), (x523).get()); + Box x549 = new Box((int)0); + Box x550 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x549, x550, (x548).get(), (x524).get(), (x521).get()); + Box x551 = new Box((int)0); + Box x552 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x551, x552, 0x0, (x503).get(), (x535).get()); + Box x553 = new Box((int)0); + Box x554 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x553, x554, (x552).get(), (x505).get(), (x537).get()); + Box x555 = new Box((int)0); + Box x556 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x555, x556, (x554).get(), (x507).get(), (x539).get()); + Box x557 = new Box((int)0); + Box x558 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x557, x558, (x556).get(), (x509).get(), (x541).get()); + Box x559 = new Box((int)0); + Box x560 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x559, x560, (x558).get(), (x511).get(), (x543).get()); + Box x561 = new Box((int)0); + Box x562 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x561, x562, (x560).get(), (x513).get(), (x545).get()); + Box x563 = new Box((int)0); + Box x564 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x563, x564, (x562).get(), (x515).get(), (x547).get()); + Box x565 = new Box((int)0); + Box x566 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x565, x566, (x564).get(), (x517).get(), (x549).get()); + Box x567 = new Box((int)0); + Box x568 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x569, x570, x6, 0x1eb5e412); + Box x571 = new Box((int)0); + Box x572 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x571, x572, x6, 0xa22b3d3b); + Box x573 = new Box((int)0); + Box x574 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x573, x574, x6, 0x620fc84c); + Box x575 = new Box((int)0); + Box x576 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x575, x576, x6, 0x3affe0d4); + Box x577 = new Box((int)0); + Box x578 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x577, x578, x6, 0x3464504a); + Box x579 = new Box((int)0); + Box x580 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x579, x580, x6, 0xde6fa2fa); + Box x581 = new Box((int)0); + Box x582 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x581, x582, x6, 0x901192af); + Box x583 = new Box((int)0); + Box x584 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x583, x584, x6, 0x7c114f20); + Box x585 = new Box((int)0); + Box x586 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x585, x586, 0x0, (x584).get(), (x581).get()); + Box x587 = new Box((int)0); + Box x588 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x587, x588, (x586).get(), (x582).get(), (x579).get()); + Box x589 = new Box((int)0); + Box x590 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x589, x590, (x588).get(), (x580).get(), (x577).get()); + Box x591 = new Box((int)0); + Box x592 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x591, x592, (x590).get(), (x578).get(), (x575).get()); + Box x593 = new Box((int)0); + Box x594 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x593, x594, (x592).get(), (x576).get(), (x573).get()); + Box x595 = new Box((int)0); + Box x596 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x595, x596, (x594).get(), (x574).get(), (x571).get()); + Box x597 = new Box((int)0); + Box x598 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x597, x598, (x596).get(), (x572).get(), (x569).get()); + Box x599 = new Box((int)0); + Box x600 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x599, x600, 0x0, (x553).get(), (x583).get()); + Box x601 = new Box((int)0); + Box x602 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x601, x602, (x600).get(), (x555).get(), (x585).get()); + Box x603 = new Box((int)0); + Box x604 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x603, x604, (x602).get(), (x557).get(), (x587).get()); + Box x605 = new Box((int)0); + Box x606 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x605, x606, (x604).get(), (x559).get(), (x589).get()); + Box x607 = new Box((int)0); + Box x608 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x607, x608, (x606).get(), (x561).get(), (x591).get()); + Box x609 = new Box((int)0); + Box x610 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x609, x610, (x608).get(), (x563).get(), (x593).get()); + Box x611 = new Box((int)0); + Box x612 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x611, x612, (x610).get(), (x565).get(), (x595).get()); + Box x613 = new Box((int)0); + Box x614 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x613, x614, (x612).get(), (x567).get(), (x597).get()); + Box x615 = new Box((int)0); + Box x616 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x615, x616, (x599).get(), 0x72350975); + Box x617 = new Box((int)0); + Box x618 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x617, x618, (x615).get(), 0xfffffffe); + Box x619 = new Box((int)0); + Box x620 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x619, x620, (x615).get(), 0xffffffff); + Box x621 = new Box((int)0); + Box x622 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x621, x622, (x615).get(), 0xffffffff); + Box x623 = new Box((int)0); + Box x624 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x623, x624, (x615).get(), 0xffffffff); + Box x625 = new Box((int)0); + Box x626 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x625, x626, (x615).get(), 0x7203df6b); + Box x627 = new Box((int)0); + Box x628 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x627, x628, (x615).get(), 0x21c6052b); + Box x629 = new Box((int)0); + Box x630 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x629, x630, (x615).get(), 0x53bbf409); + Box x631 = new Box((int)0); + Box x632 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x631, x632, (x615).get(), 0x39d54123); + Box x633 = new Box((int)0); + Box x634 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x633, x634, 0x0, (x632).get(), (x629).get()); + Box x635 = new Box((int)0); + Box x636 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x635, x636, (x634).get(), (x630).get(), (x627).get()); + Box x637 = new Box((int)0); + Box x638 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x637, x638, (x636).get(), (x628).get(), (x625).get()); + Box x639 = new Box((int)0); + Box x640 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x639, x640, (x638).get(), (x626).get(), (x623).get()); + Box x641 = new Box((int)0); + Box x642 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x641, x642, (x640).get(), (x624).get(), (x621).get()); + Box x643 = new Box((int)0); + Box x644 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x643, x644, (x642).get(), (x622).get(), (x619).get()); + Box x645 = new Box((int)0); + Box x646 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x645, x646, (x644).get(), (x620).get(), (x617).get()); + Box x647 = new Box((int)0); + Box x648 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x647, x648, 0x0, (x599).get(), (x631).get()); + Box x649 = new Box((int)0); + Box x650 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x649, x650, (x648).get(), (x601).get(), (x633).get()); + Box x651 = new Box((int)0); + Box x652 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x651, x652, (x650).get(), (x603).get(), (x635).get()); + Box x653 = new Box((int)0); + Box x654 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x653, x654, (x652).get(), (x605).get(), (x637).get()); + Box x655 = new Box((int)0); + Box x656 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x655, x656, (x654).get(), (x607).get(), (x639).get()); + Box x657 = new Box((int)0); + Box x658 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x657, x658, (x656).get(), (x609).get(), (x641).get()); + Box x659 = new Box((int)0); + Box x660 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x659, x660, (x658).get(), (x611).get(), (x643).get()); + Box x661 = new Box((int)0); + Box x662 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x661, x662, (x660).get(), (x613).get(), (x645).get()); + Box x663 = new Box((int)0); + Box x664 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_mulx_u32(x665, x666, x7, 0x1eb5e412); + Box x667 = new Box((int)0); + Box x668 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x667, x668, x7, 0xa22b3d3b); + Box x669 = new Box((int)0); + Box x670 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x669, x670, x7, 0x620fc84c); + Box x671 = new Box((int)0); + Box x672 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x671, x672, x7, 0x3affe0d4); + Box x673 = new Box((int)0); + Box x674 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x673, x674, x7, 0x3464504a); + Box x675 = new Box((int)0); + Box x676 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x675, x676, x7, 0xde6fa2fa); + Box x677 = new Box((int)0); + Box x678 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x677, x678, x7, 0x901192af); + Box x679 = new Box((int)0); + Box x680 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x679, x680, x7, 0x7c114f20); + Box x681 = new Box((int)0); + Box x682 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x681, x682, 0x0, (x680).get(), (x677).get()); + Box x683 = new Box((int)0); + Box x684 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x683, x684, (x682).get(), (x678).get(), (x675).get()); + Box x685 = new Box((int)0); + Box x686 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x685, x686, (x684).get(), (x676).get(), (x673).get()); + Box x687 = new Box((int)0); + Box x688 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x687, x688, (x686).get(), (x674).get(), (x671).get()); + Box x689 = new Box((int)0); + Box x690 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x689, x690, (x688).get(), (x672).get(), (x669).get()); + Box x691 = new Box((int)0); + Box x692 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x691, x692, (x690).get(), (x670).get(), (x667).get()); + Box x693 = new Box((int)0); + Box x694 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x693, x694, (x692).get(), (x668).get(), (x665).get()); + Box x695 = new Box((int)0); + Box x696 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x695, x696, 0x0, (x649).get(), (x679).get()); + Box x697 = new Box((int)0); + Box x698 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x697, x698, (x696).get(), (x651).get(), (x681).get()); + Box x699 = new Box((int)0); + Box x700 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x699, x700, (x698).get(), (x653).get(), (x683).get()); + Box x701 = new Box((int)0); + Box x702 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x701, x702, (x700).get(), (x655).get(), (x685).get()); + Box x703 = new Box((int)0); + Box x704 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x703, x704, (x702).get(), (x657).get(), (x687).get()); + Box x705 = new Box((int)0); + Box x706 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x705, x706, (x704).get(), (x659).get(), (x689).get()); + Box x707 = new Box((int)0); + Box x708 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x707, x708, (x706).get(), (x661).get(), (x691).get()); + Box x709 = new Box((int)0); + Box x710 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x709, x710, (x708).get(), (x663).get(), (x693).get()); + Box x711 = new Box((int)0); + Box x712 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x711, x712, (x695).get(), 0x72350975); + Box x713 = new Box((int)0); + Box x714 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x713, x714, (x711).get(), 0xfffffffe); + Box x715 = new Box((int)0); + Box x716 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x715, x716, (x711).get(), 0xffffffff); + Box x717 = new Box((int)0); + Box x718 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x717, x718, (x711).get(), 0xffffffff); + Box x719 = new Box((int)0); + Box x720 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x719, x720, (x711).get(), 0xffffffff); + Box x721 = new Box((int)0); + Box x722 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x721, x722, (x711).get(), 0x7203df6b); + Box x723 = new Box((int)0); + Box x724 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x723, x724, (x711).get(), 0x21c6052b); + Box x725 = new Box((int)0); + Box x726 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x725, x726, (x711).get(), 0x53bbf409); + Box x727 = new Box((int)0); + Box x728 = new Box((int)0); + fiat_Sm2Scalar_mulx_u32(x727, x728, (x711).get(), 0x39d54123); + Box x729 = new Box((int)0); + Box x730 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x729, x730, 0x0, (x728).get(), (x725).get()); + Box x731 = new Box((int)0); + Box x732 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x731, x732, (x730).get(), (x726).get(), (x723).get()); + Box x733 = new Box((int)0); + Box x734 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x733, x734, (x732).get(), (x724).get(), (x721).get()); + Box x735 = new Box((int)0); + Box x736 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x735, x736, (x734).get(), (x722).get(), (x719).get()); + Box x737 = new Box((int)0); + Box x738 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x737, x738, (x736).get(), (x720).get(), (x717).get()); + Box x739 = new Box((int)0); + Box x740 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x739, x740, (x738).get(), (x718).get(), (x715).get()); + Box x741 = new Box((int)0); + Box x742 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x741, x742, (x740).get(), (x716).get(), (x713).get()); + Box x743 = new Box((int)0); + Box x744 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x743, x744, 0x0, (x695).get(), (x727).get()); + Box x745 = new Box((int)0); + Box x746 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x745, x746, (x744).get(), (x697).get(), (x729).get()); + Box x747 = new Box((int)0); + Box x748 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x747, x748, (x746).get(), (x699).get(), (x731).get()); + Box x749 = new Box((int)0); + Box x750 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x749, x750, (x748).get(), (x701).get(), (x733).get()); + Box x751 = new Box((int)0); + Box x752 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x751, x752, (x750).get(), (x703).get(), (x735).get()); + Box x753 = new Box((int)0); + Box x754 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x753, x754, (x752).get(), (x705).get(), (x737).get()); + Box x755 = new Box((int)0); + Box x756 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x755, x756, (x754).get(), (x707).get(), (x739).get()); + Box x757 = new Box((int)0); + Box x758 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x757, x758, (x756).get(), (x709).get(), (x741).get()); + Box x759 = new Box((int)0); + Box x760 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_subborrowx_u32(x761, x762, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x745).get(), 0x39d54123); + Box x763 = new Box((int)0); + Box x764 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x763, x764, (x762).get(), (x747).get(), 0x53bbf409); + Box x765 = new Box((int)0); + Box x766 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x765, x766, (x764).get(), (x749).get(), 0x21c6052b); + Box x767 = new Box((int)0); + Box x768 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x767, x768, (x766).get(), (x751).get(), 0x7203df6b); + Box x769 = new Box((int)0); + Box x770 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x769, x770, (x768).get(), (x753).get(), 0xffffffff); + Box x771 = new Box((int)0); + Box x772 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x771, x772, (x770).get(), (x755).get(), 0xffffffff); + Box x773 = new Box((int)0); + Box x774 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x773, x774, (x772).get(), (x757).get(), 0xffffffff); + Box x775 = new Box((int)0); + Box x776 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x775, x776, (x774).get(), (x759).get(), 0xfffffffe); + Box x777 = new Box((int)0); + Box x778 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x777, x778, (x776).get(), (x760).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue())); + Box x779 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x779, (x778).get(), (x761).get(), (x745).get()); + Box x780 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x780, (x778).get(), (x763).get(), (x747).get()); + Box x781 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x781, (x778).get(), (x765).get(), (x749).get()); + Box x782 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x782, (x778).get(), (x767).get(), (x751).get()); + Box x783 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x783, (x778).get(), (x769).get(), (x753).get()); + Box x784 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x784, (x778).get(), (x771).get(), (x755).get()); + Box x785 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x785, (x778).get(), (x773).get(), (x757).get()); + Box x786 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_selectznz(int[] out1, int arg1, final int[] arg2, final int[] arg3) { + Box x1 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x1, arg1, (arg2[0]), (arg3[0])); + Box x2 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x2, arg1, (arg2[1]), (arg3[1])); + Box x3 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x3, arg1, (arg2[2]), (arg3[2])); + Box x4 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x4, arg1, (arg2[3]), (arg3[3])); + Box x5 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x5, arg1, (arg2[4]), (arg3[4])); + Box x6 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x6, arg1, (arg2[5]), (arg3[5])); + Box x7 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x7, arg1, (arg2[6]), (arg3[6])); + Box x8 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_set_one(int[] out1) { + out1[0] = 0xc62abedd; + out1[1] = 0xac440bf6; + out1[2] = 0xde39fad4; + out1[3] = 0x8dfc2094; + 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] = 0x1; +} + +/** + * The function fiat_Sm2Scalar_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_Sm2Scalar_msat(int[] out1) { + out1[0] = 0x39d54123; + out1[1] = 0x53bbf409; + out1[2] = 0x21c6052b; + out1[3] = 0x7203df6b; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffffe; + out1[8] = (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()); +} + +/** + * The function fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x4, x5, 0x0, (~arg1), 0x1); + Box x6 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x6, x3, arg1, (x4).get()); + Box x7 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x7, x3, (arg2[0]), (arg3[0])); + Box x8 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x8, x3, (arg2[1]), (arg3[1])); + Box x9 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x9, x3, (arg2[2]), (arg3[2])); + Box x10 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x10, x3, (arg2[3]), (arg3[3])); + Box x11 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x11, x3, (arg2[4]), (arg3[4])); + Box x12 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x12, x3, (arg2[5]), (arg3[5])); + Box x13 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x13, x3, (arg2[6]), (arg3[6])); + Box x14 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x14, x3, (arg2[7]), (arg3[7])); + Box x15 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x15, x3, (arg2[8]), (arg3[8])); + Box x16 = new Box((int)0); + Box x17 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x16, x17, 0x0, 0x1, (~(arg2[0]))); + Box x18 = new Box((int)0); + Box x19 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x32, x33, (x31).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (~(arg2[8]))); + Box x34 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x34, x3, (arg3[0]), (x16).get()); + Box x35 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x35, x3, (arg3[1]), (x18).get()); + Box x36 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x36, x3, (arg3[2]), (x20).get()); + Box x37 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x37, x3, (arg3[3]), (x22).get()); + Box x38 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x38, x3, (arg3[4]), (x24).get()); + Box x39 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x39, x3, (arg3[5]), (x26).get()); + Box x40 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x40, x3, (arg3[6]), (x28).get()); + Box x41 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x41, x3, (arg3[7]), (x30).get()); + Box x42 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x42, x3, (arg3[8]), (x32).get()); + Box x43 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x43, x3, (arg4[0]), (arg5[0])); + Box x44 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x44, x3, (arg4[1]), (arg5[1])); + Box x45 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x45, x3, (arg4[2]), (arg5[2])); + Box x46 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x46, x3, (arg4[3]), (arg5[3])); + Box x47 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x47, x3, (arg4[4]), (arg5[4])); + Box x48 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x48, x3, (arg4[5]), (arg5[5])); + Box x49 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x49, x3, (arg4[6]), (arg5[6])); + Box x50 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x50, x3, (arg4[7]), (arg5[7])); + Box x51 = new Box((int)0); + Box x52 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x51, x52, 0x0, (x43).get(), (x43).get()); + Box x53 = new Box((int)0); + Box x54 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x53, x54, (x52).get(), (x44).get(), (x44).get()); + Box x55 = new Box((int)0); + Box x56 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x55, x56, (x54).get(), (x45).get(), (x45).get()); + Box x57 = new Box((int)0); + Box x58 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x57, x58, (x56).get(), (x46).get(), (x46).get()); + Box x59 = new Box((int)0); + Box x60 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x59, x60, (x58).get(), (x47).get(), (x47).get()); + Box x61 = new Box((int)0); + Box x62 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x61, x62, (x60).get(), (x48).get(), (x48).get()); + Box x63 = new Box((int)0); + Box x64 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x63, x64, (x62).get(), (x49).get(), (x49).get()); + Box x65 = new Box((int)0); + Box x66 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x65, x66, (x64).get(), (x50).get(), (x50).get()); + Box x67 = new Box((int)0); + Box x68 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x67, x68, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x51).get(), 0x39d54123); + Box x69 = new Box((int)0); + Box x70 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x69, x70, (x68).get(), (x53).get(), 0x53bbf409); + Box x71 = new Box((int)0); + Box x72 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x71, x72, (x70).get(), (x55).get(), 0x21c6052b); + Box x73 = new Box((int)0); + Box x74 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x73, x74, (x72).get(), (x57).get(), 0x7203df6b); + Box x75 = new Box((int)0); + Box x76 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x75, x76, (x74).get(), (x59).get(), 0xffffffff); + Box x77 = new Box((int)0); + Box x78 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x77, x78, (x76).get(), (x61).get(), 0xffffffff); + Box x79 = new Box((int)0); + Box x80 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x79, x80, (x78).get(), (x63).get(), 0xffffffff); + Box x81 = new Box((int)0); + Box x82 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x81, x82, (x80).get(), (x65).get(), 0xfffffffe); + Box x83 = new Box((int)0); + Box x84 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_subborrowx_u32(x107, x108, (x106).get(), (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), x85); + Box x109 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x110, x111, 0x0, (x93).get(), ((x109).get() & 0x39d54123)); + Box x112 = new Box((int)0); + Box x113 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x112, x113, (x111).get(), (x95).get(), ((x109).get() & 0x53bbf409)); + Box x114 = new Box((int)0); + Box x115 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x114, x115, (x113).get(), (x97).get(), ((x109).get() & 0x21c6052b)); + Box x116 = new Box((int)0); + Box x117 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x116, x117, (x115).get(), (x99).get(), ((x109).get() & 0x7203df6b)); + Box x118 = new Box((int)0); + Box x119 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x118, x119, (x117).get(), (x101).get(), (x109).get()); + Box x120 = new Box((int)0); + Box x121 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x120, x121, (x119).get(), (x103).get(), (x109).get()); + Box x122 = new Box((int)0); + Box x123 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x122, x123, (x121).get(), (x105).get(), (x109).get()); + Box x124 = new Box((int)0); + Box x125 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x124, x125, (x123).get(), (x107).get(), ((x109).get() & 0xfffffffe)); + Box x126 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x126, x3, (arg5[0]), (x110).get()); + Box x127 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x127, x3, (arg5[1]), (x112).get()); + Box x128 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x128, x3, (arg5[2]), (x114).get()); + Box x129 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x129, x3, (arg5[3]), (x116).get()); + Box x130 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x130, x3, (arg5[4]), (x118).get()); + Box x131 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x131, x3, (arg5[5]), (x120).get()); + Box x132 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x132, x3, (arg5[6]), (x122).get()); + Box x133 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x133, x3, (arg5[7]), (x124).get()); + int x134 = ((x34).get() & 0x1); + Box x135 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x135, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x7).get()); + Box x136 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x136, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x8).get()); + Box x137 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x137, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x9).get()); + Box x138 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x138, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x10).get()); + Box x139 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x139, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x11).get()); + Box x140 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x140, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x12).get()); + Box x141 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x141, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x13).get()); + Box x142 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x142, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x14).get()); + Box x143 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x144, x145, 0x0, (x34).get(), (x135).get()); + Box x146 = new Box((int)0); + Box x147 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x146, x147, (x145).get(), (x35).get(), (x136).get()); + Box x148 = new Box((int)0); + Box x149 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x148, x149, (x147).get(), (x36).get(), (x137).get()); + Box x150 = new Box((int)0); + Box x151 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x150, x151, (x149).get(), (x37).get(), (x138).get()); + Box x152 = new Box((int)0); + Box x153 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x152, x153, (x151).get(), (x38).get(), (x139).get()); + Box x154 = new Box((int)0); + Box x155 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x154, x155, (x153).get(), (x39).get(), (x140).get()); + Box x156 = new Box((int)0); + Box x157 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x156, x157, (x155).get(), (x40).get(), (x141).get()); + Box x158 = new Box((int)0); + Box x159 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x158, x159, (x157).get(), (x41).get(), (x142).get()); + Box x160 = new Box((int)0); + Box x161 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x160, x161, (x159).get(), (x42).get(), (x143).get()); + Box x162 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x162, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x43).get()); + Box x163 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x163, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x44).get()); + Box x164 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x164, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x45).get()); + Box x165 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x165, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x46).get()); + Box x166 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x166, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x47).get()); + Box x167 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x167, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x48).get()); + Box x168 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x168, x134, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x49).get()); + Box x169 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_addcarryx_u32(x170, x171, 0x0, (x126).get(), (x162).get()); + Box x172 = new Box((int)0); + Box x173 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x172, x173, (x171).get(), (x127).get(), (x163).get()); + Box x174 = new Box((int)0); + Box x175 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x174, x175, (x173).get(), (x128).get(), (x164).get()); + Box x176 = new Box((int)0); + Box x177 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x176, x177, (x175).get(), (x129).get(), (x165).get()); + Box x178 = new Box((int)0); + Box x179 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x178, x179, (x177).get(), (x130).get(), (x166).get()); + Box x180 = new Box((int)0); + Box x181 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x180, x181, (x179).get(), (x131).get(), (x167).get()); + Box x182 = new Box((int)0); + Box x183 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x182, x183, (x181).get(), (x132).get(), (x168).get()); + Box x184 = new Box((int)0); + Box x185 = new Box((int)0); + fiat_Sm2Scalar_addcarryx_u32(x184, x185, (x183).get(), (x133).get(), (x169).get()); + Box x186 = new Box((int)0); + Box x187 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x186, x187, (int) Integer.toUnsignedLong(((Number) (0x0)).intValue()), (x170).get(), 0x39d54123); + Box x188 = new Box((int)0); + Box x189 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x188, x189, (x187).get(), (x172).get(), 0x53bbf409); + Box x190 = new Box((int)0); + Box x191 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x190, x191, (x189).get(), (x174).get(), 0x21c6052b); + Box x192 = new Box((int)0); + Box x193 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x192, x193, (x191).get(), (x176).get(), 0x7203df6b); + Box x194 = new Box((int)0); + Box x195 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x194, x195, (x193).get(), (x178).get(), 0xffffffff); + Box x196 = new Box((int)0); + Box x197 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x196, x197, (x195).get(), (x180).get(), 0xffffffff); + Box x198 = new Box((int)0); + Box x199 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x198, x199, (x197).get(), (x182).get(), 0xffffffff); + Box x200 = new Box((int)0); + Box x201 = new Box((int)0); + fiat_Sm2Scalar_subborrowx_u32(x200, x201, (x199).get(), (x184).get(), 0xfffffffe); + Box x202 = new Box((int)0); + Box x203 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_cmovznz_u32(x215, (x84).get(), (x67).get(), (x51).get()); + Box x216 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x216, (x84).get(), (x69).get(), (x53).get()); + Box x217 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x217, (x84).get(), (x71).get(), (x55).get()); + Box x218 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x218, (x84).get(), (x73).get(), (x57).get()); + Box x219 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x219, (x84).get(), (x75).get(), (x59).get()); + Box x220 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x220, (x84).get(), (x77).get(), (x61).get()); + Box x221 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x221, (x84).get(), (x79).get(), (x63).get()); + Box x222 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x222, (x84).get(), (x81).get(), (x65).get()); + Box x223 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x223, (x203).get(), (x186).get(), (x170).get()); + Box x224 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x224, (x203).get(), (x188).get(), (x172).get()); + Box x225 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x225, (x203).get(), (x190).get(), (x174).get()); + Box x226 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x226, (x203).get(), (x192).get(), (x176).get()); + Box x227 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x227, (x203).get(), (x194).get(), (x178).get()); + Box x228 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x228, (x203).get(), (x196).get(), (x180).get()); + Box x229 = new Box((int)0); + fiat_Sm2Scalar_cmovznz_u32(x229, (x203).get(), (x198).get(), (x182).get()); + Box x230 = new Box((int)0); + fiat_Sm2Scalar_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_Sm2Scalar_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_Sm2Scalar_divstep_precomp(int[] out1) { + out1[0] = 0xb351756d; + out1[1] = 0x1aa32707; + out1[2] = 0x1e2a62fa; + out1[3] = 0xabdd67; + out1[4] = 0xd4009a81; + out1[5] = 0x49280d7d; + out1[6] = 0xe6bb86e8; + out1[7] = 0xd730336e; +} + +} diff --git a/fiat-json/src/sm2_32.json b/fiat-json/src/sm2_32.json new file mode 100644 index 00000000000..8249258dbe2 --- /dev/null +++ b/fiat-json/src/sm2_32.json @@ -0,0 +1,81085 @@ +[ + { + "operation": "fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + "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": [ + "x23" + ] + } + ] + }, + "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": [ + "x23" + ] + } + ] + }, + "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": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x51" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "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": [ + { + "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": [ + "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": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "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": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x65" + ], + "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": [ + "x41" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x67" + ], + "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": [ + "x52" + ] + } + ] + } + ] + }, + { + "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": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "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": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + "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" + ] + } + ] + }, + { + "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": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "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": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "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": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "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": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "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": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "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": [ + "x86", + "x87" + ], + "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": [ + "x88", + "x89" + ], + "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": [ + "x90", + "x91" + ], + "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": [ + "x92", + "x93" + ], + "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": [ + "x94", + "x95" + ], + "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": [ + "x96", + "x97" + ], + "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": [ + "x98", + "x99" + ], + "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": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x96" + ] + } + ] + } + ] + }, + { + "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": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "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": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "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": [ + "x93" + ] + } + ] + }, + { + "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": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "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": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "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": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x85" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x98" + ] + } + ] + } + ] + }, + { + "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": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "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": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "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": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "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": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "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": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "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": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "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": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x149" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x144" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "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": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "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": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "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": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x158" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x134" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "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": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "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": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "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": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "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": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "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": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "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": [ + "x129" + ] + } + ] + }, + { + "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": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x177" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + } + ] + }, + { + "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[7]" + ] + } + ] + }, + { + "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[6]" + ] + } + ] + }, + { + "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[5]" + ] + } + ] + }, + { + "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[4]" + ] + } + ] + }, + { + "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[3]" + ] + } + ] + }, + { + "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[2]" + ] + } + ] + }, + { + "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[1]" + ] + } + ] + }, + { + "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[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "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": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "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": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "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": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "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": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "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": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x208" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x179" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "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": [ + "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": [ + { + "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": [ + "x177" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x243" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x238" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "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": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "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": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x252" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x228" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x254" + ], + "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": [ + "x239" + ] + } + ] + } + ] + }, + { + "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": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "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": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "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": [ + "x215" + ] + } + ] + }, + { + "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": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "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": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "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": [ + "x248" + ] + } + ] + } + ] + }, + { + "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": [ + "x250" + ] + } + ] + } + ] + }, + { + "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": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x271" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "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": [ + "x274", + "x275" + ], + "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": [ + "x276", + "x277" + ], + "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": [ + "x278", + "x279" + ], + "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": [ + "x280", + "x281" + ], + "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": [ + "x282", + "x283" + ], + "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": [ + "x284", + "x285" + ], + "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": [ + "x286", + "x287" + ], + "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": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "(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": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + }, + { + "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": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + }, + { + "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": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "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": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + }, + { + "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": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "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": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x302" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x273" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "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": [ + "x286" + ] + } + ] + } + ] + }, + { + "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": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + } + ] + }, + { + "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": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + } + ] + }, + { + "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": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + } + ] + }, + { + "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": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + }, + { + "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": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + } + ] + }, + { + "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": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "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": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "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": [ + "x271" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "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": [ + "x303" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x303" + ] + } + ] + }, + "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": [ + "x303" + ] + } + ] + }, + "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": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "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": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x327" + ] + } + ] + } + ] + }, + { + "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": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + } + ] + }, + { + "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": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + }, + { + "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": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x346" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x322" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x335" + ] + } + ] + } + ] + }, + { + "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": [ + "x337" + ] + } + ] + }, + { + "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": [ + "x329" + ] + } + ] + } + ] + }, + { + "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": [ + "x338" + ] + } + ] + } + ] + }, + { + "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": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "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": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "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": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "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": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x365" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "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": [ + "x368", + "x369" + ], + "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": [ + "x370", + "x371" + ], + "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": [ + "x372", + "x373" + ], + "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": [ + "x374", + "x375" + ], + "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": [ + "x376", + "x377" + ], + "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": [ + "x378", + "x379" + ], + "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": [ + "x380", + "x381" + ], + "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": [ + "x382", + "x383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + } + ] + }, + { + "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": [ + "x377" + ] + } + ] + }, + { + "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": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "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": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "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": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + } + ] + }, + { + "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": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x396" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x367" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "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": [ + "x380" + ] + } + ] + } + ] + }, + { + "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": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x365" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x397" + ] + } + ] + }, + "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": [ + "x397" + ] + } + ] + }, + "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": [ + "x397" + ] + } + ] + }, + "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": [ + "x397" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x431" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x426" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + } + ] + }, + { + "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": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + }, + { + "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": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x440" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x416" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x442" + ], + "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": [ + "x427" + ] + } + ] + } + ] + }, + { + "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": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "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": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "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": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "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": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "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": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "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": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "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": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + } + ] + }, + { + "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": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x459" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "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": [ + "x462", + "x463" + ], + "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": [ + "x464", + "x465" + ], + "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": [ + "x466", + "x467" + ], + "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": [ + "x468", + "x469" + ], + "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": [ + "x470", + "x471" + ], + "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": [ + "x472", + "x473" + ], + "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": [ + "x474", + "x475" + ], + "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": [ + "x476", + "x477" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + } + ] + }, + { + "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": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + } + ] + }, + { + "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": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + }, + { + "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": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + } + ] + }, + { + "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": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + } + ] + }, + { + "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": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x490" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x461" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + } + ] + }, + { + "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": [ + "x445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + } + ] + }, + { + "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": [ + "x447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + } + ] + }, + { + "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": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + } + ] + }, + { + "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": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + } + ] + }, + { + "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": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + } + ] + }, + { + "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": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + } + ] + }, + { + "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": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + } + ] + }, + { + "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": [ + "x459" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "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": [ + "x519", + "x520" + ], + "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": [ + "x521", + "x522" + ], + "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": [ + "x523", + "x524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x519" + ] + } + ] + } + ] + }, + { + "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": [ + "x520" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + } + ] + }, + { + "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": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + }, + { + "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": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "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": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x534" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x510" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "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": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "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": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "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": [ + "x497" + ] + } + ] + }, + { + "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": [ + "x499" + ] + } + ] + }, + { + "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": [ + "x501" + ] + } + ] + }, + { + "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": [ + "x503" + ] + } + ] + }, + { + "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": [ + "x505" + ] + } + ] + }, + { + "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": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x553" + ], + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x554", + "x555" + ], + "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": [ + "x556", + "x557" + ], + "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": [ + "x558", + "x559" + ], + "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": [ + "x560", + "x561" + ], + "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": [ + "x562", + "x563" + ], + "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": [ + "x564", + "x565" + ], + "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": [ + "x566", + "x567" + ], + "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": [ + "x568", + "x569" + ], + "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": [ + "x570", + "x571" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "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": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + } + ] + }, + { + "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": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + }, + { + "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": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + } + ] + }, + { + "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": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + } + ] + }, + { + "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": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x584" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x555" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x537" + ] + } + ] + }, + { + "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": [ + "x539" + ] + } + ] + }, + { + "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": [ + "x541" + ] + } + ] + }, + { + "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": [ + "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": [ + "x553" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "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": [ + "x585" + ] + } + ] + }, + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x619" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x614" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + } + ] + }, + { + "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": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "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": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "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": [ + "x604" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x615" + ] + } + ] + } + ] + }, + { + "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": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "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": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "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": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "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": [ + "x593" + ] + } + ] + }, + { + "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": [ + "x595" + ] + } + ] + }, + { + "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": [ + "x597" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + } + ] + }, + { + "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": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x647" + ], + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "x649" + ], + "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": [ + "x650", + "x651" + ], + "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": [ + "x652", + "x653" + ], + "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": [ + "x654", + "x655" + ], + "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": [ + "x656", + "x657" + ], + "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": [ + "x658", + "x659" + ], + "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": [ + "x660", + "x661" + ], + "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": [ + "x662", + "x663" + ], + "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": [ + "x664", + "x665" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x660" + ] + } + ] + } + ] + }, + { + "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": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + } + ] + }, + { + "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": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + } + ] + }, + { + "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": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + } + ] + }, + { + "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": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + } + ] + }, + { + "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": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + } + ] + }, + { + "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": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x678" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x649" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x662" + ] + } + ] + } + ] + }, + { + "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": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + } + ] + }, + { + "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": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + } + ] + }, + { + "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": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + } + ] + }, + { + "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": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + } + ] + }, + { + "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": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + } + ] + }, + { + "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": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + } + ] + }, + { + "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": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + } + ] + }, + { + "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": [ + "x647" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "x712" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x713" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + }, + { + "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": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "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": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "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": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x722" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x698" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x724" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + }, + { + "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": [ + "x681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x727", + "x728" + ], + "operation": "addcarryx", + "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": [ + "x683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x729", + "x730" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "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": [ + "x705" + ] + } + ] + } + ] + }, + { + "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": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + } + ] + }, + { + "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": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + } + ] + }, + { + "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": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + } + ] + }, + { + "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": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + } + ] + }, + { + "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": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x741" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x742", + "x743" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x744", + "x745" + ], + "operation": "subborrowx", + "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": [ + "x727" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x746", + "x747" + ], + "operation": "subborrowx", + "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": [ + "x729" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x748", + "x749" + ], + "operation": "subborrowx", + "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": [ + "x731" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "subborrowx", + "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": [ + "x733" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "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": [ + "x741" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x760" + ], + "operation": "cmovznz", + "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": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x761" + ], + "operation": "cmovznz", + "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": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x762" + ], + "operation": "cmovznz", + "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": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x763" + ], + "operation": "cmovznz", + "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": [ + "x748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x764" + ], + "operation": "cmovznz", + "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": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x765" + ], + "operation": "cmovznz", + "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": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x766" + ], + "operation": "cmovznz", + "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": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x767" + ], + "operation": "cmovznz", + "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": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x760" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x761" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x762" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x763" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x764" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x765" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x766" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "operation": "fiat_sm2_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", + "x41" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x23" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + "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": [ + "x23" + ] + } + ] + }, + "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": [ + "x23" + ] + } + ] + }, + "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": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x54", + "x55" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x56" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x51" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x49" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "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": [ + { + "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": [ + "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": [ + "x45" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + } + ] + }, + { + "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": [ + "x43" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x40" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x65" + ], + "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": [ + "x41" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x67" + ], + "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": [ + "x52" + ] + } + ] + } + ] + }, + { + "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": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x54" + ] + } + ] + } + ] + }, + { + "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": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x56" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + "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" + ] + } + ] + }, + { + "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": [ + "x57" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "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": "static_cast", + "arguments": [ + "x33" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + }, + { + "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": [ + "x35" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x61" + ] + } + ] + } + ] + }, + { + "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": [ + "x37" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x63" + ] + } + ] + } + ] + }, + { + "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": [ + "x39" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "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": [ + "x86", + "x87" + ], + "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": [ + "x88", + "x89" + ], + "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": [ + "x90", + "x91" + ], + "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": [ + "x92", + "x93" + ], + "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": [ + "x94", + "x95" + ], + "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": [ + "x96", + "x97" + ], + "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": [ + "x98", + "x99" + ], + "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": [ + "x100", + "x101" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x96" + ] + } + ] + } + ] + }, + { + "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": [ + "x97" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "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": [ + "x95" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x92" + ] + } + ] + } + ] + }, + { + "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": [ + "x93" + ] + } + ] + }, + { + "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": [ + "x91" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "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": [ + "x89" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "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": [ + "x87" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x114" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x85" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x98" + ] + } + ] + } + ] + }, + { + "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": [ + "x70" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + } + ] + }, + { + "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": [ + "x72" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "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": [ + "x74" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "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": [ + "x76" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "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": [ + "x78" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + } + ] + }, + { + "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": [ + "x80" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + } + ] + }, + { + "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": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x112" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x83" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x114" + ] + } + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "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": [ + "x115" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x149" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x144" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "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": [ + "x140" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "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": [ + "x138" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + }, + { + "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": [ + "x136" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x158" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x134" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x160" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "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": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + { + "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": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "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": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x150" + ] + } + ] + } + ] + }, + { + "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": [ + "x125" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x152" + ] + } + ] + } + ] + }, + { + "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": [ + "x127" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x154" + ] + } + ] + } + ] + }, + { + "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": [ + "x129" + ] + } + ] + }, + { + "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": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x177" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + } + ] + }, + { + "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[7]" + ] + } + ] + }, + { + "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[6]" + ] + } + ] + }, + { + "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[5]" + ] + } + ] + }, + { + "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[4]" + ] + } + ] + }, + { + "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[3]" + ] + } + ] + }, + { + "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[2]" + ] + } + ] + }, + { + "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[1]" + ] + } + ] + }, + { + "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[0]" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x194", + "x195" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x191" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + } + ] + }, + { + "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": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + } + ] + }, + { + "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": [ + "x187" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "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": [ + "x185" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "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": [ + "x183" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "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": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x208" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x179" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x209", + "x210" + ], + "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": [ + "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": [ + { + "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": [ + "x177" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "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": [ + "x209" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x241", + "x242" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x243" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x238" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x244", + "x245" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x234" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + } + ] + }, + { + "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": [ + "x232" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x229" + ] + } + ] + } + ] + }, + { + "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": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x227" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x252" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x228" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x254" + ], + "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": [ + "x239" + ] + } + ] + } + ] + }, + { + "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": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + } + ] + }, + { + "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": [ + "x213" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + }, + { + "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": [ + "x215" + ] + } + ] + }, + { + "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": [ + "x217" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "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": [ + "x219" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "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": [ + "x248" + ] + } + ] + } + ] + }, + { + "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": [ + "x250" + ] + } + ] + } + ] + }, + { + "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": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x271" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x226" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x272", + "x273" + ], + "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": [ + "x274", + "x275" + ], + "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": [ + "x276", + "x277" + ], + "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": [ + "x278", + "x279" + ], + "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": [ + "x280", + "x281" + ], + "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": [ + "x282", + "x283" + ], + "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": [ + "x284", + "x285" + ], + "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": [ + "x286", + "x287" + ], + "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": [ + "x288", + "x289" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "(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": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x282" + ] + } + ] + } + ] + }, + { + "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": [ + "x283" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x280" + ] + } + ] + } + ] + }, + { + "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": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "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": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + }, + { + "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": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "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": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x302" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x273" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x303", + "x304" + ], + "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": [ + "x286" + ] + } + ] + } + ] + }, + { + "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": [ + "x257" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x288" + ] + } + ] + } + ] + }, + { + "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": [ + "x259" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + } + ] + }, + { + "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": [ + "x261" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + } + ] + }, + { + "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": [ + "x263" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + }, + { + "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": [ + "x265" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x296" + ] + } + ] + } + ] + }, + { + "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": [ + "x267" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "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": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x300" + ] + } + ] + } + ] + }, + { + "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": [ + "x271" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x302" + ] + } + ] + }, + { + "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": [ + "x303" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x325", + "x326" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x327", + "x328" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x303" + ] + } + ] + }, + "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": [ + "x303" + ] + } + ] + }, + "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": [ + "x303" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "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": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x338", + "x339" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x327" + ] + } + ] + } + ] + }, + { + "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": [ + "x328" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x325" + ] + } + ] + } + ] + }, + { + "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": [ + "x326" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x323" + ] + } + ] + } + ] + }, + { + "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": [ + "x324" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x321" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x346" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x322" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x348" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x335" + ] + } + ] + } + ] + }, + { + "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": [ + "x337" + ] + } + ] + }, + { + "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": [ + "x329" + ] + } + ] + } + ] + }, + { + "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": [ + "x338" + ] + } + ] + } + ] + }, + { + "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": [ + "x313" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "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": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "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": [ + "x317" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x344" + ] + } + ] + } + ] + }, + { + "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": [ + "x319" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x365" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x320" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x366", + "x367" + ], + "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": [ + "x368", + "x369" + ], + "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": [ + "x370", + "x371" + ], + "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": [ + "x372", + "x373" + ], + "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": [ + "x374", + "x375" + ], + "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": [ + "x376", + "x377" + ], + "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": [ + "x378", + "x379" + ], + "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": [ + "x380", + "x381" + ], + "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": [ + "x382", + "x383" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x379" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x376" + ] + } + ] + } + ] + }, + { + "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": [ + "x377" + ] + } + ] + }, + { + "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": [ + "x375" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x372" + ] + } + ] + } + ] + }, + { + "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": [ + "x373" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "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": [ + "x371" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + } + ] + }, + { + "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": [ + "x369" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x366" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x396" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x367" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x397", + "x398" + ], + "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": [ + "x380" + ] + } + ] + } + ] + }, + { + "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": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x365" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x396" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x397" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x397" + ] + } + ] + }, + "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": [ + "x397" + ] + } + ] + }, + "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": [ + "x397" + ] + } + ] + }, + "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": [ + "x397" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x429", + "x430" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x431" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x426" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x432", + "x433" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x422" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x419" + ] + } + ] + } + ] + }, + { + "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": [ + "x420" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + }, + { + "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": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x440" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x416" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x442" + ], + "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": [ + "x427" + ] + } + ] + } + ] + }, + { + "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": [ + "x399" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "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": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x431" + ] + } + ] + }, + { + "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": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x423" + ] + } + ] + } + ] + }, + { + "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": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "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": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "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": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "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": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + } + ] + }, + { + "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": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x459" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x458" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "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": [ + "x462", + "x463" + ], + "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": [ + "x464", + "x465" + ], + "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": [ + "x466", + "x467" + ], + "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": [ + "x468", + "x469" + ], + "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": [ + "x470", + "x471" + ], + "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": [ + "x472", + "x473" + ], + "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": [ + "x474", + "x475" + ], + "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": [ + "x476", + "x477" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + } + ] + }, + { + "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": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + } + ] + }, + { + "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": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + }, + { + "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": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + } + ] + }, + { + "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": [ + "x465" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + } + ] + }, + { + "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": [ + "x463" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x460" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x490" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x461" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x491", + "x492" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x443" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + } + ] + }, + { + "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": [ + "x445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + } + ] + }, + { + "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": [ + "x447" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x478" + ] + } + ] + } + ] + }, + { + "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": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x480" + ] + } + ] + } + ] + }, + { + "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": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x482" + ] + } + ] + } + ] + }, + { + "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": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x484" + ] + } + ] + } + ] + }, + { + "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": [ + "x455" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x486" + ] + } + ] + } + ] + }, + { + "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": [ + "x457" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x488" + ] + } + ] + } + ] + }, + { + "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": [ + "x459" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x490" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x517", + "x518" + ], + "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": [ + "x519", + "x520" + ], + "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": [ + "x521", + "x522" + ], + "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": [ + "x523", + "x524" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x519" + ] + } + ] + } + ] + }, + { + "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": [ + "x520" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + } + ] + }, + { + "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": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + } + ] + }, + { + "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": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "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": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x534" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x510" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x536" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "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": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + } + ] + }, + { + "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": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x525" + ] + } + ] + }, + { + "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": [ + "x497" + ] + } + ] + }, + { + "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": [ + "x499" + ] + } + ] + }, + { + "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": [ + "x501" + ] + } + ] + }, + { + "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": [ + "x503" + ] + } + ] + }, + { + "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": [ + "x505" + ] + } + ] + }, + { + "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": [ + "x507" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x534" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x553" + ], + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x554", + "x555" + ], + "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": [ + "x556", + "x557" + ], + "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": [ + "x558", + "x559" + ], + "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": [ + "x560", + "x561" + ], + "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": [ + "x562", + "x563" + ], + "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": [ + "x564", + "x565" + ], + "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": [ + "x566", + "x567" + ], + "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": [ + "x568", + "x569" + ], + "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": [ + "x570", + "x571" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x567" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x564" + ] + } + ] + } + ] + }, + { + "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": [ + "x565" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x562" + ] + } + ] + } + ] + }, + { + "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": [ + "x563" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x560" + ] + } + ] + } + ] + }, + { + "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": [ + "x561" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x558" + ] + } + ] + } + ] + }, + { + "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": [ + "x559" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x556" + ] + } + ] + } + ] + }, + { + "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": [ + "x557" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x554" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x584" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x555" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x537" + ] + } + ] + }, + { + "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": [ + "x539" + ] + } + ] + }, + { + "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": [ + "x541" + ] + } + ] + }, + { + "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": [ + "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": [ + "x553" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x584" + ] + } + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x585" + ] + } + ] + }, + "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": [ + "x585" + ] + } + ] + }, + "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": [ + "x585" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x617", + "x618" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x619" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x614" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x620", + "x621" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x610" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + } + ] + }, + { + "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": [ + "x608" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "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": [ + "x606" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x603" + ] + } + ] + } + ] + }, + { + "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": [ + "x604" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x630" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x615" + ] + } + ] + } + ] + }, + { + "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": [ + "x587" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x617" + ] + } + ] + } + ] + }, + { + "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": [ + "x589" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x619" + ] + } + ] + }, + { + "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": [ + "x591" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x611" + ] + } + ] + } + ] + }, + { + "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": [ + "x593" + ] + } + ] + }, + { + "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": [ + "x595" + ] + } + ] + }, + { + "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": [ + "x597" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x599" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x626" + ] + } + ] + } + ] + }, + { + "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": [ + "x601" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x647" + ], + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x602" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x648", + "x649" + ], + "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": [ + "x650", + "x651" + ], + "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": [ + "x652", + "x653" + ], + "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": [ + "x654", + "x655" + ], + "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": [ + "x656", + "x657" + ], + "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": [ + "x658", + "x659" + ], + "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": [ + "x660", + "x661" + ], + "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": [ + "x662", + "x663" + ], + "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": [ + "x664", + "x665" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x660" + ] + } + ] + } + ] + }, + { + "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": [ + "x661" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x658" + ] + } + ] + } + ] + }, + { + "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": [ + "x659" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x656" + ] + } + ] + } + ] + }, + { + "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": [ + "x657" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x654" + ] + } + ] + } + ] + }, + { + "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": [ + "x655" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x652" + ] + } + ] + } + ] + }, + { + "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": [ + "x653" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x650" + ] + } + ] + } + ] + }, + { + "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": [ + "x651" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x648" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x678" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x649" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x662" + ] + } + ] + } + ] + }, + { + "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": [ + "x633" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + } + ] + }, + { + "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": [ + "x635" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x666" + ] + } + ] + } + ] + }, + { + "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": [ + "x637" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x668" + ] + } + ] + } + ] + }, + { + "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": [ + "x639" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x670" + ] + } + ] + } + ] + }, + { + "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": [ + "x641" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x672" + ] + } + ] + } + ] + }, + { + "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": [ + "x643" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x674" + ] + } + ] + } + ] + }, + { + "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": [ + "x645" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x676" + ] + } + ] + } + ] + }, + { + "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": [ + "x647" + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x678" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x697", + "x698" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x699", + "x700" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x701", + "x702" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x703", + "x704" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x705", + "x706" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x707", + "x708" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x709", + "x710" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x711", + "x712" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": "u32", + "name": [ + "x713" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x712" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x708" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x706" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x703" + ] + } + ] + } + ] + }, + { + "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": [ + "x704" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x701" + ] + } + ] + } + ] + }, + { + "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": [ + "x702" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x699" + ] + } + ] + } + ] + }, + { + "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": [ + "x700" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x697" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x722" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "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": [ + "x698" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x724" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x709" + ] + } + ] + } + ] + }, + { + "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": [ + "x681" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x711" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x727", + "x728" + ], + "operation": "addcarryx", + "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": [ + "x683" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x713" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x729", + "x730" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x728" + ] + } + ] + }, + { + "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": [ + "x705" + ] + } + ] + } + ] + }, + { + "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": [ + "x687" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x714" + ] + } + ] + } + ] + }, + { + "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": [ + "x689" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x716" + ] + } + ] + } + ] + }, + { + "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": [ + "x691" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x718" + ] + } + ] + } + ] + }, + { + "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": [ + "x693" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x720" + ] + } + ] + } + ] + }, + { + "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": [ + "x695" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x722" + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x741" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x740" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x696" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x742", + "x743" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x744", + "x745" + ], + "operation": "subborrowx", + "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": [ + "x727" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x746", + "x747" + ], + "operation": "subborrowx", + "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": [ + "x729" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x748", + "x749" + ], + "operation": "subborrowx", + "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": [ + "x731" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x750", + "x751" + ], + "operation": "subborrowx", + "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": [ + "x733" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "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": [ + "x741" + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x760" + ], + "operation": "cmovznz", + "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": [ + "x742" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x725" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x761" + ], + "operation": "cmovznz", + "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": [ + "x744" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x727" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x762" + ], + "operation": "cmovznz", + "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": [ + "x746" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x729" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x763" + ], + "operation": "cmovznz", + "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": [ + "x748" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x731" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x764" + ], + "operation": "cmovznz", + "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": [ + "x750" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x733" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x765" + ], + "operation": "cmovznz", + "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": [ + "x752" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x735" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x766" + ], + "operation": "cmovznz", + "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": [ + "x754" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x737" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x767" + ], + "operation": "cmovznz", + "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": [ + "x756" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x739" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x760" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x761" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x762" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x763" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x764" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x765" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x766" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x767" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x0" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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": [ + "x17" + ] + } + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "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_sm2_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": [ + "x17" + ] + } + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "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_sm2_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", + "x3" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x10", + "x11" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x12", + "x13" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x14", + "x15" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x16", + "x17" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x18", + "x19" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x9" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "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": [ + "x7" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "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": [ + "x5" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x27" + ], + "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": [ + "x14" + ] + } + ] + } + ] + }, + { + "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": "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": "+", + "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": [ + "x13" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x10" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x28" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "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": [ + "x30" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "+", + "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": "+", + "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": [ + "x3" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x58", + "x59" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x60", + "x61" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x42" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x42" + ] + } + ] + }, + "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": [ + "x42" + ] + } + ] + }, + "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": [ + "x42" + ] + } + ] + }, + "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": [ + "x42" + ] + } + ] + }, + "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": [ + "x42" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x72", + "x73" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x74", + "x75" + ], + "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": [ + "x64" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x76", + "x77" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "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": "static_cast", + "arguments": [ + "x65" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x62" + ] + } + ] + } + ] + }, + { + "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": [ + "x63" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x60" + ] + } + ] + } + ] + }, + { + "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": [ + "x61" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x58" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x83" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x70" + ] + } + ] + } + ] + }, + { + "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": [ + "x44" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "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": [ + "x46" + ] + } + ] + }, + { + "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": [ + "x73" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x48" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x66" + ] + } + ] + } + ] + }, + { + "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": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "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": [ + "x52" + ] + } + ] + }, + { + "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": [ + "x54" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "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": [ + "x56" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x81" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x100", + "x101" + ], + "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": [ + "arg1[2]" + ] + } + ] + }, + { + "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": [ + "x86" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x88" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "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": [ + "x100" + ] + } + ] + }, + "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": [ + "x100" + ] + } + ] + }, + "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": [ + "x100" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x130", + "x131" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x132", + "x133" + ], + "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": [ + "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": [ + "x123" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + }, + { + "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": [ + "x121" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x118" + ] + } + ] + } + ] + }, + { + "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": [ + "x119" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x141" + ], + "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": [ + "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": [ + "x102" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + } + ] + }, + { + "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": [ + "x104" + ] + } + ] + }, + { + "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": [ + "x131" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x106" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x124" + ] + } + ] + } + ] + }, + { + "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": [ + "x108" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x132" + ] + } + ] + } + ] + }, + { + "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": [ + "x110" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "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": [ + "x112" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x136" + ] + } + ] + } + ] + }, + { + "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": [ + "x114" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x138" + ] + } + ] + } + ] + }, + { + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x117" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "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": [ + "x144" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x146" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x148" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x158" + ] + } + ] + }, + "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": [ + "x158" + ] + } + ] + }, + "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": [ + "x158" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x188", + "x189" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x190", + "x191" + ], + "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": [ + "x180" + ] + } + ] + } + ] + }, + { + "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": [ + "x181" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x178" + ] + } + ] + } + ] + }, + { + "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": [ + "x179" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x176" + ] + } + ] + } + ] + }, + { + "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": [ + "x177" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x199" + ], + "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": [ + "x186" + ] + } + ] + } + ] + }, + { + "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": [ + "x160" + ] + } + ] + }, + { + "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": [ + "x162" + ] + } + ] + }, + { + "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": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x164" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "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": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x190" + ] + } + ] + } + ] + }, + { + "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": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x192" + ] + } + ] + } + ] + }, + { + "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": [ + "x170" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + } + ] + }, + { + "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": [ + "x172" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x196" + ] + } + ] + } + ] + }, + { + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x175" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "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": [ + "arg1[4]" + ] + } + ] + }, + { + "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": [ + "x202" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x204" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x206" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x208" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x234", + "x235" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x236", + "x237" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x238", + "x239" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x240", + "x241" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x216" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x216" + ] + } + ] + }, + "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": [ + "x216" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x246", + "x247" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x245" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x242" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x238" + ] + } + ] + } + ] + }, + { + "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": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x234" + ] + } + ] + } + ] + }, + { + "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": [ + "x235" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x232" + ] + } + ] + } + ] + }, + { + "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": [ + "x216" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x244" + ] + } + ] + } + ] + }, + { + "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": [ + "x218" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x246" + ] + } + ] + } + ] + }, + { + "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": [ + "x220" + ] + } + ] + }, + { + "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": [ + "x247" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x243" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x222" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x240" + ] + } + ] + } + ] + }, + { + "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": [ + "x224" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + } + ] + }, + { + "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": [ + "x226" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + } + ] + }, + { + "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": [ + "x228" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x252" + ] + } + ] + } + ] + }, + { + "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": [ + "x230" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x254" + ] + } + ] + } + ] + }, + { + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x231" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x233" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x274", + "x275" + ], + "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": [ + "arg1[5]" + ] + } + ] + }, + { + "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": [ + "x260" + ] + } + ] + }, + "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": [ + "x262" + ] + } + ] + }, + "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": [ + "x264" + ] + } + ] + }, + "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": [ + "x266" + ] + } + ] + }, + "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": [ + "x268" + ] + } + ] + }, + "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": [ + "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": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x292", + "x293" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x294", + "x295" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x274" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x274" + ] + } + ] + }, + "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": [ + "x274" + ] + } + ] + }, + "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": [ + "x274" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x304", + "x305" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x306", + "x307" + ], + "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": [ + "x296" + ] + } + ] + } + ] + }, + { + "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": [ + "x297" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x294" + ] + } + ] + } + ] + }, + { + "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": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x292" + ] + } + ] + } + ] + }, + { + "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": [ + "x293" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x290" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x302" + ] + } + ] + } + ] + }, + { + "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": [ + "x276" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x304" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x305" + ] + } + ] + }, + { + "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": [ + "x280" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + }, + { + "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": [ + "x282" + ] + } + ] + }, + { + "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": [ + "x284" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x308" + ] + } + ] + } + ] + }, + { + "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": [ + "x286" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x310" + ] + } + ] + } + ] + }, + { + "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": [ + "x288" + ] + } + ] + }, + { + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x291" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x332", + "x333" + ], + "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": [ + "arg1[6]" + ] + } + ] + }, + { + "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": [ + "x318" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x320" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x322" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x324" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x326" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x328" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x332" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x360", + "x361" + ], + "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": [ + "x362", + "x363" + ], + "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": [ + "x358" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x364", + "x365" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x352" + ] + } + ] + } + ] + }, + { + "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": [ + "x353" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x350" + ] + } + ] + } + ] + }, + { + "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": [ + "x351" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x348" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x373" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x360" + ] + } + ] + } + ] + }, + { + "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": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x362" + ] + } + ] + } + ] + }, + { + "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": [ + "x336" + ] + } + ] + }, + { + "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": [ + "x359" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x338" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x356" + ] + } + ] + } + ] + }, + { + "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": [ + "x340" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + } + ] + }, + { + "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": [ + "x342" + ] + } + ] + }, + { + "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": [ + "x344" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x368" + ] + } + ] + } + ] + }, + { + "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": [ + "x346" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x370" + ] + } + ] + } + ] + }, + { + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x347" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x349" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x390", + "x391" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "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", + "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": [ + "x382" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x384" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "static_cast", + "arguments": [ + "x386" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x404", + "x405" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "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": [ + "x388" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + "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": [ + "x390" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "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": [ + "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": [ + "x413" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x410" + ] + } + ] + } + ] + }, + { + "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": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + } + ] + }, + { + "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": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + } + ] + }, + { + "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": [ + "x390" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + } + ] + }, + { + "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": [ + "x392" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x420" + ] + } + ] + } + ] + }, + { + "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": [ + "x394" + ] + } + ] + }, + { + "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": [ + "x421" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x417" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x396" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x414" + ] + } + ] + } + ] + }, + { + "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": [ + "x398" + ] + } + ] + }, + { + "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": [ + "x400" + ] + } + ] + }, + { + "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": [ + "x402" + ] + } + ] + }, + { + "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": [ + "x404" + ] + } + ] + }, + { + "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": [ + "x405" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x407" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x448", + "x449" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x450", + "x451" + ], + "operation": "subborrowx", + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x452", + "x453" + ], + "operation": "subborrowx", + "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": "subborrowx", + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x456", + "x457" + ], + "operation": "subborrowx", + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x458", + "x459" + ], + "operation": "subborrowx", + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x460", + "x461" + ], + "operation": "subborrowx", + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x462", + "x463" + ], + "operation": "subborrowx", + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x465" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "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" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x466" + ], + "operation": "cmovznz", + "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": [ + "x448" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x432" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x467" + ], + "operation": "cmovznz", + "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" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x434" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x468" + ], + "operation": "cmovznz", + "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": [ + "x452" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x436" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x469" + ], + "operation": "cmovznz", + "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": [ + "x454" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x438" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x470" + ], + "operation": "cmovznz", + "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": [ + "x456" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x440" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x471" + ], + "operation": "cmovznz", + "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": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x442" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x472" + ], + "operation": "cmovznz", + "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": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x444" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x473" + ], + "operation": "cmovznz", + "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": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x466" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x467" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x468" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x469" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x470" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x471" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x472" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x23", + "x24" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + }, + { + "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": [ + "x15" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x25", + "x26" + ], + "operation": "addcarryx", + "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": [ + "x16" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x13" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x14" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x12" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x9" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x35", + "x36" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x37", + "x38" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x39", + "x40" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x19" + ] + } + ] + }, + "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": [ + "x19" + ] + } + ] + }, + "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": [ + "x19" + ] + } + ] + }, + "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": [ + "x19" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x51", + "x52" + ], + "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": [ + "x41" + ] + } + ] + } + ] + }, + { + "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": [ + "x42" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x39" + ] + } + ] + } + ] + }, + { + "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": [ + "x40" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x37" + ] + } + ] + } + ] + }, + { + "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": [ + "x38" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x35" + ] + } + ] + } + ] + }, + { + "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": [ + "x19" + ] + } + ] + }, + { + "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": [ + "x21" + ] + } + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + { + "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": [ + "x50" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x25" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x43" + ] + } + ] + } + ] + }, + { + "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": [ + "x27" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x51" + ] + } + ] + } + ] + }, + { + "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": [ + "x29" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x53" + ] + } + ] + } + ] + }, + { + "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": [ + "x31" + ] + } + ] + }, + { + "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": [ + "x33" + ] + } + ] + }, + { + "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": "+", + "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": [ + "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": [ + "x58" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x36" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x79", + "x80" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x81", + "x82" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x83", + "x84" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x85", + "x86" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x87", + "x88" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x3" + ] + }, + { + "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": "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": [ + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x82" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x79" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x77" + ] + } + ] + } + ] + }, + { + "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": [ + "x61" + ] + } + ] + }, + { + "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": [ + "x63" + ] + } + ] + }, + { + "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": [ + "x65" + ] + } + ] + }, + { + "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": [ + "x67" + ] + } + ] + }, + { + "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": [ + "x69" + ] + } + ] + }, + { + "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": [ + "x71" + ] + } + ] + }, + { + "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": [ + "x73" + ] + } + ] + }, + { + "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": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x101" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x133", + "x134" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x129" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x137", + "x138" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "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": [ + "x126" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x123" + ] + } + ] + } + ] + }, + { + "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": [ + "x124" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "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": [ + "x122" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x119" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x144" + ], + "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": [ + "x131" + ] + } + ] + } + ] + }, + { + "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": [ + "x105" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x133" + ] + } + ] + } + ] + }, + { + "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": [ + "x107" + ] + } + ] + }, + { + "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": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x130" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x109" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x127" + ] + } + ] + } + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + { + "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": [ + "x113" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x137" + ] + } + ] + } + ] + }, + { + "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": [ + "x115" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x139" + ] + } + ] + } + ] + }, + { + "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": [ + "x117" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "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": "+", + "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": [ + "x118" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x78" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x142" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x167", + "x168" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x169", + "x170" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x171", + "x172" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x173", + "x174" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x169" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x167" + ] + } + ] + } + ] + }, + { + "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": [ + "x168" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x161" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x147" + ] + } + ] + }, + { + "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": [ + "x149" + ] + } + ] + }, + { + "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": [ + "x151" + ] + } + ] + }, + { + "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": [ + "x153" + ] + } + ] + }, + { + "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": [ + "x155" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x181" + ] + } + ] + } + ] + }, + { + "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": [ + "x157" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x183" + ] + } + ] + } + ] + }, + { + "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": [ + "x159" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x185" + ] + } + ] + } + ] + }, + { + "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": [ + "x187" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x187" + ] + } + ] + }, + "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": [ + "x187" + ] + } + ] + }, + "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": [ + "x187" + ] + } + ] + }, + "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": [ + "x187" + ] + } + ] + }, + "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": [ + "x187" + ] + } + ] + }, + "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": [ + "x187" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x217", + "x218" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x219", + "x220" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x210" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x207" + ] + } + ] + } + ] + }, + { + "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": [ + "x208" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + } + ] + }, + { + "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": [ + "x206" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x228" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x215" + ] + } + ] + } + ] + }, + { + "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": [ + "x189" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x217" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x218" + ] + } + ] + }, + { + "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": [ + "x193" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + } + ] + }, + { + "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": [ + "x195" + ] + } + ] + }, + { + "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": [ + "x197" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x221" + ] + } + ] + } + ] + }, + { + "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": [ + "x199" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x223" + ] + } + ] + } + ] + }, + { + "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": [ + "x201" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x160" + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x186" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x204" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x245", + "x246" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x247", + "x248" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x249", + "x250" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x251", + "x252" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x253", + "x254" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x255", + "x256" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x257", + "x258" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x259", + "x260" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x258" + ] + } + ] + }, + { + "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": [ + "x251" + ] + } + ] + } + ] + }, + { + "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": [ + "x252" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x249" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x250" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "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": "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": [ + "x245" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x271", + "x272" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x231" + ] + } + ] + }, + { + "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": [ + "x233" + ] + } + ] + }, + { + "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": [ + "x235" + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x237" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + } + ] + }, + { + "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": [ + "x239" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x265" + ] + } + ] + } + ] + }, + { + "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": [ + "x241" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + }, + { + "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": [ + "x243" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x269" + ] + } + ] + } + ] + }, + { + "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": [ + "x271" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x271" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x297", + "x298" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x299", + "x300" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x271" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "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": [ + "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": [ + "x294" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x291" + ] + } + ] + } + ] + }, + { + "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": [ + "x292" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x289" + ] + } + ] + } + ] + }, + { + "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": [ + "x290" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x287" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x312" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x299" + ] + } + ] + } + ] + }, + { + "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": [ + "x273" + ] + } + ] + }, + { + "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": [ + "x275" + ] + } + ] + }, + { + "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": [ + "x302" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x295" + ] + } + ] + } + ] + }, + { + "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": [ + "x279" + ] + } + ] + }, + { + "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": [ + "x281" + ] + } + ] + }, + { + "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": [ + "x283" + ] + } + ] + }, + { + "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": [ + "x285" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x309" + ] + } + ] + } + ] + }, + { + "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": "+", + "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": [ + "x286" + ] + } + ] + }, + { + "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": "+", + "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": "+", + "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": [ + "x288" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x329", + "x330" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x331", + "x332" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x333", + "x334" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x335", + "x336" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x337", + "x338" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x339", + "x340" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x341", + "x342" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x343", + "x344" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + }, + { + "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": [ + "x335" + ] + } + ] + } + ] + }, + { + "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": [ + "x336" + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x334" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x331" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x329" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x355", + "x356" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": "static_cast", + "arguments": [ + "x315" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x341" + ] + } + ] + } + ] + }, + { + "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": [ + "x317" + ] + } + ] + }, + { + "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": [ + "x319" + ] + } + ] + }, + { + "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": [ + "x321" + ] + } + ] + }, + { + "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": [ + "x323" + ] + } + ] + }, + { + "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": [ + "x325" + ] + } + ] + }, + { + "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": [ + "x327" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x353" + ] + } + ] + } + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x355" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x387", + "x388" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x378" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x375" + ] + } + ] + } + ] + }, + { + "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": [ + "x376" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x373" + ] + } + ] + } + ] + }, + { + "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": [ + "x374" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x371" + ] + } + ] + } + ] + }, + { + "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": [ + "x355" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x383" + ] + } + ] + } + ] + }, + { + "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": [ + "x357" + ] + } + ] + }, + { + "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": [ + "x359" + ] + } + ] + }, + { + "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": [ + "x386" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x382" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x379" + ] + } + ] + } + ] + }, + { + "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": [ + "x363" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x387" + ] + } + ] + } + ] + }, + { + "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": [ + "x365" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x389" + ] + } + ] + } + ] + }, + { + "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": [ + "x367" + ] + } + ] + }, + { + "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": [ + "x369" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x370" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x330" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x372" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x413", + "x414" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x415", + "x416" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x417", + "x418" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x419", + "x420" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x421", + "x422" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x423", + "x424" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x3" + ] + }, + { + "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": [ + "x424" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x421" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x419" + ] + } + ] + } + ] + }, + { + "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": [ + "x420" + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x418" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x415" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x413" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x439", + "x440" + ], + "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": [ + "x423" + ] + } + ] + } + ] + }, + { + "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": [ + "x399" + ] + } + ] + }, + { + "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": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x427" + ] + } + ] + } + ] + }, + { + "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": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x429" + ] + } + ] + } + ] + }, + { + "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": [ + "x405" + ] + } + ] + }, + { + "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": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x433" + ] + } + ] + } + ] + }, + { + "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": [ + "x409" + ] + } + ] + }, + { + "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": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x437" + ] + } + ] + } + ] + }, + { + "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": [ + "x439" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x439" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x439" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x461", + "x462" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x463", + "x464" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x465", + "x466" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x467", + "x468" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x439" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x469", + "x470" + ], + "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": [ + "x465" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x471", + "x472" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x461" + ] + } + ] + } + ] + }, + { + "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": [ + "x462" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x459" + ] + } + ] + } + ] + }, + { + "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": [ + "x460" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x457" + ] + } + ] + } + ] + }, + { + "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": [ + "x458" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x455" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x480" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x467" + ] + } + ] + } + ] + }, + { + "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": [ + "x441" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x469" + ] + } + ] + } + ] + }, + { + "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": [ + "x443" + ] + } + ] + }, + { + "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": [ + "x470" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x445" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x463" + ] + } + ] + } + ] + }, + { + "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": [ + "x447" + ] + } + ] + }, + { + "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": [ + "x449" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x473" + ] + } + ] + } + ] + }, + { + "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": [ + "x451" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x475" + ] + } + ] + } + ] + }, + { + "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": [ + "x453" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x477" + ] + } + ] + } + ] + }, + { + "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": "+", + "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": [ + "x454" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x414" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x478" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x456" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x497", + "x498" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x499", + "x500" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x501", + "x502" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x503", + "x504" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x505", + "x506" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x507", + "x508" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x509", + "x510" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x511", + "x512" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "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": [ + "x506" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x503" + ] + } + ] + } + ] + }, + { + "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": [ + "x504" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x501" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "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": "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": [ + "x497" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x523", + "x524" + ], + "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": [ + "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": [ + "x483" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x509" + ] + } + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x511" + ] + } + ] + } + ] + }, + { + "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": [ + "x513" + ] + } + ] + } + ] + }, + { + "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": [ + "x489" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x515" + ] + } + ] + } + ] + }, + { + "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": [ + "x491" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x517" + ] + } + ] + } + ] + }, + { + "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": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x519" + ] + } + ] + } + ] + }, + { + "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": [ + "x495" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x521" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x539", + "x540" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x541", + "x542" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x543", + "x544" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x545", + "x546" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x547", + "x548" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x549", + "x550" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x551", + "x552" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x523" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x553", + "x554" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x552" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x549" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x555", + "x556" + ], + "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": [ + "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": [ + "x546" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x543" + ] + } + ] + } + ] + }, + { + "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": [ + "x544" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x541" + ] + } + ] + } + ] + }, + { + "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": [ + "x542" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x539" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x564" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x551" + ] + } + ] + } + ] + }, + { + "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": [ + "x525" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x553" + ] + } + ] + } + ] + }, + { + "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": [ + "x527" + ] + } + ] + }, + { + "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": [ + "x554" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x550" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x529" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x547" + ] + } + ] + } + ] + }, + { + "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": [ + "x531" + ] + } + ] + }, + { + "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": [ + "x533" + ] + } + ] + }, + { + "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": [ + "x535" + ] + } + ] + }, + { + "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": [ + "x537" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x561" + ] + } + ] + } + ] + }, + { + "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": "+", + "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": [ + "x538" + ] + } + ] + }, + { + "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": "+", + "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": "+", + "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": [ + "x540" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x585", + "x586" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x587", + "x588" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x589", + "x590" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x2" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x591", + "x592" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x3" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x593", + "x594" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x595", + "x596" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "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": [ + "x590" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x587" + ] + } + ] + } + ] + }, + { + "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": [ + "x588" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x585" + ] + } + ] + } + ] + }, + { + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x586" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x583" + ] + } + ] + } + ] + }, + { + "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": "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": [ + "x581" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x607", + "x608" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x567" + ] + } + ] + }, + { + "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": [ + "x569" + ] + } + ] + }, + { + "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": [ + "x571" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x597" + ] + } + ] + } + ] + }, + { + "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": [ + "x599" + ] + } + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x601" + ] + } + ] + } + ] + }, + { + "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": [ + "x603" + ] + } + ] + } + ] + }, + { + "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": [ + "x579" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x605" + ] + } + ] + } + ] + }, + { + "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": [ + "x607" + ] + } + ] + }, + "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": [ + "x607" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x607" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x607" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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": [ + "x607" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x633", + "x634" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x635", + "x636" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x607" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x637", + "x638" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x639", + "x640" + ], + "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": [ + "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": [ + "x630" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x627" + ] + } + ] + } + ] + }, + { + "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": [ + "x628" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x625" + ] + } + ] + } + ] + }, + { + "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": [ + "x626" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x623" + ] + } + ] + } + ] + }, + { + "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": [ + "x607" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x635" + ] + } + ] + } + ] + }, + { + "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": [ + "x609" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x637" + ] + } + ] + } + ] + }, + { + "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": [ + "x611" + ] + } + ] + }, + { + "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": [ + "x638" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x634" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x613" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x631" + ] + } + ] + } + ] + }, + { + "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": [ + "x615" + ] + } + ] + }, + { + "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": [ + "x617" + ] + } + ] + }, + { + "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": [ + "x619" + ] + } + ] + }, + { + "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": [ + "x621" + ] + } + ] + }, + { + "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": [ + "x622" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x582" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x624" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x665", + "x666" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "subborrowx", + "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": [ + "x651" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "subborrowx", + "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": [ + "x653" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "subborrowx", + "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": [ + "x655" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "subborrowx", + "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": [ + "x657" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "subborrowx", + "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": [ + "x659" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "subborrowx", + "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": [ + "x661" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "subborrowx", + "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": [ + "x663" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x682" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x680" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x664" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x683" + ], + "operation": "cmovznz", + "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": [ + "x665" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x649" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x684" + ], + "operation": "cmovznz", + "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": [ + "x667" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x651" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x685" + ], + "operation": "cmovznz", + "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": [ + "x669" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x653" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x686" + ], + "operation": "cmovznz", + "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": [ + "x671" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x655" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x687" + ], + "operation": "cmovznz", + "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": [ + "x673" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x657" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x688" + ], + "operation": "cmovznz", + "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": [ + "x675" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x659" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x689" + ], + "operation": "cmovznz", + "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": [ + "x677" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x661" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x690" + ], + "operation": "cmovznz", + "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": [ + "x679" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x663" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x683" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x684" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x685" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x686" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x687" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x688" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x689" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x690" + ] + } + ] + }, + { + "operation": "fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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": [ + "0x1" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "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": [ + "0x1" + ] + } + ] + }, + { + "operation": "fiat_sm2_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": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x0" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x109" + ] + } + ] + }, + { + "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": [ + "x109" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "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": [ + "x99" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x0" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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": [ + "0x8ffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x50000002" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x9ffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xe8000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x8ffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xd0000001" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0x1ffffffd" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0x28000001" + ] + } + ] + } +] diff --git a/fiat-json/src/sm2_64.json b/fiat-json/src/sm2_64.json new file mode 100644 index 00000000000..038bfd17953 --- /dev/null +++ b/fiat-json/src/sm2_64.json @@ -0,0 +1,28639 @@ +[ + { + "operation": "fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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", + "x21" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x11" + ] + } + ] + }, + "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": [ + "x11" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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": [ + "x11" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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": "(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": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "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": [ + "x26" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x15" + ] + } + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "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[3]" + ] + } + ] + }, + { + "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[2]" + ] + } + ] + }, + { + "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[1]" + ] + } + ] + }, + { + "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[0]" + ] + } + ] + }, + { + "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": "u64", + "name": [ + "x59" + ], + "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": "(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": [ + "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": "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "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": [ + "x60" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x60" + ] + } + ] + }, + "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": [ + "x60" + ] + } + ] + }, + "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": [ + "x60" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x75" + ] + } + ] + }, + { + "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": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "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": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x86" + ], + "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": [ + "x76" + ] + } + ] + } + ] + }, + { + "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": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "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": [ + "x64" + ] + } + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + { + "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": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x95" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "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": [ + "x98", + "x99" + ], + "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": [ + "x100", + "x101" + ], + "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": [ + "x102", + "x103" + ], + "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": [ + "x104", + "x105" + ], + "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": [ + "x100" + ] + } + ] + } + ] + }, + { + "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": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "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": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x110" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "x97" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x102" + ] + } + ] + } + ] + }, + { + "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": [ + "x89" + ] + } + ] + }, + { + "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": [ + "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": [ + "x95" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "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": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + }, + { + "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": [ + "x126" + ] + } + ] + }, + { + "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": [ + "x124" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x135" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "x122" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x137" + ], + "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": [ + "x127" + ] + } + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "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": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "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": [ + "x117" + ] + } + ] + }, + { + "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": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x146" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "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": [ + "x149", + "x150" + ], + "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": [ + "x151", + "x152" + ], + "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": [ + "x153", + "x154" + ], + "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": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x151" + ] + } + ] + } + ] + }, + { + "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": [ + "x152" + ] + } + ] + }, + { + "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": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x161" + ], + "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": [ + "x148" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x153" + ] + } + ] + } + ] + }, + { + "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": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "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": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x146" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x176" + ] + } + ] + } + ] + }, + { + "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": [ + "x177" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "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": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x186" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "x173" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x178" + ] + } + ] + } + ] + }, + { + "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": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "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": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "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": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "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": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x197" + ], + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "subborrowx", + "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": [ + "x191" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x207" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x208" + ], + "operation": "cmovznz", + "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": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x209" + ], + "operation": "cmovznz", + "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": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x210" + ], + "operation": "cmovznz", + "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": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x211" + ], + "operation": "cmovznz", + "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": [ + "x204" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x208" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x209" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x210" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "operation": "fiat_sm2_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", + "x21" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x11" + ] + } + ] + }, + "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": [ + "x11" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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": [ + "x11" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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": "(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": [ + "x25" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x22" + ] + } + ] + } + ] + }, + { + "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": [ + "x23" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x34" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "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": [ + "x26" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x15" + ] + } + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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": [ + "x19" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x34" + ] + } + ] + }, + { + "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[3]" + ] + } + ] + }, + { + "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[2]" + ] + } + ] + }, + { + "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[1]" + ] + } + ] + }, + { + "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[0]" + ] + } + ] + }, + { + "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": "u64", + "name": [ + "x59" + ], + "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": "(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": [ + "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": "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x59" + ] + } + ] + }, + { + "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": [ + "x60" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x60" + ] + } + ] + }, + "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": [ + "x60" + ] + } + ] + }, + "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": [ + "x60" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x78", + "x79" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x75" + ] + } + ] + }, + { + "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": [ + "x73" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x70" + ] + } + ] + } + ] + }, + { + "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": [ + "x71" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x86" + ], + "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": [ + "x76" + ] + } + ] + } + ] + }, + { + "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": [ + "x62" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x78" + ] + } + ] + } + ] + }, + { + "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": [ + "x64" + ] + } + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + { + "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": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x84" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x95" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x69" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x96", + "x97" + ], + "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": [ + "x98", + "x99" + ], + "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": [ + "x100", + "x101" + ], + "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": [ + "x102", + "x103" + ], + "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": [ + "x104", + "x105" + ], + "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": [ + "x100" + ] + } + ] + } + ] + }, + { + "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": [ + "x101" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x108", + "x109" + ], + "operation": "addcarryx", + "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": [ + "x99" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x96" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x110" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "x97" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x102" + ] + } + ] + } + ] + }, + { + "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": [ + "x89" + ] + } + ] + }, + { + "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": [ + "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": [ + "x95" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x110" + ] + } + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x125", + "x126" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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": [ + "x111" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x129", + "x130" + ], + "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": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x125" + ] + } + ] + } + ] + }, + { + "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": [ + "x126" + ] + } + ] + }, + { + "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": [ + "x124" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x135" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "x122" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x137" + ], + "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": [ + "x127" + ] + } + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "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": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x131" + ] + } + ] + } + ] + }, + { + "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": [ + "x117" + ] + } + ] + }, + { + "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": [ + "x119" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x146" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x145" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x120" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "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": [ + "x149", + "x150" + ], + "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": [ + "x151", + "x152" + ], + "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": [ + "x153", + "x154" + ], + "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": [ + "x155", + "x156" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x151" + ] + } + ] + } + ] + }, + { + "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": [ + "x152" + ] + } + ] + }, + { + "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": [ + "x150" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x161" + ], + "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": [ + "x148" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x162", + "x163" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x153" + ] + } + ] + } + ] + }, + { + "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": [ + "x140" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x155" + ] + } + ] + } + ] + }, + { + "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": [ + "x142" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "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": [ + "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": [ + "x146" + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x172", + "x173" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x174", + "x175" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x176", + "x177" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x178", + "x179" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x162" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x180", + "x181" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x176" + ] + } + ] + } + ] + }, + { + "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": [ + "x177" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x174" + ] + } + ] + } + ] + }, + { + "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": [ + "x175" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x172" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x186" + ], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "+", + "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": [ + "x173" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x188" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x178" + ] + } + ] + } + ] + }, + { + "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": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + } + ] + }, + { + "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": [ + "x166" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + } + ] + }, + { + "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": [ + "x168" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x184" + ] + } + ] + } + ] + }, + { + "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": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x186" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x197" + ], + "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": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x171" + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x198", + "x199" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x200", + "x201" + ], + "operation": "subborrowx", + "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": [ + "x191" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x202", + "x203" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x204", + "x205" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x203" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x207" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x205" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x197" + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x208" + ], + "operation": "cmovznz", + "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": [ + "x198" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x189" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x209" + ], + "operation": "cmovznz", + "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": [ + "x200" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x191" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x210" + ], + "operation": "cmovznz", + "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": [ + "x202" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x193" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x211" + ], + "operation": "cmovznz", + "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": [ + "x204" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x195" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x208" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x209" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x210" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x211" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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": [ + "x9" + ] + } + ] + }, + { + "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" + ] + }, + "0xffffffff00000000" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + } + ] + } + ] + }, + { + "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_sm2_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": [ + "x9" + ] + } + ] + }, + { + "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" + ] + }, + "0xffffffff00000000" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + } + ] + } + ] + }, + { + "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_sm2_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", + "x3" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x4", + "x5" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x6", + "x7" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x8", + "x9" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "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": [ + "x9" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + } + ] + } + ] + }, + { + "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": [ + "x7" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + } + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x2" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x17" + ], + "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": [ + "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": "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": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x18" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[1]" + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x24" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x24" + ] + } + ] + }, + "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": [ + "x24" + ] + } + ] + }, + "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": [ + "x24" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x38", + "x39" + ], + "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": [ + "x34" + ] + } + ] + } + ] + }, + { + "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": [ + "x35" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x32" + ] + } + ] + } + ] + }, + { + "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": [ + "x33" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x30" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x45" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x26" + ] + } + ] + }, + { + "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": [ + "x28" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x23" + ] + } + ] + }, + { + "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": "static_cast", + "arguments": [ + "x3" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x46" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "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": [ + "x48" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x50" + ] + } + ] + }, + "0x0" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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": [ + "_", + "x73" + ], + "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": [ + "x64" + ] + } + ] + } + ] + }, + { + "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": [ + "x54" + ] + } + ] + }, + { + "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": [ + "x56" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x68" + ] + } + ] + } + ] + }, + { + "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": "+", + "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": [ + "x51" + ] + } + ] + }, + { + "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": [ + "x43" + ] + } + ] + }, + { + "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": [ + "x70" + ] + } + ] + } + ] + }, + { + "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": [ + "x74" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "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": [ + "x76" + ] + } + ] + }, + "0x0" + ] + }, + { + "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": [ + "x78" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x86", + "x87" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x88", + "x89" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x90", + "x91" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x92", + "x93" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x80" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x94", + "x95" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x91" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x88" + ] + } + ] + } + ] + }, + { + "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": [ + "x89" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x86" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x101" + ], + "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": [ + "x92" + ] + } + ] + } + ] + }, + { + "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": [ + "x82" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x94" + ] + } + ] + } + ] + }, + { + "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": [ + "x84" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x79" + ] + } + ] + }, + { + "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": [ + "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": [ + "x98" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x108" + ], + "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": "+", + "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": [ + "x87" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x109", + "x110" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x111", + "x112" + ], + "operation": "subborrowx", + "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": [ + "x104" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x113", + "x114" + ], + "operation": "subborrowx", + "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": [ + "x106" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x115", + "x116" + ], + "operation": "subborrowx", + "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": [ + "x108" + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x118" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "0x0", + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x119" + ], + "operation": "cmovznz", + "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": [ + "x109" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x102" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x120" + ], + "operation": "cmovznz", + "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": [ + "x111" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x104" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x121" + ], + "operation": "cmovznz", + "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": [ + "x113" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x106" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x122" + ], + "operation": "cmovznz", + "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": [ + "x115" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x108" + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x119" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x120" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x121" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x122" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + }, + "0x400000002" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x100000001" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x2ffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x200000003" + ] + }, + { + "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", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x11" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x11" + ] + } + ] + }, + "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": [ + "x11" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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": [ + "x11" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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": [ + "x29", + "x30" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "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": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x21" + ] + } + ] + } + ] + }, + { + "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": [ + "x22" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x19" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x34" + ], + "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": [ + "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": [ + "x13" + ] + } + ] + }, + { + "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": [ + "x15" + ] + } + ] + }, + { + "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": [ + "x17" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x32" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x20" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x43", + "x44" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x400000002" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x45", + "x46" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x100000001" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x2ffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x200000003" + ] + }, + { + "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": [ + "x50" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x47" + ] + } + ] + } + ] + }, + { + "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": [ + "x48" + ] + } + ] + }, + { + "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": [ + "x46" + ] + } + ] + }, + { + "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": [ + "0x0", + { + "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": [ + "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": [ + "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": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x67", + "x68" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x57" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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": [ + "x57" + ] + } + ] + }, + "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": [ + "x57" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x73", + "x74" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x70" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x67" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x77", + "x78" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "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": "static_cast", + "arguments": [ + "x68" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x65" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x80" + ], + "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": [ + "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": [ + "x59" + ] + } + ] + }, + { + "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": [ + "x61" + ] + } + ] + }, + { + "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": [ + "x63" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x64" + ] + } + ] + }, + { + "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": [ + "x56" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x66" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x89", + "x90" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x400000002" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x100000001" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x2ffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x200000003" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "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": [ + "x93" + ] + } + ] + } + ] + }, + { + "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": [ + "x94" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x91" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x100" + ] + } + ] + }, + { + "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": [ + "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": [ + "x81" + ] + } + ] + }, + { + "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": [ + "x83" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x97" + ] + } + ] + } + ] + }, + { + "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": [ + "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": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x103" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x119", + "x120" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "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": [ + "x115" + ] + } + ] + } + ] + }, + { + "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": [ + "x116" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x113" + ] + } + ] + } + ] + }, + { + "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": [ + "x114" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x111" + ] + } + ] + } + ] + }, + { + "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": [ + "x103" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x117" + ] + } + ] + } + ] + }, + { + "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": [ + "x105" + ] + } + ] + }, + { + "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": [ + "x107" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x121" + ] + } + ] + } + ] + }, + { + "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": [ + "x109" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x110" + ] + } + ] + }, + { + "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": "+", + "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": [ + "x90" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x112" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x135", + "x136" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x400000002" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x137", + "x138" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x100000001" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x139", + "x140" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x2ffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x141", + "x142" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x200000003" + ] + }, + { + "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": "(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": [ + "x127" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x141" + ] + } + ] + } + ] + }, + { + "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": [ + "x129" + ] + } + ] + }, + { + "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": [ + "x131" + ] + } + ] + }, + { + "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": [ + "x133" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x147" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x157", + "x158" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x159", + "x160" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x161", + "x162" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x163", + "x164" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x149" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x165", + "x166" + ], + "operation": "addcarryx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x164" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x161" + ] + } + ] + } + ] + }, + { + "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": [ + "x162" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x159" + ] + } + ] + } + ] + }, + { + "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": [ + "x160" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x157" + ] + } + ] + } + ] + }, + { + "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": [ + "x149" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x163" + ] + } + ] + } + ] + }, + { + "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": [ + "x151" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x165" + ] + } + ] + } + ] + }, + { + "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": [ + "x153" + ] + } + ] + }, + { + "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": [ + "x155" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x169" + ] + } + ] + } + ] + }, + { + "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": "+", + "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": "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": "+", + "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": "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": [ + "x170" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x158" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x181", + "x182" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + "0x0", + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x183", + "x184" + ], + "operation": "subborrowx", + "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": [ + "x175" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x185", + "x186" + ], + "operation": "subborrowx", + "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": [ + "x177" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "subborrowx", + "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": "static_cast", + "arguments": [ + "x179" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x190" + ], + "operation": "subborrowx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x188" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x180" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u64", + "name": [ + "x191" + ], + "operation": "cmovznz", + "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": [ + "x181" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x173" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x192" + ], + "operation": "cmovznz", + "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" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x175" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x193" + ], + "operation": "cmovznz", + "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": [ + "x185" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x177" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "x194" + ], + "operation": "cmovznz", + "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": [ + "x187" + ] + } + ] + }, + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x179" + ] + } + ] + } + ] + }, + { + "datatype": "u64", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x191" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x192" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x193" + ] + }, + { + "datatype": "u64", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x194" + ] + } + ] + }, + { + "operation": "fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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": [ + "0x1" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x100000000" + ] + } + ] + }, + { + "operation": "fiat_sm2_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": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xffffffff00000000" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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": [ + "x61" + ] + } + ] + }, + { + "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" + ] + }, + "0xffffffff00000000" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffffffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff00000000" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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": [ + "0x500000028ffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xe80000009ffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xd00000018ffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x280000011ffffffd" + ] + } + ] + } +] diff --git a/fiat-json/src/sm2_scalar_32.json b/fiat-json/src/sm2_scalar_32.json new file mode 100644 index 00000000000..7646c0bfc90 --- /dev/null +++ b/fiat-json/src/sm2_scalar_32.json @@ -0,0 +1,86944 @@ +[ + { + "operation": "fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "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": [ + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "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": [ + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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" + ] + }, + "0x39d54123" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x53bbf409" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x21c6052b" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x7203df6b" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "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_sm2_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" + ] + }, + "0x39d54123" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x53bbf409" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x21c6052b" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x7203df6b" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x17" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "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_sm2_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" + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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": [ + "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": [ + "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": "static_cast", + "arguments": [ + "x44" + ] + } + ] + }, + "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": [ + "x46" + ] + } + ] + }, + "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": [ + "x48" + ] + } + ] + }, + "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": "+", + "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": "+", + "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" + ] + } + ] + } + ] + } + ] + } + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x66", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x50" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + "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": [ + "x66" + ] + } + ] + }, + "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": [ + "x66" + ] + } + ] + }, + "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": [ + "x66" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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": [ + "x66" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x84", + "x85" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x81" + ] + } + ] + }, + { + "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": [ + "x79" + ] + } + ] + }, + { + "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": [ + "x77" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x74" + ] + } + ] + } + ] + }, + { + "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": [ + "x75" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x72" + ] + } + ] + } + ] + }, + { + "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": [ + "x73" + ] + } + ] + }, + { + "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": [ + { + "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": [ + "x68" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x99" + ], + "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": [ + "x82" + ] + } + ] + } + ] + }, + { + "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": [ + "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": "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": "+", + "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": [ + "x69" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x100" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[2]" + ] + } + ] + }, + { + "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", + "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", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x116" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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": [ + "x132" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x132" + ] + } + ] + }, + "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": [ + "x132" + ] + } + ] + }, + "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": [ + "x132" + ] + } + ] + }, + "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": [ + "x132" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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": [ + "x132" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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": [ + "x132" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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": [ + "x132" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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": "(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": [ + "x139" + ] + } + ] + }, + { + "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": [ + "x137" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x134" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x165" + ], + "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": [ + "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": [ + "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": "+", + "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": [ + "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": [ + "x163" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x135" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "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": [ + "x166" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[3]" + ] + } + ] + }, + { + "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": [ + "x168" + ] + } + ] + }, + "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": [ + "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", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x182" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x216", + "x217" + ], + "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": [ + "x212" + ] + } + ] + } + ] + }, + { + "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": [ + "x213" + ] + } + ] + }, + { + "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": [ + "x211" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x208" + ] + } + ] + } + ] + }, + { + "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": [ + "x209" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x206" + ] + } + ] + } + ] + }, + { + "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": [ + "x207" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x204" + ] + } + ] + } + ] + }, + { + "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": [ + "x205" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x202" + ] + } + ] + } + ] + }, + { + "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": [ + "x203" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x200" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x231" + ], + "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": [ + "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": [ + "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": "+", + "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": [ + "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": [ + "x229" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x201" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x248", + "x249" + ], + "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": [ + "arg1[4]" + ] + } + ] + }, + { + "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": [ + "x234" + ] + } + ] + }, + "0x0" + ] + }, + { + "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", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x248" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x266", + "x267" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x264" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x264" + ] + } + ] + }, + "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": [ + "x264" + ] + } + ] + }, + "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": [ + "x264" + ] + } + ] + }, + "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": [ + "x264" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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": [ + "x264" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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": [ + "x264" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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": [ + "x264" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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": [ + "x281" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x278" + ] + } + ] + } + ] + }, + { + "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": [ + "x279" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x276" + ] + } + ] + } + ] + }, + { + "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": [ + "x277" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x274" + ] + } + ] + } + ] + }, + { + "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": [ + "x275" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x272" + ] + } + ] + } + ] + }, + { + "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": [ + "x273" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x270" + ] + } + ] + } + ] + }, + { + "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": [ + "x271" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x268" + ] + } + ] + } + ] + }, + { + "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": [ + "x269" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x266" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x297" + ], + "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": [ + "x280" + ] + } + ] + } + ] + }, + { + "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": [ + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x263" + ] + } + ] + }, + { + "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": [ + "x295" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x267" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x314", + "x315" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x298" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[5]" + ] + } + ] + }, + { + "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": [ + "x300" + ] + } + ] + }, + "0x0" + ] + }, + { + "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", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x314" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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": [ + "x330" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x330" + ] + } + ] + }, + "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": [ + "x330" + ] + } + ] + }, + "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": [ + "x330" + ] + } + ] + }, + "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": [ + "x330" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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": [ + "x330" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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": [ + "x330" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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": [ + "x330" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x348", + "x349" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x345" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x342" + ] + } + ] + } + ] + }, + { + "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": [ + "x343" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x340" + ] + } + ] + } + ] + }, + { + "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": [ + "x341" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x338" + ] + } + ] + } + ] + }, + { + "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": [ + "x339" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x336" + ] + } + ] + } + ] + }, + { + "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": [ + "x337" + ] + } + ] + }, + { + "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": [ + "x335" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x332" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x363" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x329" + ] + } + ] + }, + { + "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": [ + "x361" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x333" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x380", + "x381" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x364" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[6]" + ] + } + ] + }, + { + "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": [ + "x366" + ] + } + ] + }, + "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": [ + "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", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x380" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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": [ + "x396" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x396" + ] + } + ] + }, + "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": [ + "x396" + ] + } + ] + }, + "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": [ + "x396" + ] + } + ] + }, + "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": [ + "x396" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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": [ + "x396" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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": [ + "x396" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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": [ + "x396" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x414", + "x415" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "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": [ + "x411" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x408" + ] + } + ] + } + ] + }, + { + "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": [ + "x409" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x406" + ] + } + ] + } + ] + }, + { + "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": [ + "x407" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x404" + ] + } + ] + } + ] + }, + { + "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": [ + "x405" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x402" + ] + } + ] + } + ] + }, + { + "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": [ + "x403" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x400" + ] + } + ] + } + ] + }, + { + "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": [ + "x401" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x398" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x429" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x412" + ] + } + ] + } + ] + }, + { + "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": [ + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x395" + ] + } + ] + }, + { + "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": [ + "x427" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x399" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x446", + "x447" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x430" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "arg1[7]" + ] + } + ] + }, + { + "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": [ + "x432" + ] + } + ] + }, + "0x0" + ] + }, + { + "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", + "_" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x446" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x464", + "x465" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x462" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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": [ + "x462" + ] + } + ] + }, + "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": [ + "x462" + ] + } + ] + }, + "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": [ + "x462" + ] + } + ] + }, + "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": [ + "x462" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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": [ + "x462" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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": [ + "x462" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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": [ + "x462" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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": [ + "x479" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x476" + ] + } + ] + } + ] + }, + { + "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": [ + "x477" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x474" + ] + } + ] + } + ] + }, + { + "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": [ + "x475" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x472" + ] + } + ] + } + ] + }, + { + "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": [ + "x473" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x470" + ] + } + ] + } + ] + }, + { + "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": [ + "x471" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x468" + ] + } + ] + } + ] + }, + { + "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": [ + "x469" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x466" + ] + } + ] + } + ] + }, + { + "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": [ + "x467" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x464" + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x495" + ], + "operation": "addcarryx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "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": [ + "x478" + ] + } + ] + } + ] + }, + { + "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": [ + "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": "+", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x461" + ] + } + ] + }, + { + "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": [ + "x493" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x465" + ] + } + ] + } + ] + } + ] + } + ] + }, + { + "datatype": "(auto)", + "name": [ + "x512", + "x513" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + "0x0", + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x514", + "x515" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x513" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "_", + "x529" + ], + "operation": "subborrowx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x527" + ] + } + ] + }, + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u1", + "name": [], + "operation": "static_cast", + "arguments": [ + "x511" + ] + } + ] + }, + "0x0" + ] + }, + { + "datatype": "u32", + "name": [ + "x530" + ], + "operation": "cmovznz", + "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": [ + "x512" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x496" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x531" + ], + "operation": "cmovznz", + "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": [ + "x514" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x498" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x532" + ], + "operation": "cmovznz", + "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": [ + "x516" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x500" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x533" + ], + "operation": "cmovznz", + "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": [ + "x518" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x502" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x534" + ], + "operation": "cmovznz", + "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": [ + "x520" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x504" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x535" + ], + "operation": "cmovznz", + "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": [ + "x522" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x506" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x536" + ], + "operation": "cmovznz", + "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": [ + "x524" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x508" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "x537" + ], + "operation": "cmovznz", + "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": [ + "x526" + ] + } + ] + }, + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x510" + ] + } + ] + } + ] + }, + { + "datatype": "u32", + "name": [ + "out1[0]" + ], + "operation": "static_cast", + "arguments": [ + "x530" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[1]" + ], + "operation": "static_cast", + "arguments": [ + "x531" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[2]" + ], + "operation": "static_cast", + "arguments": [ + "x532" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[3]" + ], + "operation": "static_cast", + "arguments": [ + "x533" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[4]" + ], + "operation": "static_cast", + "arguments": [ + "x534" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[5]" + ], + "operation": "static_cast", + "arguments": [ + "x535" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[6]" + ], + "operation": "static_cast", + "arguments": [ + "x536" + ] + }, + { + "datatype": "u32", + "name": [ + "out1[7]" + ], + "operation": "static_cast", + "arguments": [ + "x537" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x13", + "x14" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x15", + "x16" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x17", + "x18" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x19", + "x20" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x21", + "x22" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x23", + "x24" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x8" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x91", + "x92" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x93", + "x94" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x101", + "x102" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x103", + "x104" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x187", + "x188" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x189", + "x190" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x191", + "x192" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x193", + "x194" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x195", + "x196" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x197", + "x198" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x199", + "x200" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x283", + "x284" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x285", + "x286" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x287", + "x288" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x289", + "x290" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x291", + "x292" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x293", + "x294" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x295", + "x296" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x379", + "x380" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x381", + "x382" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x383", + "x384" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x385", + "x386" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x387", + "x388" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x389", + "x390" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x391", + "x392" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x475", + "x476" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x477", + "x478" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x479", + "x480" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x481", + "x482" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x483", + "x484" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x485", + "x486" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x487", + "x488" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x5" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x571", + "x572" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x573", + "x574" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x575", + "x576" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x577", + "x578" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x579", + "x580" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x581", + "x582" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x583", + "x584" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x6" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x667", + "x668" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xa22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x669", + "x670" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x620fc84c" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x671", + "x672" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x673", + "x674" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x3464504a" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x675", + "x676" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0xde6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x677", + "x678" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x901192af" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x679", + "x680" + ], + "operation": "mulx", + "parameters": { + "size": 32 + }, + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x7" + ] + }, + "0x7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x72350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "0xffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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": [ + "0xc62abedd" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xac440bf6" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xde39fad4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x8dfc2094" + ] + }, + { + "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": [ + "0x1" + ] + } + ] + }, + { + "operation": "fiat_sm2_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": [ + "0x39d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x53bbf409" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x21c6052b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x7203df6b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xfffffffe" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[8]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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" + ] + }, + "0x39d54123" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x53bbf409" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x21c6052b" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x7203df6b" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + { + "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": [ + { + "datatype": "u32", + "name": [], + "operation": "&", + "arguments": [ + { + "datatype": "u32", + "name": [], + "operation": "static_cast", + "arguments": [ + "x109" + ] + }, + "0xfffffffe" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x39d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf409" + ] + }, + { + "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" + ] + } + ] + }, + "0x21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b" + ] + }, + { + "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" + ] + } + ] + }, + "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" + ] + } + ] + }, + "0xfffffffe" + ] + }, + { + "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_sm2_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": [ + "0xb351756d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x1aa32707" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x1e2a62fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xabdd67" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0xd4009a81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[5]" + ], + "operation": "=", + "arguments": [ + "0x49280d7d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[6]" + ], + "operation": "=", + "arguments": [ + "0xe6bb86e8" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[7]" + ], + "operation": "=", + "arguments": [ + "0xd730336e" + ] + } + ] + } +] diff --git a/fiat-json/src/sm2_scalar_64.json b/fiat-json/src/sm2_scalar_64.json new file mode 100644 index 00000000000..bedde14b03b --- /dev/null +++ b/fiat-json/src/sm2_scalar_64.json @@ -0,0 +1,29169 @@ +[ + { + "operation": "fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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" + ] + }, + "0x53bbf40939d54123" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x7203df6b21c6052b" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + } + ] + } + ] + }, + { + "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_sm2_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" + ] + }, + "0x53bbf40939d54123" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x7203df6b21c6052b" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + } + ] + } + ] + }, + { + "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_sm2_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" + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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" + ] + }, + "0x1eb5e412a22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x7", + "x8" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x620fc84c3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x9", + "x10" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x3464504ade6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x11", + "x12" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x4" + ] + }, + "0x901192af7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412a22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x47", + "x48" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x620fc84c3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x49", + "x50" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x3464504ade6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x51", + "x52" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x1" + ] + }, + "0x901192af7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412a22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x95", + "x96" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x620fc84c3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x97", + "x98" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x3464504ade6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x99", + "x100" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x2" + ] + }, + "0x901192af7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + }, + "0x1eb5e412a22b3d3b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x143", + "x144" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x620fc84c3affe0d4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x145", + "x146" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x3464504ade6fa2fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "x147", + "x148" + ], + "operation": "mulx", + "parameters": { + "size": 64 + }, + "arguments": [ + { + "datatype": "u64", + "name": [], + "operation": "static_cast", + "arguments": [ + "x3" + ] + }, + "0x901192af7c114f20" + ] + }, + { + "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" + ] + } + ] + }, + "0x327f9e8872350975" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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": [ + "0xac440bf6c62abedd" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x8dfc2094de39fad4" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0x100000000" + ] + } + ] + }, + { + "operation": "fiat_sm2_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": [ + "0x53bbf40939d54123" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0x7203df6b21c6052b" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0xffffffffffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xfffffffeffffffff" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[4]" + ], + "operation": "=", + "arguments": [ + "0x0" + ] + } + ] + }, + { + "operation": "fiat_sm2_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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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" + ] + }, + "0x53bbf40939d54123" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0x7203df6b21c6052b" + ] + } + ] + } + ] + }, + { + "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" + ] + }, + "0xfffffffeffffffff" + ] + } + ] + } + ] + }, + { + "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" + ] + } + ] + }, + "0x53bbf40939d54123" + ] + }, + { + "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" + ] + } + ] + }, + "0x7203df6b21c6052b" + ] + }, + { + "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" + ] + } + ] + }, + "0xfffffffeffffffff" + ] + }, + { + "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_sm2_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": [ + "0x1aa32707b351756d" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[1]" + ], + "operation": "=", + "arguments": [ + "0xabdd671e2a62fa" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[2]" + ], + "operation": "=", + "arguments": [ + "0x49280d7dd4009a81" + ] + }, + { + "datatype": "(auto)", + "name": [ + "out1[3]" + ], + "operation": "=", + "arguments": [ + "0xd730336ee6bb86e8" + ] + } + ] + } +] diff --git a/fiat-rust/src/lib.rs b/fiat-rust/src/lib.rs index d6428f06561..62848526a67 100644 --- a/fiat-rust/src/lib.rs +++ b/fiat-rust/src/lib.rs @@ -28,3 +28,7 @@ pub mod secp256k1_montgomery_32; pub mod secp256k1_montgomery_64; pub mod secp256k1_montgomery_scalar_32; pub mod secp256k1_montgomery_scalar_64; +pub mod sm2_32; +pub mod sm2_64; +pub mod sm2_scalar_32; +pub mod sm2_scalar_64; diff --git a/fiat-rust/src/sm2_32.rs b/fiat-rust/src/sm2_32.rs new file mode 100644 index 00000000000..31713e6a10f --- /dev/null +++ b/fiat-rust/src/sm2_32.rs @@ -0,0 +1,5218 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline sm2 32 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: sm2 +//! 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") +//! +//! 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)] + +/** fiat_sm2_u1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_u1 = u8; +/** fiat_sm2_i1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_i1 = i8; +/** fiat_sm2_u2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_u2 = u8; +/** fiat_sm2_i2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_i2 = i8; + +/** The type fiat_sm2_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]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_montgomery_domain_field_element(pub [u32; 8]); + +impl core::ops::Index for fiat_sm2_montgomery_domain_field_element { + type Output = u32; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + +/** The type fiat_sm2_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]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_non_montgomery_domain_field_element(pub [u32; 8]); + +impl core::ops::Index for fiat_sm2_non_montgomery_domain_field_element { + type Output = u32; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_non_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + + +/// The function fiat_sm2_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_sm2_addcarryx_u32(out1: &mut u32, out2: &mut fiat_sm2_u1, arg1: fiat_sm2_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_sm2_u1 = ((x1 >> 32) as fiat_sm2_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_sm2_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_sm2_subborrowx_u32(out1: &mut u32, out2: &mut fiat_sm2_u1, arg1: fiat_sm2_u1, arg2: u32, arg3: u32) { + let x1: i64 = (((arg2 as i64) - (arg1 as i64)) - (arg3 as i64)); + let x2: fiat_sm2_i1 = ((x1 >> 32) as fiat_sm2_i1); + let x3: u32 = ((x1 & (0xffffffff as i64)) as u32); + *out1 = x3; + *out2 = (((0x0 as fiat_sm2_i2) - (x2 as fiat_sm2_i2)) as fiat_sm2_u1); +} + +/// The function fiat_sm2_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_sm2_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_sm2_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_sm2_cmovznz_u32(out1: &mut u32, arg1: fiat_sm2_u1, arg2: u32, arg3: u32) { + let x1: fiat_sm2_u1 = (!(!arg1)); + let x2: u32 = ((((((0x0 as fiat_sm2_i2) - (x1 as fiat_sm2_i2)) as fiat_sm2_i1) as i64) & (0xffffffff as i64)) as u32); + let x3: u32 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_sm2_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_sm2_mul(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element, arg2: &fiat_sm2_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_sm2_mulx_u32(&mut x9, &mut x10, x8, (arg2[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_sm2_mulx_u32(&mut x11, &mut x12, x8, (arg2[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_sm2_mulx_u32(&mut x13, &mut x14, x8, (arg2[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_sm2_mulx_u32(&mut x15, &mut x16, x8, (arg2[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_sm2_mulx_u32(&mut x17, &mut x18, x8, (arg2[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_sm2_mulx_u32(&mut x19, &mut x20, x8, (arg2[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_sm2_mulx_u32(&mut x21, &mut x22, x8, (arg2[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_sm2_mulx_u32(&mut x23, &mut x24, x8, (arg2[0])); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_mulx_u32(&mut x40, &mut x41, x23, 0xfffffffe); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_sm2_mulx_u32(&mut x42, &mut x43, x23, 0xffffffff); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_sm2_mulx_u32(&mut x44, &mut x45, x23, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_sm2_mulx_u32(&mut x46, &mut x47, x23, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_sm2_mulx_u32(&mut x48, &mut x49, x23, 0xffffffff); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_sm2_mulx_u32(&mut x50, &mut x51, x23, 0xffffffff); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_sm2_mulx_u32(&mut x52, &mut x53, x23, 0xffffffff); + let mut x54: u32 = 0; + let mut x55: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x54, &mut x55, 0x0, x53, x50); + let x56: u32 = ((x55 as u32) + x51); + let mut x57: u32 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x57, &mut x58, 0x0, x49, x46); + let mut x59: u32 = 0; + let mut x60: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x59, &mut x60, x58, x47, x44); + let mut x61: u32 = 0; + let mut x62: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x61, &mut x62, x60, x45, x42); + let mut x63: u32 = 0; + let mut x64: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x63, &mut x64, x62, x43, x40); + let x65: u32 = ((x64 as u32) + x41); + let mut x66: u32 = 0; + let mut x67: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x66, &mut x67, 0x0, x23, x52); + let mut x68: u32 = 0; + let mut x69: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x68, &mut x69, x67, x25, x54); + let mut x70: u32 = 0; + let mut x71: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x70, &mut x71, x69, x27, x56); + let mut x72: u32 = 0; + let mut x73: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x72, &mut x73, x71, x29, x48); + let mut x74: u32 = 0; + let mut x75: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x74, &mut x75, x73, x31, x57); + let mut x76: u32 = 0; + let mut x77: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x76, &mut x77, x75, x33, x59); + let mut x78: u32 = 0; + let mut x79: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x78, &mut x79, x77, x35, x61); + let mut x80: u32 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x80, &mut x81, x79, x37, x63); + let mut x82: u32 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x82, &mut x83, x81, x39, x65); + let mut x84: u32 = 0; + let mut x85: u32 = 0; + fiat_sm2_mulx_u32(&mut x84, &mut x85, x1, (arg2[7])); + let mut x86: u32 = 0; + let mut x87: u32 = 0; + fiat_sm2_mulx_u32(&mut x86, &mut x87, x1, (arg2[6])); + let mut x88: u32 = 0; + let mut x89: u32 = 0; + fiat_sm2_mulx_u32(&mut x88, &mut x89, x1, (arg2[5])); + let mut x90: u32 = 0; + let mut x91: u32 = 0; + fiat_sm2_mulx_u32(&mut x90, &mut x91, x1, (arg2[4])); + let mut x92: u32 = 0; + let mut x93: u32 = 0; + fiat_sm2_mulx_u32(&mut x92, &mut x93, x1, (arg2[3])); + let mut x94: u32 = 0; + let mut x95: u32 = 0; + fiat_sm2_mulx_u32(&mut x94, &mut x95, x1, (arg2[2])); + let mut x96: u32 = 0; + let mut x97: u32 = 0; + fiat_sm2_mulx_u32(&mut x96, &mut x97, x1, (arg2[1])); + let mut x98: u32 = 0; + let mut x99: u32 = 0; + fiat_sm2_mulx_u32(&mut x98, &mut x99, x1, (arg2[0])); + let mut x100: u32 = 0; + let mut x101: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x100, &mut x101, 0x0, x99, x96); + let mut x102: u32 = 0; + let mut x103: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x102, &mut x103, x101, x97, x94); + let mut x104: u32 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x104, &mut x105, x103, x95, x92); + let mut x106: u32 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x106, &mut x107, x105, x93, x90); + let mut x108: u32 = 0; + let mut x109: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x108, &mut x109, x107, x91, x88); + let mut x110: u32 = 0; + let mut x111: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x110, &mut x111, x109, x89, x86); + let mut x112: u32 = 0; + let mut x113: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x112, &mut x113, x111, x87, x84); + let x114: u32 = ((x113 as u32) + x85); + let mut x115: u32 = 0; + let mut x116: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x115, &mut x116, 0x0, x68, x98); + let mut x117: u32 = 0; + let mut x118: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x117, &mut x118, x116, x70, x100); + let mut x119: u32 = 0; + let mut x120: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x119, &mut x120, x118, x72, x102); + let mut x121: u32 = 0; + let mut x122: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x121, &mut x122, x120, x74, x104); + let mut x123: u32 = 0; + let mut x124: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x123, &mut x124, x122, x76, x106); + let mut x125: u32 = 0; + let mut x126: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x125, &mut x126, x124, x78, x108); + let mut x127: u32 = 0; + let mut x128: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x127, &mut x128, x126, x80, x110); + let mut x129: u32 = 0; + let mut x130: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x129, &mut x130, x128, x82, x112); + let mut x131: u32 = 0; + let mut x132: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x131, &mut x132, x130, (x83 as u32), x114); + let mut x133: u32 = 0; + let mut x134: u32 = 0; + fiat_sm2_mulx_u32(&mut x133, &mut x134, x115, 0xfffffffe); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_sm2_mulx_u32(&mut x135, &mut x136, x115, 0xffffffff); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_sm2_mulx_u32(&mut x137, &mut x138, x115, 0xffffffff); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_sm2_mulx_u32(&mut x139, &mut x140, x115, 0xffffffff); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_sm2_mulx_u32(&mut x141, &mut x142, x115, 0xffffffff); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_sm2_mulx_u32(&mut x143, &mut x144, x115, 0xffffffff); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_sm2_mulx_u32(&mut x145, &mut x146, x115, 0xffffffff); + let mut x147: u32 = 0; + let mut x148: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x147, &mut x148, 0x0, x146, x143); + let x149: u32 = ((x148 as u32) + x144); + let mut x150: u32 = 0; + let mut x151: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x150, &mut x151, 0x0, x142, x139); + let mut x152: u32 = 0; + let mut x153: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x152, &mut x153, x151, x140, x137); + let mut x154: u32 = 0; + let mut x155: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x154, &mut x155, x153, x138, x135); + let mut x156: u32 = 0; + let mut x157: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x156, &mut x157, x155, x136, x133); + let x158: u32 = ((x157 as u32) + x134); + let mut x159: u32 = 0; + let mut x160: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x159, &mut x160, 0x0, x115, x145); + let mut x161: u32 = 0; + let mut x162: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x161, &mut x162, x160, x117, x147); + let mut x163: u32 = 0; + let mut x164: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x163, &mut x164, x162, x119, x149); + let mut x165: u32 = 0; + let mut x166: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x165, &mut x166, x164, x121, x141); + let mut x167: u32 = 0; + let mut x168: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x167, &mut x168, x166, x123, x150); + let mut x169: u32 = 0; + let mut x170: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x169, &mut x170, x168, x125, x152); + let mut x171: u32 = 0; + let mut x172: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x171, &mut x172, x170, x127, x154); + let mut x173: u32 = 0; + let mut x174: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x173, &mut x174, x172, x129, x156); + let mut x175: u32 = 0; + let mut x176: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x175, &mut x176, x174, x131, x158); + let x177: u32 = ((x176 as u32) + (x132 as u32)); + let mut x178: u32 = 0; + let mut x179: u32 = 0; + fiat_sm2_mulx_u32(&mut x178, &mut x179, x2, (arg2[7])); + let mut x180: u32 = 0; + let mut x181: u32 = 0; + fiat_sm2_mulx_u32(&mut x180, &mut x181, x2, (arg2[6])); + let mut x182: u32 = 0; + let mut x183: u32 = 0; + fiat_sm2_mulx_u32(&mut x182, &mut x183, x2, (arg2[5])); + let mut x184: u32 = 0; + let mut x185: u32 = 0; + fiat_sm2_mulx_u32(&mut x184, &mut x185, x2, (arg2[4])); + let mut x186: u32 = 0; + let mut x187: u32 = 0; + fiat_sm2_mulx_u32(&mut x186, &mut x187, x2, (arg2[3])); + let mut x188: u32 = 0; + let mut x189: u32 = 0; + fiat_sm2_mulx_u32(&mut x188, &mut x189, x2, (arg2[2])); + let mut x190: u32 = 0; + let mut x191: u32 = 0; + fiat_sm2_mulx_u32(&mut x190, &mut x191, x2, (arg2[1])); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_sm2_mulx_u32(&mut x192, &mut x193, x2, (arg2[0])); + let mut x194: u32 = 0; + let mut x195: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x194, &mut x195, 0x0, x193, x190); + let mut x196: u32 = 0; + let mut x197: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x196, &mut x197, x195, x191, x188); + let mut x198: u32 = 0; + let mut x199: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x198, &mut x199, x197, x189, x186); + let mut x200: u32 = 0; + let mut x201: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x200, &mut x201, x199, x187, x184); + let mut x202: u32 = 0; + let mut x203: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x202, &mut x203, x201, x185, x182); + let mut x204: u32 = 0; + let mut x205: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x204, &mut x205, x203, x183, x180); + let mut x206: u32 = 0; + let mut x207: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x206, &mut x207, x205, x181, x178); + let x208: u32 = ((x207 as u32) + x179); + let mut x209: u32 = 0; + let mut x210: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x209, &mut x210, 0x0, x161, x192); + let mut x211: u32 = 0; + let mut x212: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x211, &mut x212, x210, x163, x194); + let mut x213: u32 = 0; + let mut x214: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x213, &mut x214, x212, x165, x196); + let mut x215: u32 = 0; + let mut x216: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x215, &mut x216, x214, x167, x198); + let mut x217: u32 = 0; + let mut x218: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x217, &mut x218, x216, x169, x200); + let mut x219: u32 = 0; + let mut x220: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x219, &mut x220, x218, x171, x202); + let mut x221: u32 = 0; + let mut x222: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x221, &mut x222, x220, x173, x204); + let mut x223: u32 = 0; + let mut x224: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x223, &mut x224, x222, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: u32 = 0; + fiat_sm2_mulx_u32(&mut x227, &mut x228, x209, 0xfffffffe); + let mut x229: u32 = 0; + let mut x230: u32 = 0; + fiat_sm2_mulx_u32(&mut x229, &mut x230, x209, 0xffffffff); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_sm2_mulx_u32(&mut x231, &mut x232, x209, 0xffffffff); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_sm2_mulx_u32(&mut x233, &mut x234, x209, 0xffffffff); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_sm2_mulx_u32(&mut x235, &mut x236, x209, 0xffffffff); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_sm2_mulx_u32(&mut x237, &mut x238, x209, 0xffffffff); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_sm2_mulx_u32(&mut x239, &mut x240, x209, 0xffffffff); + let mut x241: u32 = 0; + let mut x242: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x241, &mut x242, 0x0, x240, x237); + let x243: u32 = ((x242 as u32) + x238); + let mut x244: u32 = 0; + let mut x245: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x244, &mut x245, 0x0, x236, x233); + let mut x246: u32 = 0; + let mut x247: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x246, &mut x247, x245, x234, x231); + let mut x248: u32 = 0; + let mut x249: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x248, &mut x249, x247, x232, x229); + let mut x250: u32 = 0; + let mut x251: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x250, &mut x251, x249, x230, x227); + let x252: u32 = ((x251 as u32) + x228); + let mut x253: u32 = 0; + let mut x254: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x253, &mut x254, 0x0, x209, x239); + let mut x255: u32 = 0; + let mut x256: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x255, &mut x256, x254, x211, x241); + let mut x257: u32 = 0; + let mut x258: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x257, &mut x258, x256, x213, x243); + let mut x259: u32 = 0; + let mut x260: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x259, &mut x260, x258, x215, x235); + let mut x261: u32 = 0; + let mut x262: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x261, &mut x262, x260, x217, x244); + let mut x263: u32 = 0; + let mut x264: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x263, &mut x264, x262, x219, x246); + let mut x265: u32 = 0; + let mut x266: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x265, &mut x266, x264, x221, x248); + let mut x267: u32 = 0; + let mut x268: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x267, &mut x268, x266, x223, x250); + let mut x269: u32 = 0; + let mut x270: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x269, &mut x270, x268, x225, x252); + let x271: u32 = ((x270 as u32) + (x226 as u32)); + let mut x272: u32 = 0; + let mut x273: u32 = 0; + fiat_sm2_mulx_u32(&mut x272, &mut x273, x3, (arg2[7])); + let mut x274: u32 = 0; + let mut x275: u32 = 0; + fiat_sm2_mulx_u32(&mut x274, &mut x275, x3, (arg2[6])); + let mut x276: u32 = 0; + let mut x277: u32 = 0; + fiat_sm2_mulx_u32(&mut x276, &mut x277, x3, (arg2[5])); + let mut x278: u32 = 0; + let mut x279: u32 = 0; + fiat_sm2_mulx_u32(&mut x278, &mut x279, x3, (arg2[4])); + let mut x280: u32 = 0; + let mut x281: u32 = 0; + fiat_sm2_mulx_u32(&mut x280, &mut x281, x3, (arg2[3])); + let mut x282: u32 = 0; + let mut x283: u32 = 0; + fiat_sm2_mulx_u32(&mut x282, &mut x283, x3, (arg2[2])); + let mut x284: u32 = 0; + let mut x285: u32 = 0; + fiat_sm2_mulx_u32(&mut x284, &mut x285, x3, (arg2[1])); + let mut x286: u32 = 0; + let mut x287: u32 = 0; + fiat_sm2_mulx_u32(&mut x286, &mut x287, x3, (arg2[0])); + let mut x288: u32 = 0; + let mut x289: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x288, &mut x289, 0x0, x287, x284); + let mut x290: u32 = 0; + let mut x291: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x290, &mut x291, x289, x285, x282); + let mut x292: u32 = 0; + let mut x293: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x292, &mut x293, x291, x283, x280); + let mut x294: u32 = 0; + let mut x295: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x294, &mut x295, x293, x281, x278); + let mut x296: u32 = 0; + let mut x297: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x296, &mut x297, x295, x279, x276); + let mut x298: u32 = 0; + let mut x299: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x298, &mut x299, x297, x277, x274); + let mut x300: u32 = 0; + let mut x301: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x300, &mut x301, x299, x275, x272); + let x302: u32 = ((x301 as u32) + x273); + let mut x303: u32 = 0; + let mut x304: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x303, &mut x304, 0x0, x255, x286); + let mut x305: u32 = 0; + let mut x306: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x305, &mut x306, x304, x257, x288); + let mut x307: u32 = 0; + let mut x308: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x307, &mut x308, x306, x259, x290); + let mut x309: u32 = 0; + let mut x310: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x309, &mut x310, x308, x261, x292); + let mut x311: u32 = 0; + let mut x312: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x311, &mut x312, x310, x263, x294); + let mut x313: u32 = 0; + let mut x314: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x313, &mut x314, x312, x265, x296); + let mut x315: u32 = 0; + let mut x316: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x315, &mut x316, x314, x267, x298); + let mut x317: u32 = 0; + let mut x318: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x317, &mut x318, x316, x269, x300); + let mut x319: u32 = 0; + let mut x320: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x319, &mut x320, x318, x271, x302); + let mut x321: u32 = 0; + let mut x322: u32 = 0; + fiat_sm2_mulx_u32(&mut x321, &mut x322, x303, 0xfffffffe); + let mut x323: u32 = 0; + let mut x324: u32 = 0; + fiat_sm2_mulx_u32(&mut x323, &mut x324, x303, 0xffffffff); + let mut x325: u32 = 0; + let mut x326: u32 = 0; + fiat_sm2_mulx_u32(&mut x325, &mut x326, x303, 0xffffffff); + let mut x327: u32 = 0; + let mut x328: u32 = 0; + fiat_sm2_mulx_u32(&mut x327, &mut x328, x303, 0xffffffff); + let mut x329: u32 = 0; + let mut x330: u32 = 0; + fiat_sm2_mulx_u32(&mut x329, &mut x330, x303, 0xffffffff); + let mut x331: u32 = 0; + let mut x332: u32 = 0; + fiat_sm2_mulx_u32(&mut x331, &mut x332, x303, 0xffffffff); + let mut x333: u32 = 0; + let mut x334: u32 = 0; + fiat_sm2_mulx_u32(&mut x333, &mut x334, x303, 0xffffffff); + let mut x335: u32 = 0; + let mut x336: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x335, &mut x336, 0x0, x334, x331); + let x337: u32 = ((x336 as u32) + x332); + let mut x338: u32 = 0; + let mut x339: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x338, &mut x339, 0x0, x330, x327); + let mut x340: u32 = 0; + let mut x341: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x340, &mut x341, x339, x328, x325); + let mut x342: u32 = 0; + let mut x343: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x342, &mut x343, x341, x326, x323); + let mut x344: u32 = 0; + let mut x345: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x344, &mut x345, x343, x324, x321); + let x346: u32 = ((x345 as u32) + x322); + let mut x347: u32 = 0; + let mut x348: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x347, &mut x348, 0x0, x303, x333); + let mut x349: u32 = 0; + let mut x350: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x349, &mut x350, x348, x305, x335); + let mut x351: u32 = 0; + let mut x352: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x351, &mut x352, x350, x307, x337); + let mut x353: u32 = 0; + let mut x354: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x353, &mut x354, x352, x309, x329); + let mut x355: u32 = 0; + let mut x356: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x355, &mut x356, x354, x311, x338); + let mut x357: u32 = 0; + let mut x358: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x357, &mut x358, x356, x313, x340); + let mut x359: u32 = 0; + let mut x360: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x359, &mut x360, x358, x315, x342); + let mut x361: u32 = 0; + let mut x362: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x361, &mut x362, x360, x317, x344); + let mut x363: u32 = 0; + let mut x364: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x363, &mut x364, x362, x319, x346); + let x365: u32 = ((x364 as u32) + (x320 as u32)); + let mut x366: u32 = 0; + let mut x367: u32 = 0; + fiat_sm2_mulx_u32(&mut x366, &mut x367, x4, (arg2[7])); + let mut x368: u32 = 0; + let mut x369: u32 = 0; + fiat_sm2_mulx_u32(&mut x368, &mut x369, x4, (arg2[6])); + let mut x370: u32 = 0; + let mut x371: u32 = 0; + fiat_sm2_mulx_u32(&mut x370, &mut x371, x4, (arg2[5])); + let mut x372: u32 = 0; + let mut x373: u32 = 0; + fiat_sm2_mulx_u32(&mut x372, &mut x373, x4, (arg2[4])); + let mut x374: u32 = 0; + let mut x375: u32 = 0; + fiat_sm2_mulx_u32(&mut x374, &mut x375, x4, (arg2[3])); + let mut x376: u32 = 0; + let mut x377: u32 = 0; + fiat_sm2_mulx_u32(&mut x376, &mut x377, x4, (arg2[2])); + let mut x378: u32 = 0; + let mut x379: u32 = 0; + fiat_sm2_mulx_u32(&mut x378, &mut x379, x4, (arg2[1])); + let mut x380: u32 = 0; + let mut x381: u32 = 0; + fiat_sm2_mulx_u32(&mut x380, &mut x381, x4, (arg2[0])); + let mut x382: u32 = 0; + let mut x383: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x382, &mut x383, 0x0, x381, x378); + let mut x384: u32 = 0; + let mut x385: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x384, &mut x385, x383, x379, x376); + let mut x386: u32 = 0; + let mut x387: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x386, &mut x387, x385, x377, x374); + let mut x388: u32 = 0; + let mut x389: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x388, &mut x389, x387, x375, x372); + let mut x390: u32 = 0; + let mut x391: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x390, &mut x391, x389, x373, x370); + let mut x392: u32 = 0; + let mut x393: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x392, &mut x393, x391, x371, x368); + let mut x394: u32 = 0; + let mut x395: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x394, &mut x395, x393, x369, x366); + let x396: u32 = ((x395 as u32) + x367); + let mut x397: u32 = 0; + let mut x398: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x397, &mut x398, 0x0, x349, x380); + let mut x399: u32 = 0; + let mut x400: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x399, &mut x400, x398, x351, x382); + let mut x401: u32 = 0; + let mut x402: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x401, &mut x402, x400, x353, x384); + let mut x403: u32 = 0; + let mut x404: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x403, &mut x404, x402, x355, x386); + let mut x405: u32 = 0; + let mut x406: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x405, &mut x406, x404, x357, x388); + let mut x407: u32 = 0; + let mut x408: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x407, &mut x408, x406, x359, x390); + let mut x409: u32 = 0; + let mut x410: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x409, &mut x410, x408, x361, x392); + let mut x411: u32 = 0; + let mut x412: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x411, &mut x412, x410, x363, x394); + let mut x413: u32 = 0; + let mut x414: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x413, &mut x414, x412, x365, x396); + let mut x415: u32 = 0; + let mut x416: u32 = 0; + fiat_sm2_mulx_u32(&mut x415, &mut x416, x397, 0xfffffffe); + let mut x417: u32 = 0; + let mut x418: u32 = 0; + fiat_sm2_mulx_u32(&mut x417, &mut x418, x397, 0xffffffff); + let mut x419: u32 = 0; + let mut x420: u32 = 0; + fiat_sm2_mulx_u32(&mut x419, &mut x420, x397, 0xffffffff); + let mut x421: u32 = 0; + let mut x422: u32 = 0; + fiat_sm2_mulx_u32(&mut x421, &mut x422, x397, 0xffffffff); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_sm2_mulx_u32(&mut x423, &mut x424, x397, 0xffffffff); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_sm2_mulx_u32(&mut x425, &mut x426, x397, 0xffffffff); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_sm2_mulx_u32(&mut x427, &mut x428, x397, 0xffffffff); + let mut x429: u32 = 0; + let mut x430: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x429, &mut x430, 0x0, x428, x425); + let x431: u32 = ((x430 as u32) + x426); + let mut x432: u32 = 0; + let mut x433: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x432, &mut x433, 0x0, x424, x421); + let mut x434: u32 = 0; + let mut x435: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x434, &mut x435, x433, x422, x419); + let mut x436: u32 = 0; + let mut x437: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x436, &mut x437, x435, x420, x417); + let mut x438: u32 = 0; + let mut x439: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x438, &mut x439, x437, x418, x415); + let x440: u32 = ((x439 as u32) + x416); + let mut x441: u32 = 0; + let mut x442: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x441, &mut x442, 0x0, x397, x427); + let mut x443: u32 = 0; + let mut x444: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x443, &mut x444, x442, x399, x429); + let mut x445: u32 = 0; + let mut x446: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x445, &mut x446, x444, x401, x431); + let mut x447: u32 = 0; + let mut x448: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x447, &mut x448, x446, x403, x423); + let mut x449: u32 = 0; + let mut x450: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x449, &mut x450, x448, x405, x432); + let mut x451: u32 = 0; + let mut x452: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x451, &mut x452, x450, x407, x434); + let mut x453: u32 = 0; + let mut x454: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x453, &mut x454, x452, x409, x436); + let mut x455: u32 = 0; + let mut x456: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x455, &mut x456, x454, x411, x438); + let mut x457: u32 = 0; + let mut x458: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x457, &mut x458, x456, x413, x440); + let x459: u32 = ((x458 as u32) + (x414 as u32)); + let mut x460: u32 = 0; + let mut x461: u32 = 0; + fiat_sm2_mulx_u32(&mut x460, &mut x461, x5, (arg2[7])); + let mut x462: u32 = 0; + let mut x463: u32 = 0; + fiat_sm2_mulx_u32(&mut x462, &mut x463, x5, (arg2[6])); + let mut x464: u32 = 0; + let mut x465: u32 = 0; + fiat_sm2_mulx_u32(&mut x464, &mut x465, x5, (arg2[5])); + let mut x466: u32 = 0; + let mut x467: u32 = 0; + fiat_sm2_mulx_u32(&mut x466, &mut x467, x5, (arg2[4])); + let mut x468: u32 = 0; + let mut x469: u32 = 0; + fiat_sm2_mulx_u32(&mut x468, &mut x469, x5, (arg2[3])); + let mut x470: u32 = 0; + let mut x471: u32 = 0; + fiat_sm2_mulx_u32(&mut x470, &mut x471, x5, (arg2[2])); + let mut x472: u32 = 0; + let mut x473: u32 = 0; + fiat_sm2_mulx_u32(&mut x472, &mut x473, x5, (arg2[1])); + let mut x474: u32 = 0; + let mut x475: u32 = 0; + fiat_sm2_mulx_u32(&mut x474, &mut x475, x5, (arg2[0])); + let mut x476: u32 = 0; + let mut x477: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x476, &mut x477, 0x0, x475, x472); + let mut x478: u32 = 0; + let mut x479: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x478, &mut x479, x477, x473, x470); + let mut x480: u32 = 0; + let mut x481: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x480, &mut x481, x479, x471, x468); + let mut x482: u32 = 0; + let mut x483: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x482, &mut x483, x481, x469, x466); + let mut x484: u32 = 0; + let mut x485: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x484, &mut x485, x483, x467, x464); + let mut x486: u32 = 0; + let mut x487: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x486, &mut x487, x485, x465, x462); + let mut x488: u32 = 0; + let mut x489: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x488, &mut x489, x487, x463, x460); + let x490: u32 = ((x489 as u32) + x461); + let mut x491: u32 = 0; + let mut x492: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x491, &mut x492, 0x0, x443, x474); + let mut x493: u32 = 0; + let mut x494: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x493, &mut x494, x492, x445, x476); + let mut x495: u32 = 0; + let mut x496: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x495, &mut x496, x494, x447, x478); + let mut x497: u32 = 0; + let mut x498: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x497, &mut x498, x496, x449, x480); + let mut x499: u32 = 0; + let mut x500: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x499, &mut x500, x498, x451, x482); + let mut x501: u32 = 0; + let mut x502: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x501, &mut x502, x500, x453, x484); + let mut x503: u32 = 0; + let mut x504: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x503, &mut x504, x502, x455, x486); + let mut x505: u32 = 0; + let mut x506: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x505, &mut x506, x504, x457, x488); + let mut x507: u32 = 0; + let mut x508: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x507, &mut x508, x506, x459, x490); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_sm2_mulx_u32(&mut x509, &mut x510, x491, 0xfffffffe); + let mut x511: u32 = 0; + let mut x512: u32 = 0; + fiat_sm2_mulx_u32(&mut x511, &mut x512, x491, 0xffffffff); + let mut x513: u32 = 0; + let mut x514: u32 = 0; + fiat_sm2_mulx_u32(&mut x513, &mut x514, x491, 0xffffffff); + let mut x515: u32 = 0; + let mut x516: u32 = 0; + fiat_sm2_mulx_u32(&mut x515, &mut x516, x491, 0xffffffff); + let mut x517: u32 = 0; + let mut x518: u32 = 0; + fiat_sm2_mulx_u32(&mut x517, &mut x518, x491, 0xffffffff); + let mut x519: u32 = 0; + let mut x520: u32 = 0; + fiat_sm2_mulx_u32(&mut x519, &mut x520, x491, 0xffffffff); + let mut x521: u32 = 0; + let mut x522: u32 = 0; + fiat_sm2_mulx_u32(&mut x521, &mut x522, x491, 0xffffffff); + let mut x523: u32 = 0; + let mut x524: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x523, &mut x524, 0x0, x522, x519); + let x525: u32 = ((x524 as u32) + x520); + let mut x526: u32 = 0; + let mut x527: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x526, &mut x527, 0x0, x518, x515); + let mut x528: u32 = 0; + let mut x529: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x528, &mut x529, x527, x516, x513); + let mut x530: u32 = 0; + let mut x531: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x530, &mut x531, x529, x514, x511); + let mut x532: u32 = 0; + let mut x533: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x532, &mut x533, x531, x512, x509); + let x534: u32 = ((x533 as u32) + x510); + let mut x535: u32 = 0; + let mut x536: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x535, &mut x536, 0x0, x491, x521); + let mut x537: u32 = 0; + let mut x538: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x537, &mut x538, x536, x493, x523); + let mut x539: u32 = 0; + let mut x540: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x539, &mut x540, x538, x495, x525); + let mut x541: u32 = 0; + let mut x542: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x541, &mut x542, x540, x497, x517); + let mut x543: u32 = 0; + let mut x544: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x543, &mut x544, x542, x499, x526); + let mut x545: u32 = 0; + let mut x546: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x545, &mut x546, x544, x501, x528); + let mut x547: u32 = 0; + let mut x548: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x547, &mut x548, x546, x503, x530); + let mut x549: u32 = 0; + let mut x550: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x549, &mut x550, x548, x505, x532); + let mut x551: u32 = 0; + let mut x552: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x551, &mut x552, x550, x507, x534); + let x553: u32 = ((x552 as u32) + (x508 as u32)); + let mut x554: u32 = 0; + let mut x555: u32 = 0; + fiat_sm2_mulx_u32(&mut x554, &mut x555, x6, (arg2[7])); + let mut x556: u32 = 0; + let mut x557: u32 = 0; + fiat_sm2_mulx_u32(&mut x556, &mut x557, x6, (arg2[6])); + let mut x558: u32 = 0; + let mut x559: u32 = 0; + fiat_sm2_mulx_u32(&mut x558, &mut x559, x6, (arg2[5])); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_sm2_mulx_u32(&mut x560, &mut x561, x6, (arg2[4])); + let mut x562: u32 = 0; + let mut x563: u32 = 0; + fiat_sm2_mulx_u32(&mut x562, &mut x563, x6, (arg2[3])); + let mut x564: u32 = 0; + let mut x565: u32 = 0; + fiat_sm2_mulx_u32(&mut x564, &mut x565, x6, (arg2[2])); + let mut x566: u32 = 0; + let mut x567: u32 = 0; + fiat_sm2_mulx_u32(&mut x566, &mut x567, x6, (arg2[1])); + let mut x568: u32 = 0; + let mut x569: u32 = 0; + fiat_sm2_mulx_u32(&mut x568, &mut x569, x6, (arg2[0])); + let mut x570: u32 = 0; + let mut x571: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x570, &mut x571, 0x0, x569, x566); + let mut x572: u32 = 0; + let mut x573: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x572, &mut x573, x571, x567, x564); + let mut x574: u32 = 0; + let mut x575: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x574, &mut x575, x573, x565, x562); + let mut x576: u32 = 0; + let mut x577: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x576, &mut x577, x575, x563, x560); + let mut x578: u32 = 0; + let mut x579: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x578, &mut x579, x577, x561, x558); + let mut x580: u32 = 0; + let mut x581: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x580, &mut x581, x579, x559, x556); + let mut x582: u32 = 0; + let mut x583: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x582, &mut x583, x581, x557, x554); + let x584: u32 = ((x583 as u32) + x555); + let mut x585: u32 = 0; + let mut x586: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x585, &mut x586, 0x0, x537, x568); + let mut x587: u32 = 0; + let mut x588: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x587, &mut x588, x586, x539, x570); + let mut x589: u32 = 0; + let mut x590: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x589, &mut x590, x588, x541, x572); + let mut x591: u32 = 0; + let mut x592: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x591, &mut x592, x590, x543, x574); + let mut x593: u32 = 0; + let mut x594: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x593, &mut x594, x592, x545, x576); + let mut x595: u32 = 0; + let mut x596: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x595, &mut x596, x594, x547, x578); + let mut x597: u32 = 0; + let mut x598: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x597, &mut x598, x596, x549, x580); + let mut x599: u32 = 0; + let mut x600: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x599, &mut x600, x598, x551, x582); + let mut x601: u32 = 0; + let mut x602: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x601, &mut x602, x600, x553, x584); + let mut x603: u32 = 0; + let mut x604: u32 = 0; + fiat_sm2_mulx_u32(&mut x603, &mut x604, x585, 0xfffffffe); + let mut x605: u32 = 0; + let mut x606: u32 = 0; + fiat_sm2_mulx_u32(&mut x605, &mut x606, x585, 0xffffffff); + let mut x607: u32 = 0; + let mut x608: u32 = 0; + fiat_sm2_mulx_u32(&mut x607, &mut x608, x585, 0xffffffff); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_sm2_mulx_u32(&mut x609, &mut x610, x585, 0xffffffff); + let mut x611: u32 = 0; + let mut x612: u32 = 0; + fiat_sm2_mulx_u32(&mut x611, &mut x612, x585, 0xffffffff); + let mut x613: u32 = 0; + let mut x614: u32 = 0; + fiat_sm2_mulx_u32(&mut x613, &mut x614, x585, 0xffffffff); + let mut x615: u32 = 0; + let mut x616: u32 = 0; + fiat_sm2_mulx_u32(&mut x615, &mut x616, x585, 0xffffffff); + let mut x617: u32 = 0; + let mut x618: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x617, &mut x618, 0x0, x616, x613); + let x619: u32 = ((x618 as u32) + x614); + let mut x620: u32 = 0; + let mut x621: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x620, &mut x621, 0x0, x612, x609); + let mut x622: u32 = 0; + let mut x623: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x622, &mut x623, x621, x610, x607); + let mut x624: u32 = 0; + let mut x625: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x624, &mut x625, x623, x608, x605); + let mut x626: u32 = 0; + let mut x627: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x626, &mut x627, x625, x606, x603); + let x628: u32 = ((x627 as u32) + x604); + let mut x629: u32 = 0; + let mut x630: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x629, &mut x630, 0x0, x585, x615); + let mut x631: u32 = 0; + let mut x632: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x631, &mut x632, x630, x587, x617); + let mut x633: u32 = 0; + let mut x634: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x633, &mut x634, x632, x589, x619); + let mut x635: u32 = 0; + let mut x636: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x635, &mut x636, x634, x591, x611); + let mut x637: u32 = 0; + let mut x638: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x637, &mut x638, x636, x593, x620); + let mut x639: u32 = 0; + let mut x640: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x639, &mut x640, x638, x595, x622); + let mut x641: u32 = 0; + let mut x642: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x641, &mut x642, x640, x597, x624); + let mut x643: u32 = 0; + let mut x644: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x643, &mut x644, x642, x599, x626); + let mut x645: u32 = 0; + let mut x646: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x645, &mut x646, x644, x601, x628); + let x647: u32 = ((x646 as u32) + (x602 as u32)); + let mut x648: u32 = 0; + let mut x649: u32 = 0; + fiat_sm2_mulx_u32(&mut x648, &mut x649, x7, (arg2[7])); + let mut x650: u32 = 0; + let mut x651: u32 = 0; + fiat_sm2_mulx_u32(&mut x650, &mut x651, x7, (arg2[6])); + let mut x652: u32 = 0; + let mut x653: u32 = 0; + fiat_sm2_mulx_u32(&mut x652, &mut x653, x7, (arg2[5])); + let mut x654: u32 = 0; + let mut x655: u32 = 0; + fiat_sm2_mulx_u32(&mut x654, &mut x655, x7, (arg2[4])); + let mut x656: u32 = 0; + let mut x657: u32 = 0; + fiat_sm2_mulx_u32(&mut x656, &mut x657, x7, (arg2[3])); + let mut x658: u32 = 0; + let mut x659: u32 = 0; + fiat_sm2_mulx_u32(&mut x658, &mut x659, x7, (arg2[2])); + let mut x660: u32 = 0; + let mut x661: u32 = 0; + fiat_sm2_mulx_u32(&mut x660, &mut x661, x7, (arg2[1])); + let mut x662: u32 = 0; + let mut x663: u32 = 0; + fiat_sm2_mulx_u32(&mut x662, &mut x663, x7, (arg2[0])); + let mut x664: u32 = 0; + let mut x665: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x664, &mut x665, 0x0, x663, x660); + let mut x666: u32 = 0; + let mut x667: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x666, &mut x667, x665, x661, x658); + let mut x668: u32 = 0; + let mut x669: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x668, &mut x669, x667, x659, x656); + let mut x670: u32 = 0; + let mut x671: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x670, &mut x671, x669, x657, x654); + let mut x672: u32 = 0; + let mut x673: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x672, &mut x673, x671, x655, x652); + let mut x674: u32 = 0; + let mut x675: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x674, &mut x675, x673, x653, x650); + let mut x676: u32 = 0; + let mut x677: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x676, &mut x677, x675, x651, x648); + let x678: u32 = ((x677 as u32) + x649); + let mut x679: u32 = 0; + let mut x680: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x679, &mut x680, 0x0, x631, x662); + let mut x681: u32 = 0; + let mut x682: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x681, &mut x682, x680, x633, x664); + let mut x683: u32 = 0; + let mut x684: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x683, &mut x684, x682, x635, x666); + let mut x685: u32 = 0; + let mut x686: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x685, &mut x686, x684, x637, x668); + let mut x687: u32 = 0; + let mut x688: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x687, &mut x688, x686, x639, x670); + let mut x689: u32 = 0; + let mut x690: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x689, &mut x690, x688, x641, x672); + let mut x691: u32 = 0; + let mut x692: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x691, &mut x692, x690, x643, x674); + let mut x693: u32 = 0; + let mut x694: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x693, &mut x694, x692, x645, x676); + let mut x695: u32 = 0; + let mut x696: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x695, &mut x696, x694, x647, x678); + let mut x697: u32 = 0; + let mut x698: u32 = 0; + fiat_sm2_mulx_u32(&mut x697, &mut x698, x679, 0xfffffffe); + let mut x699: u32 = 0; + let mut x700: u32 = 0; + fiat_sm2_mulx_u32(&mut x699, &mut x700, x679, 0xffffffff); + let mut x701: u32 = 0; + let mut x702: u32 = 0; + fiat_sm2_mulx_u32(&mut x701, &mut x702, x679, 0xffffffff); + let mut x703: u32 = 0; + let mut x704: u32 = 0; + fiat_sm2_mulx_u32(&mut x703, &mut x704, x679, 0xffffffff); + let mut x705: u32 = 0; + let mut x706: u32 = 0; + fiat_sm2_mulx_u32(&mut x705, &mut x706, x679, 0xffffffff); + let mut x707: u32 = 0; + let mut x708: u32 = 0; + fiat_sm2_mulx_u32(&mut x707, &mut x708, x679, 0xffffffff); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_sm2_mulx_u32(&mut x709, &mut x710, x679, 0xffffffff); + let mut x711: u32 = 0; + let mut x712: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x711, &mut x712, 0x0, x710, x707); + let x713: u32 = ((x712 as u32) + x708); + let mut x714: u32 = 0; + let mut x715: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x714, &mut x715, 0x0, x706, x703); + let mut x716: u32 = 0; + let mut x717: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x716, &mut x717, x715, x704, x701); + let mut x718: u32 = 0; + let mut x719: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x718, &mut x719, x717, x702, x699); + let mut x720: u32 = 0; + let mut x721: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x720, &mut x721, x719, x700, x697); + let x722: u32 = ((x721 as u32) + x698); + let mut x723: u32 = 0; + let mut x724: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x723, &mut x724, 0x0, x679, x709); + let mut x725: u32 = 0; + let mut x726: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x725, &mut x726, x724, x681, x711); + let mut x727: u32 = 0; + let mut x728: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x727, &mut x728, x726, x683, x713); + let mut x729: u32 = 0; + let mut x730: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x729, &mut x730, x728, x685, x705); + let mut x731: u32 = 0; + let mut x732: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x731, &mut x732, x730, x687, x714); + let mut x733: u32 = 0; + let mut x734: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x733, &mut x734, x732, x689, x716); + let mut x735: u32 = 0; + let mut x736: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x735, &mut x736, x734, x691, x718); + let mut x737: u32 = 0; + let mut x738: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x737, &mut x738, x736, x693, x720); + let mut x739: u32 = 0; + let mut x740: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x739, &mut x740, x738, x695, x722); + let x741: u32 = ((x740 as u32) + (x696 as u32)); + let mut x742: u32 = 0; + let mut x743: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x742, &mut x743, 0x0, x725, 0xffffffff); + let mut x744: u32 = 0; + let mut x745: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x744, &mut x745, x743, x727, 0xffffffff); + let mut x746: u32 = 0; + let mut x747: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x746, &mut x747, x745, x729, (0x0 as u32)); + let mut x748: u32 = 0; + let mut x749: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x748, &mut x749, x747, x731, 0xffffffff); + let mut x750: u32 = 0; + let mut x751: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x750, &mut x751, x749, x733, 0xffffffff); + let mut x752: u32 = 0; + let mut x753: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x752, &mut x753, x751, x735, 0xffffffff); + let mut x754: u32 = 0; + let mut x755: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x754, &mut x755, x753, x737, 0xffffffff); + let mut x756: u32 = 0; + let mut x757: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x756, &mut x757, x755, x739, 0xfffffffe); + let mut x758: u32 = 0; + let mut x759: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x758, &mut x759, x757, x741, (0x0 as u32)); + let mut x760: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x760, x759, x742, x725); + let mut x761: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x761, x759, x744, x727); + let mut x762: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x762, x759, x746, x729); + let mut x763: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x763, x759, x748, x731); + let mut x764: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x764, x759, x750, x733); + let mut x765: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x765, x759, x752, x735); + let mut x766: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x766, x759, x754, x737); + let mut x767: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x767, x759, x756, x739); + out1[0] = x760; + out1[1] = x761; + out1[2] = x762; + out1[3] = x763; + out1[4] = x764; + out1[5] = x765; + out1[6] = x766; + out1[7] = x767; +} + +/// The function fiat_sm2_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_sm2_square(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_mulx_u32(&mut x9, &mut x10, x8, (arg1[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_sm2_mulx_u32(&mut x11, &mut x12, x8, (arg1[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_sm2_mulx_u32(&mut x13, &mut x14, x8, (arg1[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_sm2_mulx_u32(&mut x15, &mut x16, x8, (arg1[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_sm2_mulx_u32(&mut x17, &mut x18, x8, (arg1[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_sm2_mulx_u32(&mut x19, &mut x20, x8, (arg1[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_sm2_mulx_u32(&mut x21, &mut x22, x8, (arg1[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_sm2_mulx_u32(&mut x23, &mut x24, x8, (arg1[0])); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_mulx_u32(&mut x40, &mut x41, x23, 0xfffffffe); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_sm2_mulx_u32(&mut x42, &mut x43, x23, 0xffffffff); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_sm2_mulx_u32(&mut x44, &mut x45, x23, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_sm2_mulx_u32(&mut x46, &mut x47, x23, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_sm2_mulx_u32(&mut x48, &mut x49, x23, 0xffffffff); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_sm2_mulx_u32(&mut x50, &mut x51, x23, 0xffffffff); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_sm2_mulx_u32(&mut x52, &mut x53, x23, 0xffffffff); + let mut x54: u32 = 0; + let mut x55: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x54, &mut x55, 0x0, x53, x50); + let x56: u32 = ((x55 as u32) + x51); + let mut x57: u32 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x57, &mut x58, 0x0, x49, x46); + let mut x59: u32 = 0; + let mut x60: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x59, &mut x60, x58, x47, x44); + let mut x61: u32 = 0; + let mut x62: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x61, &mut x62, x60, x45, x42); + let mut x63: u32 = 0; + let mut x64: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x63, &mut x64, x62, x43, x40); + let x65: u32 = ((x64 as u32) + x41); + let mut x66: u32 = 0; + let mut x67: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x66, &mut x67, 0x0, x23, x52); + let mut x68: u32 = 0; + let mut x69: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x68, &mut x69, x67, x25, x54); + let mut x70: u32 = 0; + let mut x71: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x70, &mut x71, x69, x27, x56); + let mut x72: u32 = 0; + let mut x73: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x72, &mut x73, x71, x29, x48); + let mut x74: u32 = 0; + let mut x75: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x74, &mut x75, x73, x31, x57); + let mut x76: u32 = 0; + let mut x77: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x76, &mut x77, x75, x33, x59); + let mut x78: u32 = 0; + let mut x79: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x78, &mut x79, x77, x35, x61); + let mut x80: u32 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x80, &mut x81, x79, x37, x63); + let mut x82: u32 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x82, &mut x83, x81, x39, x65); + let mut x84: u32 = 0; + let mut x85: u32 = 0; + fiat_sm2_mulx_u32(&mut x84, &mut x85, x1, (arg1[7])); + let mut x86: u32 = 0; + let mut x87: u32 = 0; + fiat_sm2_mulx_u32(&mut x86, &mut x87, x1, (arg1[6])); + let mut x88: u32 = 0; + let mut x89: u32 = 0; + fiat_sm2_mulx_u32(&mut x88, &mut x89, x1, (arg1[5])); + let mut x90: u32 = 0; + let mut x91: u32 = 0; + fiat_sm2_mulx_u32(&mut x90, &mut x91, x1, (arg1[4])); + let mut x92: u32 = 0; + let mut x93: u32 = 0; + fiat_sm2_mulx_u32(&mut x92, &mut x93, x1, (arg1[3])); + let mut x94: u32 = 0; + let mut x95: u32 = 0; + fiat_sm2_mulx_u32(&mut x94, &mut x95, x1, (arg1[2])); + let mut x96: u32 = 0; + let mut x97: u32 = 0; + fiat_sm2_mulx_u32(&mut x96, &mut x97, x1, (arg1[1])); + let mut x98: u32 = 0; + let mut x99: u32 = 0; + fiat_sm2_mulx_u32(&mut x98, &mut x99, x1, (arg1[0])); + let mut x100: u32 = 0; + let mut x101: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x100, &mut x101, 0x0, x99, x96); + let mut x102: u32 = 0; + let mut x103: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x102, &mut x103, x101, x97, x94); + let mut x104: u32 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x104, &mut x105, x103, x95, x92); + let mut x106: u32 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x106, &mut x107, x105, x93, x90); + let mut x108: u32 = 0; + let mut x109: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x108, &mut x109, x107, x91, x88); + let mut x110: u32 = 0; + let mut x111: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x110, &mut x111, x109, x89, x86); + let mut x112: u32 = 0; + let mut x113: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x112, &mut x113, x111, x87, x84); + let x114: u32 = ((x113 as u32) + x85); + let mut x115: u32 = 0; + let mut x116: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x115, &mut x116, 0x0, x68, x98); + let mut x117: u32 = 0; + let mut x118: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x117, &mut x118, x116, x70, x100); + let mut x119: u32 = 0; + let mut x120: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x119, &mut x120, x118, x72, x102); + let mut x121: u32 = 0; + let mut x122: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x121, &mut x122, x120, x74, x104); + let mut x123: u32 = 0; + let mut x124: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x123, &mut x124, x122, x76, x106); + let mut x125: u32 = 0; + let mut x126: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x125, &mut x126, x124, x78, x108); + let mut x127: u32 = 0; + let mut x128: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x127, &mut x128, x126, x80, x110); + let mut x129: u32 = 0; + let mut x130: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x129, &mut x130, x128, x82, x112); + let mut x131: u32 = 0; + let mut x132: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x131, &mut x132, x130, (x83 as u32), x114); + let mut x133: u32 = 0; + let mut x134: u32 = 0; + fiat_sm2_mulx_u32(&mut x133, &mut x134, x115, 0xfffffffe); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_sm2_mulx_u32(&mut x135, &mut x136, x115, 0xffffffff); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_sm2_mulx_u32(&mut x137, &mut x138, x115, 0xffffffff); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_sm2_mulx_u32(&mut x139, &mut x140, x115, 0xffffffff); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_sm2_mulx_u32(&mut x141, &mut x142, x115, 0xffffffff); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_sm2_mulx_u32(&mut x143, &mut x144, x115, 0xffffffff); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_sm2_mulx_u32(&mut x145, &mut x146, x115, 0xffffffff); + let mut x147: u32 = 0; + let mut x148: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x147, &mut x148, 0x0, x146, x143); + let x149: u32 = ((x148 as u32) + x144); + let mut x150: u32 = 0; + let mut x151: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x150, &mut x151, 0x0, x142, x139); + let mut x152: u32 = 0; + let mut x153: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x152, &mut x153, x151, x140, x137); + let mut x154: u32 = 0; + let mut x155: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x154, &mut x155, x153, x138, x135); + let mut x156: u32 = 0; + let mut x157: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x156, &mut x157, x155, x136, x133); + let x158: u32 = ((x157 as u32) + x134); + let mut x159: u32 = 0; + let mut x160: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x159, &mut x160, 0x0, x115, x145); + let mut x161: u32 = 0; + let mut x162: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x161, &mut x162, x160, x117, x147); + let mut x163: u32 = 0; + let mut x164: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x163, &mut x164, x162, x119, x149); + let mut x165: u32 = 0; + let mut x166: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x165, &mut x166, x164, x121, x141); + let mut x167: u32 = 0; + let mut x168: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x167, &mut x168, x166, x123, x150); + let mut x169: u32 = 0; + let mut x170: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x169, &mut x170, x168, x125, x152); + let mut x171: u32 = 0; + let mut x172: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x171, &mut x172, x170, x127, x154); + let mut x173: u32 = 0; + let mut x174: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x173, &mut x174, x172, x129, x156); + let mut x175: u32 = 0; + let mut x176: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x175, &mut x176, x174, x131, x158); + let x177: u32 = ((x176 as u32) + (x132 as u32)); + let mut x178: u32 = 0; + let mut x179: u32 = 0; + fiat_sm2_mulx_u32(&mut x178, &mut x179, x2, (arg1[7])); + let mut x180: u32 = 0; + let mut x181: u32 = 0; + fiat_sm2_mulx_u32(&mut x180, &mut x181, x2, (arg1[6])); + let mut x182: u32 = 0; + let mut x183: u32 = 0; + fiat_sm2_mulx_u32(&mut x182, &mut x183, x2, (arg1[5])); + let mut x184: u32 = 0; + let mut x185: u32 = 0; + fiat_sm2_mulx_u32(&mut x184, &mut x185, x2, (arg1[4])); + let mut x186: u32 = 0; + let mut x187: u32 = 0; + fiat_sm2_mulx_u32(&mut x186, &mut x187, x2, (arg1[3])); + let mut x188: u32 = 0; + let mut x189: u32 = 0; + fiat_sm2_mulx_u32(&mut x188, &mut x189, x2, (arg1[2])); + let mut x190: u32 = 0; + let mut x191: u32 = 0; + fiat_sm2_mulx_u32(&mut x190, &mut x191, x2, (arg1[1])); + let mut x192: u32 = 0; + let mut x193: u32 = 0; + fiat_sm2_mulx_u32(&mut x192, &mut x193, x2, (arg1[0])); + let mut x194: u32 = 0; + let mut x195: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x194, &mut x195, 0x0, x193, x190); + let mut x196: u32 = 0; + let mut x197: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x196, &mut x197, x195, x191, x188); + let mut x198: u32 = 0; + let mut x199: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x198, &mut x199, x197, x189, x186); + let mut x200: u32 = 0; + let mut x201: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x200, &mut x201, x199, x187, x184); + let mut x202: u32 = 0; + let mut x203: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x202, &mut x203, x201, x185, x182); + let mut x204: u32 = 0; + let mut x205: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x204, &mut x205, x203, x183, x180); + let mut x206: u32 = 0; + let mut x207: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x206, &mut x207, x205, x181, x178); + let x208: u32 = ((x207 as u32) + x179); + let mut x209: u32 = 0; + let mut x210: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x209, &mut x210, 0x0, x161, x192); + let mut x211: u32 = 0; + let mut x212: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x211, &mut x212, x210, x163, x194); + let mut x213: u32 = 0; + let mut x214: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x213, &mut x214, x212, x165, x196); + let mut x215: u32 = 0; + let mut x216: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x215, &mut x216, x214, x167, x198); + let mut x217: u32 = 0; + let mut x218: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x217, &mut x218, x216, x169, x200); + let mut x219: u32 = 0; + let mut x220: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x219, &mut x220, x218, x171, x202); + let mut x221: u32 = 0; + let mut x222: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x221, &mut x222, x220, x173, x204); + let mut x223: u32 = 0; + let mut x224: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x223, &mut x224, x222, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: u32 = 0; + fiat_sm2_mulx_u32(&mut x227, &mut x228, x209, 0xfffffffe); + let mut x229: u32 = 0; + let mut x230: u32 = 0; + fiat_sm2_mulx_u32(&mut x229, &mut x230, x209, 0xffffffff); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_sm2_mulx_u32(&mut x231, &mut x232, x209, 0xffffffff); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_sm2_mulx_u32(&mut x233, &mut x234, x209, 0xffffffff); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_sm2_mulx_u32(&mut x235, &mut x236, x209, 0xffffffff); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_sm2_mulx_u32(&mut x237, &mut x238, x209, 0xffffffff); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_sm2_mulx_u32(&mut x239, &mut x240, x209, 0xffffffff); + let mut x241: u32 = 0; + let mut x242: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x241, &mut x242, 0x0, x240, x237); + let x243: u32 = ((x242 as u32) + x238); + let mut x244: u32 = 0; + let mut x245: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x244, &mut x245, 0x0, x236, x233); + let mut x246: u32 = 0; + let mut x247: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x246, &mut x247, x245, x234, x231); + let mut x248: u32 = 0; + let mut x249: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x248, &mut x249, x247, x232, x229); + let mut x250: u32 = 0; + let mut x251: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x250, &mut x251, x249, x230, x227); + let x252: u32 = ((x251 as u32) + x228); + let mut x253: u32 = 0; + let mut x254: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x253, &mut x254, 0x0, x209, x239); + let mut x255: u32 = 0; + let mut x256: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x255, &mut x256, x254, x211, x241); + let mut x257: u32 = 0; + let mut x258: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x257, &mut x258, x256, x213, x243); + let mut x259: u32 = 0; + let mut x260: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x259, &mut x260, x258, x215, x235); + let mut x261: u32 = 0; + let mut x262: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x261, &mut x262, x260, x217, x244); + let mut x263: u32 = 0; + let mut x264: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x263, &mut x264, x262, x219, x246); + let mut x265: u32 = 0; + let mut x266: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x265, &mut x266, x264, x221, x248); + let mut x267: u32 = 0; + let mut x268: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x267, &mut x268, x266, x223, x250); + let mut x269: u32 = 0; + let mut x270: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x269, &mut x270, x268, x225, x252); + let x271: u32 = ((x270 as u32) + (x226 as u32)); + let mut x272: u32 = 0; + let mut x273: u32 = 0; + fiat_sm2_mulx_u32(&mut x272, &mut x273, x3, (arg1[7])); + let mut x274: u32 = 0; + let mut x275: u32 = 0; + fiat_sm2_mulx_u32(&mut x274, &mut x275, x3, (arg1[6])); + let mut x276: u32 = 0; + let mut x277: u32 = 0; + fiat_sm2_mulx_u32(&mut x276, &mut x277, x3, (arg1[5])); + let mut x278: u32 = 0; + let mut x279: u32 = 0; + fiat_sm2_mulx_u32(&mut x278, &mut x279, x3, (arg1[4])); + let mut x280: u32 = 0; + let mut x281: u32 = 0; + fiat_sm2_mulx_u32(&mut x280, &mut x281, x3, (arg1[3])); + let mut x282: u32 = 0; + let mut x283: u32 = 0; + fiat_sm2_mulx_u32(&mut x282, &mut x283, x3, (arg1[2])); + let mut x284: u32 = 0; + let mut x285: u32 = 0; + fiat_sm2_mulx_u32(&mut x284, &mut x285, x3, (arg1[1])); + let mut x286: u32 = 0; + let mut x287: u32 = 0; + fiat_sm2_mulx_u32(&mut x286, &mut x287, x3, (arg1[0])); + let mut x288: u32 = 0; + let mut x289: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x288, &mut x289, 0x0, x287, x284); + let mut x290: u32 = 0; + let mut x291: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x290, &mut x291, x289, x285, x282); + let mut x292: u32 = 0; + let mut x293: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x292, &mut x293, x291, x283, x280); + let mut x294: u32 = 0; + let mut x295: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x294, &mut x295, x293, x281, x278); + let mut x296: u32 = 0; + let mut x297: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x296, &mut x297, x295, x279, x276); + let mut x298: u32 = 0; + let mut x299: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x298, &mut x299, x297, x277, x274); + let mut x300: u32 = 0; + let mut x301: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x300, &mut x301, x299, x275, x272); + let x302: u32 = ((x301 as u32) + x273); + let mut x303: u32 = 0; + let mut x304: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x303, &mut x304, 0x0, x255, x286); + let mut x305: u32 = 0; + let mut x306: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x305, &mut x306, x304, x257, x288); + let mut x307: u32 = 0; + let mut x308: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x307, &mut x308, x306, x259, x290); + let mut x309: u32 = 0; + let mut x310: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x309, &mut x310, x308, x261, x292); + let mut x311: u32 = 0; + let mut x312: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x311, &mut x312, x310, x263, x294); + let mut x313: u32 = 0; + let mut x314: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x313, &mut x314, x312, x265, x296); + let mut x315: u32 = 0; + let mut x316: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x315, &mut x316, x314, x267, x298); + let mut x317: u32 = 0; + let mut x318: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x317, &mut x318, x316, x269, x300); + let mut x319: u32 = 0; + let mut x320: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x319, &mut x320, x318, x271, x302); + let mut x321: u32 = 0; + let mut x322: u32 = 0; + fiat_sm2_mulx_u32(&mut x321, &mut x322, x303, 0xfffffffe); + let mut x323: u32 = 0; + let mut x324: u32 = 0; + fiat_sm2_mulx_u32(&mut x323, &mut x324, x303, 0xffffffff); + let mut x325: u32 = 0; + let mut x326: u32 = 0; + fiat_sm2_mulx_u32(&mut x325, &mut x326, x303, 0xffffffff); + let mut x327: u32 = 0; + let mut x328: u32 = 0; + fiat_sm2_mulx_u32(&mut x327, &mut x328, x303, 0xffffffff); + let mut x329: u32 = 0; + let mut x330: u32 = 0; + fiat_sm2_mulx_u32(&mut x329, &mut x330, x303, 0xffffffff); + let mut x331: u32 = 0; + let mut x332: u32 = 0; + fiat_sm2_mulx_u32(&mut x331, &mut x332, x303, 0xffffffff); + let mut x333: u32 = 0; + let mut x334: u32 = 0; + fiat_sm2_mulx_u32(&mut x333, &mut x334, x303, 0xffffffff); + let mut x335: u32 = 0; + let mut x336: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x335, &mut x336, 0x0, x334, x331); + let x337: u32 = ((x336 as u32) + x332); + let mut x338: u32 = 0; + let mut x339: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x338, &mut x339, 0x0, x330, x327); + let mut x340: u32 = 0; + let mut x341: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x340, &mut x341, x339, x328, x325); + let mut x342: u32 = 0; + let mut x343: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x342, &mut x343, x341, x326, x323); + let mut x344: u32 = 0; + let mut x345: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x344, &mut x345, x343, x324, x321); + let x346: u32 = ((x345 as u32) + x322); + let mut x347: u32 = 0; + let mut x348: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x347, &mut x348, 0x0, x303, x333); + let mut x349: u32 = 0; + let mut x350: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x349, &mut x350, x348, x305, x335); + let mut x351: u32 = 0; + let mut x352: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x351, &mut x352, x350, x307, x337); + let mut x353: u32 = 0; + let mut x354: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x353, &mut x354, x352, x309, x329); + let mut x355: u32 = 0; + let mut x356: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x355, &mut x356, x354, x311, x338); + let mut x357: u32 = 0; + let mut x358: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x357, &mut x358, x356, x313, x340); + let mut x359: u32 = 0; + let mut x360: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x359, &mut x360, x358, x315, x342); + let mut x361: u32 = 0; + let mut x362: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x361, &mut x362, x360, x317, x344); + let mut x363: u32 = 0; + let mut x364: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x363, &mut x364, x362, x319, x346); + let x365: u32 = ((x364 as u32) + (x320 as u32)); + let mut x366: u32 = 0; + let mut x367: u32 = 0; + fiat_sm2_mulx_u32(&mut x366, &mut x367, x4, (arg1[7])); + let mut x368: u32 = 0; + let mut x369: u32 = 0; + fiat_sm2_mulx_u32(&mut x368, &mut x369, x4, (arg1[6])); + let mut x370: u32 = 0; + let mut x371: u32 = 0; + fiat_sm2_mulx_u32(&mut x370, &mut x371, x4, (arg1[5])); + let mut x372: u32 = 0; + let mut x373: u32 = 0; + fiat_sm2_mulx_u32(&mut x372, &mut x373, x4, (arg1[4])); + let mut x374: u32 = 0; + let mut x375: u32 = 0; + fiat_sm2_mulx_u32(&mut x374, &mut x375, x4, (arg1[3])); + let mut x376: u32 = 0; + let mut x377: u32 = 0; + fiat_sm2_mulx_u32(&mut x376, &mut x377, x4, (arg1[2])); + let mut x378: u32 = 0; + let mut x379: u32 = 0; + fiat_sm2_mulx_u32(&mut x378, &mut x379, x4, (arg1[1])); + let mut x380: u32 = 0; + let mut x381: u32 = 0; + fiat_sm2_mulx_u32(&mut x380, &mut x381, x4, (arg1[0])); + let mut x382: u32 = 0; + let mut x383: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x382, &mut x383, 0x0, x381, x378); + let mut x384: u32 = 0; + let mut x385: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x384, &mut x385, x383, x379, x376); + let mut x386: u32 = 0; + let mut x387: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x386, &mut x387, x385, x377, x374); + let mut x388: u32 = 0; + let mut x389: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x388, &mut x389, x387, x375, x372); + let mut x390: u32 = 0; + let mut x391: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x390, &mut x391, x389, x373, x370); + let mut x392: u32 = 0; + let mut x393: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x392, &mut x393, x391, x371, x368); + let mut x394: u32 = 0; + let mut x395: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x394, &mut x395, x393, x369, x366); + let x396: u32 = ((x395 as u32) + x367); + let mut x397: u32 = 0; + let mut x398: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x397, &mut x398, 0x0, x349, x380); + let mut x399: u32 = 0; + let mut x400: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x399, &mut x400, x398, x351, x382); + let mut x401: u32 = 0; + let mut x402: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x401, &mut x402, x400, x353, x384); + let mut x403: u32 = 0; + let mut x404: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x403, &mut x404, x402, x355, x386); + let mut x405: u32 = 0; + let mut x406: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x405, &mut x406, x404, x357, x388); + let mut x407: u32 = 0; + let mut x408: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x407, &mut x408, x406, x359, x390); + let mut x409: u32 = 0; + let mut x410: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x409, &mut x410, x408, x361, x392); + let mut x411: u32 = 0; + let mut x412: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x411, &mut x412, x410, x363, x394); + let mut x413: u32 = 0; + let mut x414: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x413, &mut x414, x412, x365, x396); + let mut x415: u32 = 0; + let mut x416: u32 = 0; + fiat_sm2_mulx_u32(&mut x415, &mut x416, x397, 0xfffffffe); + let mut x417: u32 = 0; + let mut x418: u32 = 0; + fiat_sm2_mulx_u32(&mut x417, &mut x418, x397, 0xffffffff); + let mut x419: u32 = 0; + let mut x420: u32 = 0; + fiat_sm2_mulx_u32(&mut x419, &mut x420, x397, 0xffffffff); + let mut x421: u32 = 0; + let mut x422: u32 = 0; + fiat_sm2_mulx_u32(&mut x421, &mut x422, x397, 0xffffffff); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_sm2_mulx_u32(&mut x423, &mut x424, x397, 0xffffffff); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_sm2_mulx_u32(&mut x425, &mut x426, x397, 0xffffffff); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_sm2_mulx_u32(&mut x427, &mut x428, x397, 0xffffffff); + let mut x429: u32 = 0; + let mut x430: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x429, &mut x430, 0x0, x428, x425); + let x431: u32 = ((x430 as u32) + x426); + let mut x432: u32 = 0; + let mut x433: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x432, &mut x433, 0x0, x424, x421); + let mut x434: u32 = 0; + let mut x435: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x434, &mut x435, x433, x422, x419); + let mut x436: u32 = 0; + let mut x437: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x436, &mut x437, x435, x420, x417); + let mut x438: u32 = 0; + let mut x439: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x438, &mut x439, x437, x418, x415); + let x440: u32 = ((x439 as u32) + x416); + let mut x441: u32 = 0; + let mut x442: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x441, &mut x442, 0x0, x397, x427); + let mut x443: u32 = 0; + let mut x444: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x443, &mut x444, x442, x399, x429); + let mut x445: u32 = 0; + let mut x446: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x445, &mut x446, x444, x401, x431); + let mut x447: u32 = 0; + let mut x448: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x447, &mut x448, x446, x403, x423); + let mut x449: u32 = 0; + let mut x450: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x449, &mut x450, x448, x405, x432); + let mut x451: u32 = 0; + let mut x452: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x451, &mut x452, x450, x407, x434); + let mut x453: u32 = 0; + let mut x454: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x453, &mut x454, x452, x409, x436); + let mut x455: u32 = 0; + let mut x456: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x455, &mut x456, x454, x411, x438); + let mut x457: u32 = 0; + let mut x458: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x457, &mut x458, x456, x413, x440); + let x459: u32 = ((x458 as u32) + (x414 as u32)); + let mut x460: u32 = 0; + let mut x461: u32 = 0; + fiat_sm2_mulx_u32(&mut x460, &mut x461, x5, (arg1[7])); + let mut x462: u32 = 0; + let mut x463: u32 = 0; + fiat_sm2_mulx_u32(&mut x462, &mut x463, x5, (arg1[6])); + let mut x464: u32 = 0; + let mut x465: u32 = 0; + fiat_sm2_mulx_u32(&mut x464, &mut x465, x5, (arg1[5])); + let mut x466: u32 = 0; + let mut x467: u32 = 0; + fiat_sm2_mulx_u32(&mut x466, &mut x467, x5, (arg1[4])); + let mut x468: u32 = 0; + let mut x469: u32 = 0; + fiat_sm2_mulx_u32(&mut x468, &mut x469, x5, (arg1[3])); + let mut x470: u32 = 0; + let mut x471: u32 = 0; + fiat_sm2_mulx_u32(&mut x470, &mut x471, x5, (arg1[2])); + let mut x472: u32 = 0; + let mut x473: u32 = 0; + fiat_sm2_mulx_u32(&mut x472, &mut x473, x5, (arg1[1])); + let mut x474: u32 = 0; + let mut x475: u32 = 0; + fiat_sm2_mulx_u32(&mut x474, &mut x475, x5, (arg1[0])); + let mut x476: u32 = 0; + let mut x477: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x476, &mut x477, 0x0, x475, x472); + let mut x478: u32 = 0; + let mut x479: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x478, &mut x479, x477, x473, x470); + let mut x480: u32 = 0; + let mut x481: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x480, &mut x481, x479, x471, x468); + let mut x482: u32 = 0; + let mut x483: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x482, &mut x483, x481, x469, x466); + let mut x484: u32 = 0; + let mut x485: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x484, &mut x485, x483, x467, x464); + let mut x486: u32 = 0; + let mut x487: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x486, &mut x487, x485, x465, x462); + let mut x488: u32 = 0; + let mut x489: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x488, &mut x489, x487, x463, x460); + let x490: u32 = ((x489 as u32) + x461); + let mut x491: u32 = 0; + let mut x492: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x491, &mut x492, 0x0, x443, x474); + let mut x493: u32 = 0; + let mut x494: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x493, &mut x494, x492, x445, x476); + let mut x495: u32 = 0; + let mut x496: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x495, &mut x496, x494, x447, x478); + let mut x497: u32 = 0; + let mut x498: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x497, &mut x498, x496, x449, x480); + let mut x499: u32 = 0; + let mut x500: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x499, &mut x500, x498, x451, x482); + let mut x501: u32 = 0; + let mut x502: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x501, &mut x502, x500, x453, x484); + let mut x503: u32 = 0; + let mut x504: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x503, &mut x504, x502, x455, x486); + let mut x505: u32 = 0; + let mut x506: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x505, &mut x506, x504, x457, x488); + let mut x507: u32 = 0; + let mut x508: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x507, &mut x508, x506, x459, x490); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_sm2_mulx_u32(&mut x509, &mut x510, x491, 0xfffffffe); + let mut x511: u32 = 0; + let mut x512: u32 = 0; + fiat_sm2_mulx_u32(&mut x511, &mut x512, x491, 0xffffffff); + let mut x513: u32 = 0; + let mut x514: u32 = 0; + fiat_sm2_mulx_u32(&mut x513, &mut x514, x491, 0xffffffff); + let mut x515: u32 = 0; + let mut x516: u32 = 0; + fiat_sm2_mulx_u32(&mut x515, &mut x516, x491, 0xffffffff); + let mut x517: u32 = 0; + let mut x518: u32 = 0; + fiat_sm2_mulx_u32(&mut x517, &mut x518, x491, 0xffffffff); + let mut x519: u32 = 0; + let mut x520: u32 = 0; + fiat_sm2_mulx_u32(&mut x519, &mut x520, x491, 0xffffffff); + let mut x521: u32 = 0; + let mut x522: u32 = 0; + fiat_sm2_mulx_u32(&mut x521, &mut x522, x491, 0xffffffff); + let mut x523: u32 = 0; + let mut x524: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x523, &mut x524, 0x0, x522, x519); + let x525: u32 = ((x524 as u32) + x520); + let mut x526: u32 = 0; + let mut x527: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x526, &mut x527, 0x0, x518, x515); + let mut x528: u32 = 0; + let mut x529: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x528, &mut x529, x527, x516, x513); + let mut x530: u32 = 0; + let mut x531: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x530, &mut x531, x529, x514, x511); + let mut x532: u32 = 0; + let mut x533: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x532, &mut x533, x531, x512, x509); + let x534: u32 = ((x533 as u32) + x510); + let mut x535: u32 = 0; + let mut x536: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x535, &mut x536, 0x0, x491, x521); + let mut x537: u32 = 0; + let mut x538: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x537, &mut x538, x536, x493, x523); + let mut x539: u32 = 0; + let mut x540: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x539, &mut x540, x538, x495, x525); + let mut x541: u32 = 0; + let mut x542: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x541, &mut x542, x540, x497, x517); + let mut x543: u32 = 0; + let mut x544: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x543, &mut x544, x542, x499, x526); + let mut x545: u32 = 0; + let mut x546: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x545, &mut x546, x544, x501, x528); + let mut x547: u32 = 0; + let mut x548: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x547, &mut x548, x546, x503, x530); + let mut x549: u32 = 0; + let mut x550: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x549, &mut x550, x548, x505, x532); + let mut x551: u32 = 0; + let mut x552: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x551, &mut x552, x550, x507, x534); + let x553: u32 = ((x552 as u32) + (x508 as u32)); + let mut x554: u32 = 0; + let mut x555: u32 = 0; + fiat_sm2_mulx_u32(&mut x554, &mut x555, x6, (arg1[7])); + let mut x556: u32 = 0; + let mut x557: u32 = 0; + fiat_sm2_mulx_u32(&mut x556, &mut x557, x6, (arg1[6])); + let mut x558: u32 = 0; + let mut x559: u32 = 0; + fiat_sm2_mulx_u32(&mut x558, &mut x559, x6, (arg1[5])); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_sm2_mulx_u32(&mut x560, &mut x561, x6, (arg1[4])); + let mut x562: u32 = 0; + let mut x563: u32 = 0; + fiat_sm2_mulx_u32(&mut x562, &mut x563, x6, (arg1[3])); + let mut x564: u32 = 0; + let mut x565: u32 = 0; + fiat_sm2_mulx_u32(&mut x564, &mut x565, x6, (arg1[2])); + let mut x566: u32 = 0; + let mut x567: u32 = 0; + fiat_sm2_mulx_u32(&mut x566, &mut x567, x6, (arg1[1])); + let mut x568: u32 = 0; + let mut x569: u32 = 0; + fiat_sm2_mulx_u32(&mut x568, &mut x569, x6, (arg1[0])); + let mut x570: u32 = 0; + let mut x571: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x570, &mut x571, 0x0, x569, x566); + let mut x572: u32 = 0; + let mut x573: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x572, &mut x573, x571, x567, x564); + let mut x574: u32 = 0; + let mut x575: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x574, &mut x575, x573, x565, x562); + let mut x576: u32 = 0; + let mut x577: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x576, &mut x577, x575, x563, x560); + let mut x578: u32 = 0; + let mut x579: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x578, &mut x579, x577, x561, x558); + let mut x580: u32 = 0; + let mut x581: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x580, &mut x581, x579, x559, x556); + let mut x582: u32 = 0; + let mut x583: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x582, &mut x583, x581, x557, x554); + let x584: u32 = ((x583 as u32) + x555); + let mut x585: u32 = 0; + let mut x586: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x585, &mut x586, 0x0, x537, x568); + let mut x587: u32 = 0; + let mut x588: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x587, &mut x588, x586, x539, x570); + let mut x589: u32 = 0; + let mut x590: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x589, &mut x590, x588, x541, x572); + let mut x591: u32 = 0; + let mut x592: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x591, &mut x592, x590, x543, x574); + let mut x593: u32 = 0; + let mut x594: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x593, &mut x594, x592, x545, x576); + let mut x595: u32 = 0; + let mut x596: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x595, &mut x596, x594, x547, x578); + let mut x597: u32 = 0; + let mut x598: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x597, &mut x598, x596, x549, x580); + let mut x599: u32 = 0; + let mut x600: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x599, &mut x600, x598, x551, x582); + let mut x601: u32 = 0; + let mut x602: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x601, &mut x602, x600, x553, x584); + let mut x603: u32 = 0; + let mut x604: u32 = 0; + fiat_sm2_mulx_u32(&mut x603, &mut x604, x585, 0xfffffffe); + let mut x605: u32 = 0; + let mut x606: u32 = 0; + fiat_sm2_mulx_u32(&mut x605, &mut x606, x585, 0xffffffff); + let mut x607: u32 = 0; + let mut x608: u32 = 0; + fiat_sm2_mulx_u32(&mut x607, &mut x608, x585, 0xffffffff); + let mut x609: u32 = 0; + let mut x610: u32 = 0; + fiat_sm2_mulx_u32(&mut x609, &mut x610, x585, 0xffffffff); + let mut x611: u32 = 0; + let mut x612: u32 = 0; + fiat_sm2_mulx_u32(&mut x611, &mut x612, x585, 0xffffffff); + let mut x613: u32 = 0; + let mut x614: u32 = 0; + fiat_sm2_mulx_u32(&mut x613, &mut x614, x585, 0xffffffff); + let mut x615: u32 = 0; + let mut x616: u32 = 0; + fiat_sm2_mulx_u32(&mut x615, &mut x616, x585, 0xffffffff); + let mut x617: u32 = 0; + let mut x618: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x617, &mut x618, 0x0, x616, x613); + let x619: u32 = ((x618 as u32) + x614); + let mut x620: u32 = 0; + let mut x621: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x620, &mut x621, 0x0, x612, x609); + let mut x622: u32 = 0; + let mut x623: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x622, &mut x623, x621, x610, x607); + let mut x624: u32 = 0; + let mut x625: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x624, &mut x625, x623, x608, x605); + let mut x626: u32 = 0; + let mut x627: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x626, &mut x627, x625, x606, x603); + let x628: u32 = ((x627 as u32) + x604); + let mut x629: u32 = 0; + let mut x630: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x629, &mut x630, 0x0, x585, x615); + let mut x631: u32 = 0; + let mut x632: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x631, &mut x632, x630, x587, x617); + let mut x633: u32 = 0; + let mut x634: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x633, &mut x634, x632, x589, x619); + let mut x635: u32 = 0; + let mut x636: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x635, &mut x636, x634, x591, x611); + let mut x637: u32 = 0; + let mut x638: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x637, &mut x638, x636, x593, x620); + let mut x639: u32 = 0; + let mut x640: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x639, &mut x640, x638, x595, x622); + let mut x641: u32 = 0; + let mut x642: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x641, &mut x642, x640, x597, x624); + let mut x643: u32 = 0; + let mut x644: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x643, &mut x644, x642, x599, x626); + let mut x645: u32 = 0; + let mut x646: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x645, &mut x646, x644, x601, x628); + let x647: u32 = ((x646 as u32) + (x602 as u32)); + let mut x648: u32 = 0; + let mut x649: u32 = 0; + fiat_sm2_mulx_u32(&mut x648, &mut x649, x7, (arg1[7])); + let mut x650: u32 = 0; + let mut x651: u32 = 0; + fiat_sm2_mulx_u32(&mut x650, &mut x651, x7, (arg1[6])); + let mut x652: u32 = 0; + let mut x653: u32 = 0; + fiat_sm2_mulx_u32(&mut x652, &mut x653, x7, (arg1[5])); + let mut x654: u32 = 0; + let mut x655: u32 = 0; + fiat_sm2_mulx_u32(&mut x654, &mut x655, x7, (arg1[4])); + let mut x656: u32 = 0; + let mut x657: u32 = 0; + fiat_sm2_mulx_u32(&mut x656, &mut x657, x7, (arg1[3])); + let mut x658: u32 = 0; + let mut x659: u32 = 0; + fiat_sm2_mulx_u32(&mut x658, &mut x659, x7, (arg1[2])); + let mut x660: u32 = 0; + let mut x661: u32 = 0; + fiat_sm2_mulx_u32(&mut x660, &mut x661, x7, (arg1[1])); + let mut x662: u32 = 0; + let mut x663: u32 = 0; + fiat_sm2_mulx_u32(&mut x662, &mut x663, x7, (arg1[0])); + let mut x664: u32 = 0; + let mut x665: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x664, &mut x665, 0x0, x663, x660); + let mut x666: u32 = 0; + let mut x667: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x666, &mut x667, x665, x661, x658); + let mut x668: u32 = 0; + let mut x669: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x668, &mut x669, x667, x659, x656); + let mut x670: u32 = 0; + let mut x671: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x670, &mut x671, x669, x657, x654); + let mut x672: u32 = 0; + let mut x673: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x672, &mut x673, x671, x655, x652); + let mut x674: u32 = 0; + let mut x675: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x674, &mut x675, x673, x653, x650); + let mut x676: u32 = 0; + let mut x677: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x676, &mut x677, x675, x651, x648); + let x678: u32 = ((x677 as u32) + x649); + let mut x679: u32 = 0; + let mut x680: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x679, &mut x680, 0x0, x631, x662); + let mut x681: u32 = 0; + let mut x682: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x681, &mut x682, x680, x633, x664); + let mut x683: u32 = 0; + let mut x684: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x683, &mut x684, x682, x635, x666); + let mut x685: u32 = 0; + let mut x686: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x685, &mut x686, x684, x637, x668); + let mut x687: u32 = 0; + let mut x688: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x687, &mut x688, x686, x639, x670); + let mut x689: u32 = 0; + let mut x690: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x689, &mut x690, x688, x641, x672); + let mut x691: u32 = 0; + let mut x692: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x691, &mut x692, x690, x643, x674); + let mut x693: u32 = 0; + let mut x694: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x693, &mut x694, x692, x645, x676); + let mut x695: u32 = 0; + let mut x696: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x695, &mut x696, x694, x647, x678); + let mut x697: u32 = 0; + let mut x698: u32 = 0; + fiat_sm2_mulx_u32(&mut x697, &mut x698, x679, 0xfffffffe); + let mut x699: u32 = 0; + let mut x700: u32 = 0; + fiat_sm2_mulx_u32(&mut x699, &mut x700, x679, 0xffffffff); + let mut x701: u32 = 0; + let mut x702: u32 = 0; + fiat_sm2_mulx_u32(&mut x701, &mut x702, x679, 0xffffffff); + let mut x703: u32 = 0; + let mut x704: u32 = 0; + fiat_sm2_mulx_u32(&mut x703, &mut x704, x679, 0xffffffff); + let mut x705: u32 = 0; + let mut x706: u32 = 0; + fiat_sm2_mulx_u32(&mut x705, &mut x706, x679, 0xffffffff); + let mut x707: u32 = 0; + let mut x708: u32 = 0; + fiat_sm2_mulx_u32(&mut x707, &mut x708, x679, 0xffffffff); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_sm2_mulx_u32(&mut x709, &mut x710, x679, 0xffffffff); + let mut x711: u32 = 0; + let mut x712: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x711, &mut x712, 0x0, x710, x707); + let x713: u32 = ((x712 as u32) + x708); + let mut x714: u32 = 0; + let mut x715: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x714, &mut x715, 0x0, x706, x703); + let mut x716: u32 = 0; + let mut x717: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x716, &mut x717, x715, x704, x701); + let mut x718: u32 = 0; + let mut x719: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x718, &mut x719, x717, x702, x699); + let mut x720: u32 = 0; + let mut x721: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x720, &mut x721, x719, x700, x697); + let x722: u32 = ((x721 as u32) + x698); + let mut x723: u32 = 0; + let mut x724: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x723, &mut x724, 0x0, x679, x709); + let mut x725: u32 = 0; + let mut x726: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x725, &mut x726, x724, x681, x711); + let mut x727: u32 = 0; + let mut x728: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x727, &mut x728, x726, x683, x713); + let mut x729: u32 = 0; + let mut x730: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x729, &mut x730, x728, x685, x705); + let mut x731: u32 = 0; + let mut x732: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x731, &mut x732, x730, x687, x714); + let mut x733: u32 = 0; + let mut x734: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x733, &mut x734, x732, x689, x716); + let mut x735: u32 = 0; + let mut x736: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x735, &mut x736, x734, x691, x718); + let mut x737: u32 = 0; + let mut x738: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x737, &mut x738, x736, x693, x720); + let mut x739: u32 = 0; + let mut x740: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x739, &mut x740, x738, x695, x722); + let x741: u32 = ((x740 as u32) + (x696 as u32)); + let mut x742: u32 = 0; + let mut x743: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x742, &mut x743, 0x0, x725, 0xffffffff); + let mut x744: u32 = 0; + let mut x745: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x744, &mut x745, x743, x727, 0xffffffff); + let mut x746: u32 = 0; + let mut x747: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x746, &mut x747, x745, x729, (0x0 as u32)); + let mut x748: u32 = 0; + let mut x749: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x748, &mut x749, x747, x731, 0xffffffff); + let mut x750: u32 = 0; + let mut x751: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x750, &mut x751, x749, x733, 0xffffffff); + let mut x752: u32 = 0; + let mut x753: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x752, &mut x753, x751, x735, 0xffffffff); + let mut x754: u32 = 0; + let mut x755: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x754, &mut x755, x753, x737, 0xffffffff); + let mut x756: u32 = 0; + let mut x757: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x756, &mut x757, x755, x739, 0xfffffffe); + let mut x758: u32 = 0; + let mut x759: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x758, &mut x759, x757, x741, (0x0 as u32)); + let mut x760: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x760, x759, x742, x725); + let mut x761: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x761, x759, x744, x727); + let mut x762: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x762, x759, x746, x729); + let mut x763: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x763, x759, x748, x731); + let mut x764: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x764, x759, x750, x733); + let mut x765: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x765, x759, x752, x735); + let mut x766: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x766, x759, x754, x737); + let mut x767: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x767, x759, x756, x739); + out1[0] = x760; + out1[1] = x761; + out1[2] = x762; + out1[3] = x763; + out1[4] = x764; + out1[5] = x765; + out1[6] = x766; + out1[7] = x767; +} + +/// The function fiat_sm2_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_sm2_add(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element, arg2: &fiat_sm2_montgomery_domain_field_element) { + let mut x1: u32 = 0; + let mut x2: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x17, &mut x18, 0x0, x1, 0xffffffff); + let mut x19: u32 = 0; + let mut x20: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x19, &mut x20, x18, x3, 0xffffffff); + let mut x21: u32 = 0; + let mut x22: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x21, &mut x22, x20, x5, (0x0 as u32)); + let mut x23: u32 = 0; + let mut x24: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x23, &mut x24, x22, x7, 0xffffffff); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x25, &mut x26, x24, x9, 0xffffffff); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x27, &mut x28, x26, x11, 0xffffffff); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x29, &mut x30, x28, x13, 0xffffffff); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x31, &mut x32, x30, x15, 0xfffffffe); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x33, &mut x34, x32, (x16 as u32), (0x0 as u32)); + let mut x35: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x35, x34, x17, x1); + let mut x36: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x36, x34, x19, x3); + let mut x37: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x37, x34, x21, x5); + let mut x38: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x38, x34, x23, x7); + let mut x39: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x39, x34, x25, x9); + let mut x40: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x40, x34, x27, x11); + let mut x41: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x41, x34, x29, x13); + let mut x42: u32 = 0; + fiat_sm2_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_sm2_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_sm2_sub(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element, arg2: &fiat_sm2_montgomery_domain_field_element) { + let mut x1: u32 = 0; + let mut x2: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, x17); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x20, &mut x21, x19, x3, x17); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x22, &mut x23, x21, x5, (0x0 as u32)); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x24, &mut x25, x23, x7, x17); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x26, &mut x27, x25, x9, x17); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x30, &mut x31, x29, x13, x17); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x32, &mut x33, x31, x15, (x17 & 0xfffffffe)); + 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_sm2_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_sm2_opp(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element) { + let mut x1: u32 = 0; + let mut x2: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x1, &mut x2, 0x0, (0x0 as u32), (arg1[0])); + let mut x3: u32 = 0; + let mut x4: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x3, &mut x4, x2, (0x0 as u32), (arg1[1])); + let mut x5: u32 = 0; + let mut x6: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x5, &mut x6, x4, (0x0 as u32), (arg1[2])); + let mut x7: u32 = 0; + let mut x8: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x7, &mut x8, x6, (0x0 as u32), (arg1[3])); + let mut x9: u32 = 0; + let mut x10: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x9, &mut x10, x8, (0x0 as u32), (arg1[4])); + let mut x11: u32 = 0; + let mut x12: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x11, &mut x12, x10, (0x0 as u32), (arg1[5])); + let mut x13: u32 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x13, &mut x14, x12, (0x0 as u32), (arg1[6])); + let mut x15: u32 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x15, &mut x16, x14, (0x0 as u32), (arg1[7])); + let mut x17: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, x17); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x20, &mut x21, x19, x3, x17); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x22, &mut x23, x21, x5, (0x0 as u32)); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x24, &mut x25, x23, x7, x17); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x26, &mut x27, x25, x9, x17); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x30, &mut x31, x29, x13, x17); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x32, &mut x33, x31, x15, (x17 & 0xfffffffe)); + 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_sm2_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_sm2_from_montgomery(out1: &mut fiat_sm2_non_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element) { + let x1: u32 = (arg1[0]); + let mut x2: u32 = 0; + let mut x3: u32 = 0; + fiat_sm2_mulx_u32(&mut x2, &mut x3, x1, 0xfffffffe); + let mut x4: u32 = 0; + let mut x5: u32 = 0; + fiat_sm2_mulx_u32(&mut x4, &mut x5, x1, 0xffffffff); + let mut x6: u32 = 0; + let mut x7: u32 = 0; + fiat_sm2_mulx_u32(&mut x6, &mut x7, x1, 0xffffffff); + let mut x8: u32 = 0; + let mut x9: u32 = 0; + fiat_sm2_mulx_u32(&mut x8, &mut x9, x1, 0xffffffff); + let mut x10: u32 = 0; + let mut x11: u32 = 0; + fiat_sm2_mulx_u32(&mut x10, &mut x11, x1, 0xffffffff); + let mut x12: u32 = 0; + let mut x13: u32 = 0; + fiat_sm2_mulx_u32(&mut x12, &mut x13, x1, 0xffffffff); + let mut x14: u32 = 0; + let mut x15: u32 = 0; + fiat_sm2_mulx_u32(&mut x14, &mut x15, x1, 0xffffffff); + let mut x16: u32 = 0; + let mut x17: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x16, &mut x17, 0x0, x15, x12); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x18, &mut x19, 0x0, x11, x8); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x20, &mut x21, x19, x9, x6); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x22, &mut x23, x21, x7, x4); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x24, &mut x25, x23, x5, x2); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x26, &mut x27, 0x0, x1, x14); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), x16); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), ((x17 as u32) + x13)); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), x10); + let mut x34: u32 = 0; + let mut x35: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x34, &mut x35, x33, (0x0 as u32), x18); + let mut x36: u32 = 0; + let mut x37: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x36, &mut x37, x35, (0x0 as u32), x20); + let mut x38: u32 = 0; + let mut x39: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x38, &mut x39, x37, (0x0 as u32), x22); + let mut x40: u32 = 0; + let mut x41: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x40, &mut x41, x39, (0x0 as u32), x24); + let mut x42: u32 = 0; + let mut x43: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x42, &mut x43, 0x0, x28, (arg1[1])); + let mut x44: u32 = 0; + let mut x45: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x44, &mut x45, x43, x30, (0x0 as u32)); + let mut x46: u32 = 0; + let mut x47: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x46, &mut x47, x45, x32, (0x0 as u32)); + let mut x48: u32 = 0; + let mut x49: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x48, &mut x49, x47, x34, (0x0 as u32)); + let mut x50: u32 = 0; + let mut x51: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x50, &mut x51, x49, x36, (0x0 as u32)); + let mut x52: u32 = 0; + let mut x53: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x52, &mut x53, x51, x38, (0x0 as u32)); + let mut x54: u32 = 0; + let mut x55: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x54, &mut x55, x53, x40, (0x0 as u32)); + let mut x56: u32 = 0; + let mut x57: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x56, &mut x57, x55, ((x41 as u32) + ((x25 as u32) + x3)), (0x0 as u32)); + let mut x58: u32 = 0; + let mut x59: u32 = 0; + fiat_sm2_mulx_u32(&mut x58, &mut x59, x42, 0xfffffffe); + let mut x60: u32 = 0; + let mut x61: u32 = 0; + fiat_sm2_mulx_u32(&mut x60, &mut x61, x42, 0xffffffff); + let mut x62: u32 = 0; + let mut x63: u32 = 0; + fiat_sm2_mulx_u32(&mut x62, &mut x63, x42, 0xffffffff); + let mut x64: u32 = 0; + let mut x65: u32 = 0; + fiat_sm2_mulx_u32(&mut x64, &mut x65, x42, 0xffffffff); + let mut x66: u32 = 0; + let mut x67: u32 = 0; + fiat_sm2_mulx_u32(&mut x66, &mut x67, x42, 0xffffffff); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_sm2_mulx_u32(&mut x68, &mut x69, x42, 0xffffffff); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_sm2_mulx_u32(&mut x70, &mut x71, x42, 0xffffffff); + let mut x72: u32 = 0; + let mut x73: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x72, &mut x73, 0x0, x71, x68); + let mut x74: u32 = 0; + let mut x75: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x74, &mut x75, 0x0, x67, x64); + let mut x76: u32 = 0; + let mut x77: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x76, &mut x77, x75, x65, x62); + let mut x78: u32 = 0; + let mut x79: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x78, &mut x79, x77, x63, x60); + let mut x80: u32 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x80, &mut x81, x79, x61, x58); + let mut x82: u32 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x82, &mut x83, 0x0, x42, x70); + let mut x84: u32 = 0; + let mut x85: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x84, &mut x85, x83, x44, x72); + let mut x86: u32 = 0; + let mut x87: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x86, &mut x87, x85, x46, ((x73 as u32) + x69)); + let mut x88: u32 = 0; + let mut x89: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x88, &mut x89, x87, x48, x66); + let mut x90: u32 = 0; + let mut x91: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x90, &mut x91, x89, x50, x74); + let mut x92: u32 = 0; + let mut x93: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x92, &mut x93, x91, x52, x76); + let mut x94: u32 = 0; + let mut x95: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x94, &mut x95, x93, x54, x78); + let mut x96: u32 = 0; + let mut x97: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x96, &mut x97, x95, x56, x80); + let mut x98: u32 = 0; + let mut x99: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x98, &mut x99, x97, (x57 as u32), ((x81 as u32) + x59)); + let mut x100: u32 = 0; + let mut x101: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x100, &mut x101, 0x0, x84, (arg1[2])); + let mut x102: u32 = 0; + let mut x103: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x102, &mut x103, x101, x86, (0x0 as u32)); + let mut x104: u32 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x104, &mut x105, x103, x88, (0x0 as u32)); + let mut x106: u32 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x106, &mut x107, x105, x90, (0x0 as u32)); + let mut x108: u32 = 0; + let mut x109: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x108, &mut x109, x107, x92, (0x0 as u32)); + let mut x110: u32 = 0; + let mut x111: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x110, &mut x111, x109, x94, (0x0 as u32)); + let mut x112: u32 = 0; + let mut x113: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x112, &mut x113, x111, x96, (0x0 as u32)); + let mut x114: u32 = 0; + let mut x115: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x114, &mut x115, x113, x98, (0x0 as u32)); + let mut x116: u32 = 0; + let mut x117: u32 = 0; + fiat_sm2_mulx_u32(&mut x116, &mut x117, x100, 0xfffffffe); + let mut x118: u32 = 0; + let mut x119: u32 = 0; + fiat_sm2_mulx_u32(&mut x118, &mut x119, x100, 0xffffffff); + let mut x120: u32 = 0; + let mut x121: u32 = 0; + fiat_sm2_mulx_u32(&mut x120, &mut x121, x100, 0xffffffff); + let mut x122: u32 = 0; + let mut x123: u32 = 0; + fiat_sm2_mulx_u32(&mut x122, &mut x123, x100, 0xffffffff); + let mut x124: u32 = 0; + let mut x125: u32 = 0; + fiat_sm2_mulx_u32(&mut x124, &mut x125, x100, 0xffffffff); + let mut x126: u32 = 0; + let mut x127: u32 = 0; + fiat_sm2_mulx_u32(&mut x126, &mut x127, x100, 0xffffffff); + let mut x128: u32 = 0; + let mut x129: u32 = 0; + fiat_sm2_mulx_u32(&mut x128, &mut x129, x100, 0xffffffff); + let mut x130: u32 = 0; + let mut x131: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x130, &mut x131, 0x0, x129, x126); + let mut x132: u32 = 0; + let mut x133: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x132, &mut x133, 0x0, x125, x122); + let mut x134: u32 = 0; + let mut x135: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x134, &mut x135, x133, x123, x120); + let mut x136: u32 = 0; + let mut x137: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x136, &mut x137, x135, x121, x118); + let mut x138: u32 = 0; + let mut x139: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x138, &mut x139, x137, x119, x116); + let mut x140: u32 = 0; + let mut x141: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x140, &mut x141, 0x0, x100, x128); + let mut x142: u32 = 0; + let mut x143: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x142, &mut x143, x141, x102, x130); + let mut x144: u32 = 0; + let mut x145: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x144, &mut x145, x143, x104, ((x131 as u32) + x127)); + let mut x146: u32 = 0; + let mut x147: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x146, &mut x147, x145, x106, x124); + let mut x148: u32 = 0; + let mut x149: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x148, &mut x149, x147, x108, x132); + let mut x150: u32 = 0; + let mut x151: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x150, &mut x151, x149, x110, x134); + let mut x152: u32 = 0; + let mut x153: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x152, &mut x153, x151, x112, x136); + let mut x154: u32 = 0; + let mut x155: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x154, &mut x155, x153, x114, x138); + let mut x156: u32 = 0; + let mut x157: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x156, &mut x157, x155, ((x115 as u32) + (x99 as u32)), ((x139 as u32) + x117)); + let mut x158: u32 = 0; + let mut x159: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x158, &mut x159, 0x0, x142, (arg1[3])); + let mut x160: u32 = 0; + let mut x161: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x160, &mut x161, x159, x144, (0x0 as u32)); + let mut x162: u32 = 0; + let mut x163: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x162, &mut x163, x161, x146, (0x0 as u32)); + let mut x164: u32 = 0; + let mut x165: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x164, &mut x165, x163, x148, (0x0 as u32)); + let mut x166: u32 = 0; + let mut x167: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x166, &mut x167, x165, x150, (0x0 as u32)); + let mut x168: u32 = 0; + let mut x169: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x168, &mut x169, x167, x152, (0x0 as u32)); + let mut x170: u32 = 0; + let mut x171: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x170, &mut x171, x169, x154, (0x0 as u32)); + let mut x172: u32 = 0; + let mut x173: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x172, &mut x173, x171, x156, (0x0 as u32)); + let mut x174: u32 = 0; + let mut x175: u32 = 0; + fiat_sm2_mulx_u32(&mut x174, &mut x175, x158, 0xfffffffe); + let mut x176: u32 = 0; + let mut x177: u32 = 0; + fiat_sm2_mulx_u32(&mut x176, &mut x177, x158, 0xffffffff); + let mut x178: u32 = 0; + let mut x179: u32 = 0; + fiat_sm2_mulx_u32(&mut x178, &mut x179, x158, 0xffffffff); + let mut x180: u32 = 0; + let mut x181: u32 = 0; + fiat_sm2_mulx_u32(&mut x180, &mut x181, x158, 0xffffffff); + let mut x182: u32 = 0; + let mut x183: u32 = 0; + fiat_sm2_mulx_u32(&mut x182, &mut x183, x158, 0xffffffff); + let mut x184: u32 = 0; + let mut x185: u32 = 0; + fiat_sm2_mulx_u32(&mut x184, &mut x185, x158, 0xffffffff); + let mut x186: u32 = 0; + let mut x187: u32 = 0; + fiat_sm2_mulx_u32(&mut x186, &mut x187, x158, 0xffffffff); + let mut x188: u32 = 0; + let mut x189: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u32 = 0; + let mut x191: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x190, &mut x191, 0x0, x183, x180); + let mut x192: u32 = 0; + let mut x193: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x192, &mut x193, x191, x181, x178); + let mut x194: u32 = 0; + let mut x195: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x194, &mut x195, x193, x179, x176); + let mut x196: u32 = 0; + let mut x197: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x196, &mut x197, x195, x177, x174); + let mut x198: u32 = 0; + let mut x199: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x198, &mut x199, 0x0, x158, x186); + let mut x200: u32 = 0; + let mut x201: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x200, &mut x201, x199, x160, x188); + let mut x202: u32 = 0; + let mut x203: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x202, &mut x203, x201, x162, ((x189 as u32) + x185)); + let mut x204: u32 = 0; + let mut x205: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x204, &mut x205, x203, x164, x182); + let mut x206: u32 = 0; + let mut x207: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x206, &mut x207, x205, x166, x190); + let mut x208: u32 = 0; + let mut x209: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x208, &mut x209, x207, x168, x192); + let mut x210: u32 = 0; + let mut x211: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x210, &mut x211, x209, x170, x194); + let mut x212: u32 = 0; + let mut x213: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x212, &mut x213, x211, x172, x196); + let mut x214: u32 = 0; + let mut x215: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x214, &mut x215, x213, ((x173 as u32) + (x157 as u32)), ((x197 as u32) + x175)); + let mut x216: u32 = 0; + let mut x217: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x216, &mut x217, 0x0, x200, (arg1[4])); + let mut x218: u32 = 0; + let mut x219: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x218, &mut x219, x217, x202, (0x0 as u32)); + let mut x220: u32 = 0; + let mut x221: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x220, &mut x221, x219, x204, (0x0 as u32)); + let mut x222: u32 = 0; + let mut x223: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x222, &mut x223, x221, x206, (0x0 as u32)); + let mut x224: u32 = 0; + let mut x225: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x224, &mut x225, x223, x208, (0x0 as u32)); + let mut x226: u32 = 0; + let mut x227: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x226, &mut x227, x225, x210, (0x0 as u32)); + let mut x228: u32 = 0; + let mut x229: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x228, &mut x229, x227, x212, (0x0 as u32)); + let mut x230: u32 = 0; + let mut x231: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x230, &mut x231, x229, x214, (0x0 as u32)); + let mut x232: u32 = 0; + let mut x233: u32 = 0; + fiat_sm2_mulx_u32(&mut x232, &mut x233, x216, 0xfffffffe); + let mut x234: u32 = 0; + let mut x235: u32 = 0; + fiat_sm2_mulx_u32(&mut x234, &mut x235, x216, 0xffffffff); + let mut x236: u32 = 0; + let mut x237: u32 = 0; + fiat_sm2_mulx_u32(&mut x236, &mut x237, x216, 0xffffffff); + let mut x238: u32 = 0; + let mut x239: u32 = 0; + fiat_sm2_mulx_u32(&mut x238, &mut x239, x216, 0xffffffff); + let mut x240: u32 = 0; + let mut x241: u32 = 0; + fiat_sm2_mulx_u32(&mut x240, &mut x241, x216, 0xffffffff); + let mut x242: u32 = 0; + let mut x243: u32 = 0; + fiat_sm2_mulx_u32(&mut x242, &mut x243, x216, 0xffffffff); + let mut x244: u32 = 0; + let mut x245: u32 = 0; + fiat_sm2_mulx_u32(&mut x244, &mut x245, x216, 0xffffffff); + let mut x246: u32 = 0; + let mut x247: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x246, &mut x247, 0x0, x245, x242); + let mut x248: u32 = 0; + let mut x249: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x248, &mut x249, 0x0, x241, x238); + let mut x250: u32 = 0; + let mut x251: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x250, &mut x251, x249, x239, x236); + let mut x252: u32 = 0; + let mut x253: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x252, &mut x253, x251, x237, x234); + let mut x254: u32 = 0; + let mut x255: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x254, &mut x255, x253, x235, x232); + let mut x256: u32 = 0; + let mut x257: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x256, &mut x257, 0x0, x216, x244); + let mut x258: u32 = 0; + let mut x259: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x258, &mut x259, x257, x218, x246); + let mut x260: u32 = 0; + let mut x261: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x260, &mut x261, x259, x220, ((x247 as u32) + x243)); + let mut x262: u32 = 0; + let mut x263: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x262, &mut x263, x261, x222, x240); + let mut x264: u32 = 0; + let mut x265: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x264, &mut x265, x263, x224, x248); + let mut x266: u32 = 0; + let mut x267: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x266, &mut x267, x265, x226, x250); + let mut x268: u32 = 0; + let mut x269: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x268, &mut x269, x267, x228, x252); + let mut x270: u32 = 0; + let mut x271: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x270, &mut x271, x269, x230, x254); + let mut x272: u32 = 0; + let mut x273: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x272, &mut x273, x271, ((x231 as u32) + (x215 as u32)), ((x255 as u32) + x233)); + let mut x274: u32 = 0; + let mut x275: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x274, &mut x275, 0x0, x258, (arg1[5])); + let mut x276: u32 = 0; + let mut x277: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x276, &mut x277, x275, x260, (0x0 as u32)); + let mut x278: u32 = 0; + let mut x279: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x278, &mut x279, x277, x262, (0x0 as u32)); + let mut x280: u32 = 0; + let mut x281: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x280, &mut x281, x279, x264, (0x0 as u32)); + let mut x282: u32 = 0; + let mut x283: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x282, &mut x283, x281, x266, (0x0 as u32)); + let mut x284: u32 = 0; + let mut x285: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x284, &mut x285, x283, x268, (0x0 as u32)); + let mut x286: u32 = 0; + let mut x287: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x286, &mut x287, x285, x270, (0x0 as u32)); + let mut x288: u32 = 0; + let mut x289: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x288, &mut x289, x287, x272, (0x0 as u32)); + let mut x290: u32 = 0; + let mut x291: u32 = 0; + fiat_sm2_mulx_u32(&mut x290, &mut x291, x274, 0xfffffffe); + let mut x292: u32 = 0; + let mut x293: u32 = 0; + fiat_sm2_mulx_u32(&mut x292, &mut x293, x274, 0xffffffff); + let mut x294: u32 = 0; + let mut x295: u32 = 0; + fiat_sm2_mulx_u32(&mut x294, &mut x295, x274, 0xffffffff); + let mut x296: u32 = 0; + let mut x297: u32 = 0; + fiat_sm2_mulx_u32(&mut x296, &mut x297, x274, 0xffffffff); + let mut x298: u32 = 0; + let mut x299: u32 = 0; + fiat_sm2_mulx_u32(&mut x298, &mut x299, x274, 0xffffffff); + let mut x300: u32 = 0; + let mut x301: u32 = 0; + fiat_sm2_mulx_u32(&mut x300, &mut x301, x274, 0xffffffff); + let mut x302: u32 = 0; + let mut x303: u32 = 0; + fiat_sm2_mulx_u32(&mut x302, &mut x303, x274, 0xffffffff); + let mut x304: u32 = 0; + let mut x305: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x304, &mut x305, 0x0, x303, x300); + let mut x306: u32 = 0; + let mut x307: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x306, &mut x307, 0x0, x299, x296); + let mut x308: u32 = 0; + let mut x309: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x308, &mut x309, x307, x297, x294); + let mut x310: u32 = 0; + let mut x311: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x310, &mut x311, x309, x295, x292); + let mut x312: u32 = 0; + let mut x313: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x312, &mut x313, x311, x293, x290); + let mut x314: u32 = 0; + let mut x315: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x314, &mut x315, 0x0, x274, x302); + let mut x316: u32 = 0; + let mut x317: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x316, &mut x317, x315, x276, x304); + let mut x318: u32 = 0; + let mut x319: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x318, &mut x319, x317, x278, ((x305 as u32) + x301)); + let mut x320: u32 = 0; + let mut x321: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x320, &mut x321, x319, x280, x298); + let mut x322: u32 = 0; + let mut x323: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x322, &mut x323, x321, x282, x306); + let mut x324: u32 = 0; + let mut x325: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x324, &mut x325, x323, x284, x308); + let mut x326: u32 = 0; + let mut x327: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x326, &mut x327, x325, x286, x310); + let mut x328: u32 = 0; + let mut x329: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x328, &mut x329, x327, x288, x312); + let mut x330: u32 = 0; + let mut x331: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x330, &mut x331, x329, ((x289 as u32) + (x273 as u32)), ((x313 as u32) + x291)); + let mut x332: u32 = 0; + let mut x333: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x332, &mut x333, 0x0, x316, (arg1[6])); + let mut x334: u32 = 0; + let mut x335: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x334, &mut x335, x333, x318, (0x0 as u32)); + let mut x336: u32 = 0; + let mut x337: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x336, &mut x337, x335, x320, (0x0 as u32)); + let mut x338: u32 = 0; + let mut x339: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x338, &mut x339, x337, x322, (0x0 as u32)); + let mut x340: u32 = 0; + let mut x341: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x340, &mut x341, x339, x324, (0x0 as u32)); + let mut x342: u32 = 0; + let mut x343: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x342, &mut x343, x341, x326, (0x0 as u32)); + let mut x344: u32 = 0; + let mut x345: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x344, &mut x345, x343, x328, (0x0 as u32)); + let mut x346: u32 = 0; + let mut x347: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x346, &mut x347, x345, x330, (0x0 as u32)); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_sm2_mulx_u32(&mut x348, &mut x349, x332, 0xfffffffe); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_sm2_mulx_u32(&mut x350, &mut x351, x332, 0xffffffff); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_sm2_mulx_u32(&mut x352, &mut x353, x332, 0xffffffff); + let mut x354: u32 = 0; + let mut x355: u32 = 0; + fiat_sm2_mulx_u32(&mut x354, &mut x355, x332, 0xffffffff); + let mut x356: u32 = 0; + let mut x357: u32 = 0; + fiat_sm2_mulx_u32(&mut x356, &mut x357, x332, 0xffffffff); + let mut x358: u32 = 0; + let mut x359: u32 = 0; + fiat_sm2_mulx_u32(&mut x358, &mut x359, x332, 0xffffffff); + let mut x360: u32 = 0; + let mut x361: u32 = 0; + fiat_sm2_mulx_u32(&mut x360, &mut x361, x332, 0xffffffff); + let mut x362: u32 = 0; + let mut x363: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x362, &mut x363, 0x0, x361, x358); + let mut x364: u32 = 0; + let mut x365: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x364, &mut x365, 0x0, x357, x354); + let mut x366: u32 = 0; + let mut x367: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x366, &mut x367, x365, x355, x352); + let mut x368: u32 = 0; + let mut x369: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x368, &mut x369, x367, x353, x350); + let mut x370: u32 = 0; + let mut x371: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x370, &mut x371, x369, x351, x348); + let mut x372: u32 = 0; + let mut x373: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x372, &mut x373, 0x0, x332, x360); + let mut x374: u32 = 0; + let mut x375: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x374, &mut x375, x373, x334, x362); + let mut x376: u32 = 0; + let mut x377: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x376, &mut x377, x375, x336, ((x363 as u32) + x359)); + let mut x378: u32 = 0; + let mut x379: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x378, &mut x379, x377, x338, x356); + let mut x380: u32 = 0; + let mut x381: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x380, &mut x381, x379, x340, x364); + let mut x382: u32 = 0; + let mut x383: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x382, &mut x383, x381, x342, x366); + let mut x384: u32 = 0; + let mut x385: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x384, &mut x385, x383, x344, x368); + let mut x386: u32 = 0; + let mut x387: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x386, &mut x387, x385, x346, x370); + let mut x388: u32 = 0; + let mut x389: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x388, &mut x389, x387, ((x347 as u32) + (x331 as u32)), ((x371 as u32) + x349)); + let mut x390: u32 = 0; + let mut x391: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x390, &mut x391, 0x0, x374, (arg1[7])); + let mut x392: u32 = 0; + let mut x393: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x392, &mut x393, x391, x376, (0x0 as u32)); + let mut x394: u32 = 0; + let mut x395: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x394, &mut x395, x393, x378, (0x0 as u32)); + let mut x396: u32 = 0; + let mut x397: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x396, &mut x397, x395, x380, (0x0 as u32)); + let mut x398: u32 = 0; + let mut x399: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x398, &mut x399, x397, x382, (0x0 as u32)); + let mut x400: u32 = 0; + let mut x401: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x400, &mut x401, x399, x384, (0x0 as u32)); + let mut x402: u32 = 0; + let mut x403: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x402, &mut x403, x401, x386, (0x0 as u32)); + let mut x404: u32 = 0; + let mut x405: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x404, &mut x405, x403, x388, (0x0 as u32)); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_sm2_mulx_u32(&mut x406, &mut x407, x390, 0xfffffffe); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_sm2_mulx_u32(&mut x408, &mut x409, x390, 0xffffffff); + let mut x410: u32 = 0; + let mut x411: u32 = 0; + fiat_sm2_mulx_u32(&mut x410, &mut x411, x390, 0xffffffff); + let mut x412: u32 = 0; + let mut x413: u32 = 0; + fiat_sm2_mulx_u32(&mut x412, &mut x413, x390, 0xffffffff); + let mut x414: u32 = 0; + let mut x415: u32 = 0; + fiat_sm2_mulx_u32(&mut x414, &mut x415, x390, 0xffffffff); + let mut x416: u32 = 0; + let mut x417: u32 = 0; + fiat_sm2_mulx_u32(&mut x416, &mut x417, x390, 0xffffffff); + let mut x418: u32 = 0; + let mut x419: u32 = 0; + fiat_sm2_mulx_u32(&mut x418, &mut x419, x390, 0xffffffff); + let mut x420: u32 = 0; + let mut x421: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x420, &mut x421, 0x0, x419, x416); + let mut x422: u32 = 0; + let mut x423: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x422, &mut x423, 0x0, x415, x412); + let mut x424: u32 = 0; + let mut x425: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x424, &mut x425, x423, x413, x410); + let mut x426: u32 = 0; + let mut x427: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x426, &mut x427, x425, x411, x408); + let mut x428: u32 = 0; + let mut x429: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x428, &mut x429, x427, x409, x406); + let mut x430: u32 = 0; + let mut x431: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x430, &mut x431, 0x0, x390, x418); + let mut x432: u32 = 0; + let mut x433: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x432, &mut x433, x431, x392, x420); + let mut x434: u32 = 0; + let mut x435: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x434, &mut x435, x433, x394, ((x421 as u32) + x417)); + let mut x436: u32 = 0; + let mut x437: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x436, &mut x437, x435, x396, x414); + let mut x438: u32 = 0; + let mut x439: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x438, &mut x439, x437, x398, x422); + let mut x440: u32 = 0; + let mut x441: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x440, &mut x441, x439, x400, x424); + let mut x442: u32 = 0; + let mut x443: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x442, &mut x443, x441, x402, x426); + let mut x444: u32 = 0; + let mut x445: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x444, &mut x445, x443, x404, x428); + let mut x446: u32 = 0; + let mut x447: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x446, &mut x447, x445, ((x405 as u32) + (x389 as u32)), ((x429 as u32) + x407)); + let mut x448: u32 = 0; + let mut x449: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x448, &mut x449, 0x0, x432, 0xffffffff); + let mut x450: u32 = 0; + let mut x451: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x450, &mut x451, x449, x434, 0xffffffff); + let mut x452: u32 = 0; + let mut x453: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x452, &mut x453, x451, x436, (0x0 as u32)); + let mut x454: u32 = 0; + let mut x455: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x454, &mut x455, x453, x438, 0xffffffff); + let mut x456: u32 = 0; + let mut x457: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x456, &mut x457, x455, x440, 0xffffffff); + let mut x458: u32 = 0; + let mut x459: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x458, &mut x459, x457, x442, 0xffffffff); + let mut x460: u32 = 0; + let mut x461: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x460, &mut x461, x459, x444, 0xffffffff); + let mut x462: u32 = 0; + let mut x463: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x462, &mut x463, x461, x446, 0xfffffffe); + let mut x464: u32 = 0; + let mut x465: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x464, &mut x465, x463, (x447 as u32), (0x0 as u32)); + let mut x466: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x466, x465, x448, x432); + let mut x467: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x467, x465, x450, x434); + let mut x468: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x468, x465, x452, x436); + let mut x469: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x469, x465, x454, x438); + let mut x470: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x470, x465, x456, x440); + let mut x471: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x471, x465, x458, x442); + let mut x472: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x472, x465, x460, x444); + let mut x473: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x473, x465, x462, x446); + out1[0] = x466; + out1[1] = x467; + out1[2] = x468; + out1[3] = x469; + out1[4] = x470; + out1[5] = x471; + out1[6] = x472; + out1[7] = x473; +} + +/// The function fiat_sm2_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_sm2_to_montgomery(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_mulx_u32(&mut x9, &mut x10, x8, 0x4); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_sm2_mulx_u32(&mut x11, &mut x12, x8, 0x2); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_sm2_mulx_u32(&mut x13, &mut x14, x8, 0x2); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_sm2_mulx_u32(&mut x15, &mut x16, x8, 0xffffffff); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_sm2_mulx_u32(&mut x17, &mut x18, x8, 0x2); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_sm2_mulx_u32(&mut x19, &mut x20, x8, 0x3); + let mut x21: u32 = 0; + let mut x22: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x21, &mut x22, 0x0, x20, x17); + let mut x23: u32 = 0; + let mut x24: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x23, &mut x24, x22, ((x18 as fiat_sm2_u1) as u32), x15); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x25, &mut x26, x24, x16, x13); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x27, &mut x28, x26, ((x14 as fiat_sm2_u1) as u32), x8); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x29, &mut x30, x28, (0x0 as u32), x8); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x31, &mut x32, x30, (0x0 as u32), x11); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x33, &mut x34, x32, ((x12 as fiat_sm2_u1) as u32), x9); + let mut x35: u32 = 0; + let mut x36: u32 = 0; + fiat_sm2_mulx_u32(&mut x35, &mut x36, x19, 0xfffffffe); + let mut x37: u32 = 0; + let mut x38: u32 = 0; + fiat_sm2_mulx_u32(&mut x37, &mut x38, x19, 0xffffffff); + let mut x39: u32 = 0; + let mut x40: u32 = 0; + fiat_sm2_mulx_u32(&mut x39, &mut x40, x19, 0xffffffff); + let mut x41: u32 = 0; + let mut x42: u32 = 0; + fiat_sm2_mulx_u32(&mut x41, &mut x42, x19, 0xffffffff); + let mut x43: u32 = 0; + let mut x44: u32 = 0; + fiat_sm2_mulx_u32(&mut x43, &mut x44, x19, 0xffffffff); + let mut x45: u32 = 0; + let mut x46: u32 = 0; + fiat_sm2_mulx_u32(&mut x45, &mut x46, x19, 0xffffffff); + let mut x47: u32 = 0; + let mut x48: u32 = 0; + fiat_sm2_mulx_u32(&mut x47, &mut x48, x19, 0xffffffff); + let mut x49: u32 = 0; + let mut x50: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x49, &mut x50, 0x0, x48, x45); + let mut x51: u32 = 0; + let mut x52: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x51, &mut x52, 0x0, x44, x41); + let mut x53: u32 = 0; + let mut x54: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x53, &mut x54, x52, x42, x39); + let mut x55: u32 = 0; + let mut x56: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x55, &mut x56, x54, x40, x37); + let mut x57: u32 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x57, &mut x58, x56, x38, x35); + let mut x59: u32 = 0; + let mut x60: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x59, &mut x60, 0x0, x19, x47); + let mut x61: u32 = 0; + let mut x62: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x61, &mut x62, x60, x21, x49); + let mut x63: u32 = 0; + let mut x64: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x63, &mut x64, x62, x23, ((x50 as u32) + x46)); + let mut x65: u32 = 0; + let mut x66: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x65, &mut x66, x64, x25, x43); + let mut x67: u32 = 0; + let mut x68: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x67, &mut x68, x66, x27, x51); + let mut x69: u32 = 0; + let mut x70: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x69, &mut x70, x68, x29, x53); + let mut x71: u32 = 0; + let mut x72: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x71, &mut x72, x70, x31, x55); + let mut x73: u32 = 0; + let mut x74: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x73, &mut x74, x72, x33, x57); + let mut x75: u32 = 0; + let mut x76: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x75, &mut x76, x74, ((x34 as u32) + x10), ((x58 as u32) + x36)); + let mut x77: u32 = 0; + let mut x78: u32 = 0; + fiat_sm2_mulx_u32(&mut x77, &mut x78, x1, 0x4); + let mut x79: u32 = 0; + let mut x80: u32 = 0; + fiat_sm2_mulx_u32(&mut x79, &mut x80, x1, 0x2); + let mut x81: u32 = 0; + let mut x82: u32 = 0; + fiat_sm2_mulx_u32(&mut x81, &mut x82, x1, 0x2); + let mut x83: u32 = 0; + let mut x84: u32 = 0; + fiat_sm2_mulx_u32(&mut x83, &mut x84, x1, 0xffffffff); + let mut x85: u32 = 0; + let mut x86: u32 = 0; + fiat_sm2_mulx_u32(&mut x85, &mut x86, x1, 0x2); + let mut x87: u32 = 0; + let mut x88: u32 = 0; + fiat_sm2_mulx_u32(&mut x87, &mut x88, x1, 0x3); + let mut x89: u32 = 0; + let mut x90: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x89, &mut x90, 0x0, x88, x85); + let mut x91: u32 = 0; + let mut x92: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x91, &mut x92, x90, ((x86 as fiat_sm2_u1) as u32), x83); + let mut x93: u32 = 0; + let mut x94: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x93, &mut x94, x92, x84, x81); + let mut x95: u32 = 0; + let mut x96: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x95, &mut x96, x94, ((x82 as fiat_sm2_u1) as u32), x1); + let mut x97: u32 = 0; + let mut x98: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x97, &mut x98, x96, (0x0 as u32), x1); + let mut x99: u32 = 0; + let mut x100: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x99, &mut x100, x98, (0x0 as u32), x79); + let mut x101: u32 = 0; + let mut x102: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x101, &mut x102, x100, ((x80 as fiat_sm2_u1) as u32), x77); + let mut x103: u32 = 0; + let mut x104: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x103, &mut x104, 0x0, x61, x87); + let mut x105: u32 = 0; + let mut x106: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x105, &mut x106, x104, x63, x89); + let mut x107: u32 = 0; + let mut x108: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x107, &mut x108, x106, x65, x91); + let mut x109: u32 = 0; + let mut x110: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x109, &mut x110, x108, x67, x93); + let mut x111: u32 = 0; + let mut x112: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x111, &mut x112, x110, x69, x95); + let mut x113: u32 = 0; + let mut x114: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x113, &mut x114, x112, x71, x97); + let mut x115: u32 = 0; + let mut x116: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x115, &mut x116, x114, x73, x99); + let mut x117: u32 = 0; + let mut x118: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x117, &mut x118, x116, x75, x101); + let mut x119: u32 = 0; + let mut x120: u32 = 0; + fiat_sm2_mulx_u32(&mut x119, &mut x120, x103, 0xfffffffe); + let mut x121: u32 = 0; + let mut x122: u32 = 0; + fiat_sm2_mulx_u32(&mut x121, &mut x122, x103, 0xffffffff); + let mut x123: u32 = 0; + let mut x124: u32 = 0; + fiat_sm2_mulx_u32(&mut x123, &mut x124, x103, 0xffffffff); + let mut x125: u32 = 0; + let mut x126: u32 = 0; + fiat_sm2_mulx_u32(&mut x125, &mut x126, x103, 0xffffffff); + let mut x127: u32 = 0; + let mut x128: u32 = 0; + fiat_sm2_mulx_u32(&mut x127, &mut x128, x103, 0xffffffff); + let mut x129: u32 = 0; + let mut x130: u32 = 0; + fiat_sm2_mulx_u32(&mut x129, &mut x130, x103, 0xffffffff); + let mut x131: u32 = 0; + let mut x132: u32 = 0; + fiat_sm2_mulx_u32(&mut x131, &mut x132, x103, 0xffffffff); + let mut x133: u32 = 0; + let mut x134: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x133, &mut x134, 0x0, x132, x129); + let mut x135: u32 = 0; + let mut x136: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x135, &mut x136, 0x0, x128, x125); + let mut x137: u32 = 0; + let mut x138: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x137, &mut x138, x136, x126, x123); + let mut x139: u32 = 0; + let mut x140: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x139, &mut x140, x138, x124, x121); + let mut x141: u32 = 0; + let mut x142: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x141, &mut x142, x140, x122, x119); + let mut x143: u32 = 0; + let mut x144: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x143, &mut x144, 0x0, x103, x131); + let mut x145: u32 = 0; + let mut x146: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x145, &mut x146, x144, x105, x133); + let mut x147: u32 = 0; + let mut x148: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x147, &mut x148, x146, x107, ((x134 as u32) + x130)); + let mut x149: u32 = 0; + let mut x150: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x149, &mut x150, x148, x109, x127); + let mut x151: u32 = 0; + let mut x152: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x151, &mut x152, x150, x111, x135); + let mut x153: u32 = 0; + let mut x154: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x153, &mut x154, x152, x113, x137); + let mut x155: u32 = 0; + let mut x156: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x155, &mut x156, x154, x115, x139); + let mut x157: u32 = 0; + let mut x158: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x157, &mut x158, x156, x117, x141); + let mut x159: u32 = 0; + let mut x160: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x159, &mut x160, x158, (((x118 as u32) + (x76 as u32)) + ((x102 as u32) + x78)), ((x142 as u32) + x120)); + let mut x161: u32 = 0; + let mut x162: u32 = 0; + fiat_sm2_mulx_u32(&mut x161, &mut x162, x2, 0x4); + let mut x163: u32 = 0; + let mut x164: u32 = 0; + fiat_sm2_mulx_u32(&mut x163, &mut x164, x2, 0x2); + let mut x165: u32 = 0; + let mut x166: u32 = 0; + fiat_sm2_mulx_u32(&mut x165, &mut x166, x2, 0x2); + let mut x167: u32 = 0; + let mut x168: u32 = 0; + fiat_sm2_mulx_u32(&mut x167, &mut x168, x2, 0xffffffff); + let mut x169: u32 = 0; + let mut x170: u32 = 0; + fiat_sm2_mulx_u32(&mut x169, &mut x170, x2, 0x2); + let mut x171: u32 = 0; + let mut x172: u32 = 0; + fiat_sm2_mulx_u32(&mut x171, &mut x172, x2, 0x3); + let mut x173: u32 = 0; + let mut x174: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x173, &mut x174, 0x0, x172, x169); + let mut x175: u32 = 0; + let mut x176: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x175, &mut x176, x174, ((x170 as fiat_sm2_u1) as u32), x167); + let mut x177: u32 = 0; + let mut x178: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x177, &mut x178, x176, x168, x165); + let mut x179: u32 = 0; + let mut x180: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x179, &mut x180, x178, ((x166 as fiat_sm2_u1) as u32), x2); + let mut x181: u32 = 0; + let mut x182: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x181, &mut x182, x180, (0x0 as u32), x2); + let mut x183: u32 = 0; + let mut x184: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x183, &mut x184, x182, (0x0 as u32), x163); + let mut x185: u32 = 0; + let mut x186: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x185, &mut x186, x184, ((x164 as fiat_sm2_u1) as u32), x161); + let mut x187: u32 = 0; + let mut x188: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x187, &mut x188, 0x0, x145, x171); + let mut x189: u32 = 0; + let mut x190: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x189, &mut x190, x188, x147, x173); + let mut x191: u32 = 0; + let mut x192: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x191, &mut x192, x190, x149, x175); + let mut x193: u32 = 0; + let mut x194: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x193, &mut x194, x192, x151, x177); + let mut x195: u32 = 0; + let mut x196: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x195, &mut x196, x194, x153, x179); + let mut x197: u32 = 0; + let mut x198: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x197, &mut x198, x196, x155, x181); + let mut x199: u32 = 0; + let mut x200: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x199, &mut x200, x198, x157, x183); + let mut x201: u32 = 0; + let mut x202: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x201, &mut x202, x200, x159, x185); + let mut x203: u32 = 0; + let mut x204: u32 = 0; + fiat_sm2_mulx_u32(&mut x203, &mut x204, x187, 0xfffffffe); + let mut x205: u32 = 0; + let mut x206: u32 = 0; + fiat_sm2_mulx_u32(&mut x205, &mut x206, x187, 0xffffffff); + let mut x207: u32 = 0; + let mut x208: u32 = 0; + fiat_sm2_mulx_u32(&mut x207, &mut x208, x187, 0xffffffff); + let mut x209: u32 = 0; + let mut x210: u32 = 0; + fiat_sm2_mulx_u32(&mut x209, &mut x210, x187, 0xffffffff); + let mut x211: u32 = 0; + let mut x212: u32 = 0; + fiat_sm2_mulx_u32(&mut x211, &mut x212, x187, 0xffffffff); + let mut x213: u32 = 0; + let mut x214: u32 = 0; + fiat_sm2_mulx_u32(&mut x213, &mut x214, x187, 0xffffffff); + let mut x215: u32 = 0; + let mut x216: u32 = 0; + fiat_sm2_mulx_u32(&mut x215, &mut x216, x187, 0xffffffff); + let mut x217: u32 = 0; + let mut x218: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x217, &mut x218, 0x0, x216, x213); + let mut x219: u32 = 0; + let mut x220: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x219, &mut x220, 0x0, x212, x209); + let mut x221: u32 = 0; + let mut x222: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x221, &mut x222, x220, x210, x207); + let mut x223: u32 = 0; + let mut x224: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x223, &mut x224, x222, x208, x205); + let mut x225: u32 = 0; + let mut x226: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x225, &mut x226, x224, x206, x203); + let mut x227: u32 = 0; + let mut x228: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x227, &mut x228, 0x0, x187, x215); + let mut x229: u32 = 0; + let mut x230: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x229, &mut x230, x228, x189, x217); + let mut x231: u32 = 0; + let mut x232: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x231, &mut x232, x230, x191, ((x218 as u32) + x214)); + let mut x233: u32 = 0; + let mut x234: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x233, &mut x234, x232, x193, x211); + let mut x235: u32 = 0; + let mut x236: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x235, &mut x236, x234, x195, x219); + let mut x237: u32 = 0; + let mut x238: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x237, &mut x238, x236, x197, x221); + let mut x239: u32 = 0; + let mut x240: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x239, &mut x240, x238, x199, x223); + let mut x241: u32 = 0; + let mut x242: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x241, &mut x242, x240, x201, x225); + let mut x243: u32 = 0; + let mut x244: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x243, &mut x244, x242, (((x202 as u32) + (x160 as u32)) + ((x186 as u32) + x162)), ((x226 as u32) + x204)); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_sm2_mulx_u32(&mut x245, &mut x246, x3, 0x4); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_sm2_mulx_u32(&mut x247, &mut x248, x3, 0x2); + let mut x249: u32 = 0; + let mut x250: u32 = 0; + fiat_sm2_mulx_u32(&mut x249, &mut x250, x3, 0x2); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_sm2_mulx_u32(&mut x251, &mut x252, x3, 0xffffffff); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_sm2_mulx_u32(&mut x253, &mut x254, x3, 0x2); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_sm2_mulx_u32(&mut x255, &mut x256, x3, 0x3); + let mut x257: u32 = 0; + let mut x258: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x257, &mut x258, 0x0, x256, x253); + let mut x259: u32 = 0; + let mut x260: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x259, &mut x260, x258, ((x254 as fiat_sm2_u1) as u32), x251); + let mut x261: u32 = 0; + let mut x262: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x261, &mut x262, x260, x252, x249); + let mut x263: u32 = 0; + let mut x264: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x263, &mut x264, x262, ((x250 as fiat_sm2_u1) as u32), x3); + let mut x265: u32 = 0; + let mut x266: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x265, &mut x266, x264, (0x0 as u32), x3); + let mut x267: u32 = 0; + let mut x268: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x267, &mut x268, x266, (0x0 as u32), x247); + let mut x269: u32 = 0; + let mut x270: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x269, &mut x270, x268, ((x248 as fiat_sm2_u1) as u32), x245); + let mut x271: u32 = 0; + let mut x272: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x271, &mut x272, 0x0, x229, x255); + let mut x273: u32 = 0; + let mut x274: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x273, &mut x274, x272, x231, x257); + let mut x275: u32 = 0; + let mut x276: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x275, &mut x276, x274, x233, x259); + let mut x277: u32 = 0; + let mut x278: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x277, &mut x278, x276, x235, x261); + let mut x279: u32 = 0; + let mut x280: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x279, &mut x280, x278, x237, x263); + let mut x281: u32 = 0; + let mut x282: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x281, &mut x282, x280, x239, x265); + let mut x283: u32 = 0; + let mut x284: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x283, &mut x284, x282, x241, x267); + let mut x285: u32 = 0; + let mut x286: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x285, &mut x286, x284, x243, x269); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_sm2_mulx_u32(&mut x287, &mut x288, x271, 0xfffffffe); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_sm2_mulx_u32(&mut x289, &mut x290, x271, 0xffffffff); + let mut x291: u32 = 0; + let mut x292: u32 = 0; + fiat_sm2_mulx_u32(&mut x291, &mut x292, x271, 0xffffffff); + let mut x293: u32 = 0; + let mut x294: u32 = 0; + fiat_sm2_mulx_u32(&mut x293, &mut x294, x271, 0xffffffff); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_sm2_mulx_u32(&mut x295, &mut x296, x271, 0xffffffff); + let mut x297: u32 = 0; + let mut x298: u32 = 0; + fiat_sm2_mulx_u32(&mut x297, &mut x298, x271, 0xffffffff); + let mut x299: u32 = 0; + let mut x300: u32 = 0; + fiat_sm2_mulx_u32(&mut x299, &mut x300, x271, 0xffffffff); + let mut x301: u32 = 0; + let mut x302: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x301, &mut x302, 0x0, x300, x297); + let mut x303: u32 = 0; + let mut x304: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x303, &mut x304, 0x0, x296, x293); + let mut x305: u32 = 0; + let mut x306: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x305, &mut x306, x304, x294, x291); + let mut x307: u32 = 0; + let mut x308: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x307, &mut x308, x306, x292, x289); + let mut x309: u32 = 0; + let mut x310: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x309, &mut x310, x308, x290, x287); + let mut x311: u32 = 0; + let mut x312: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x311, &mut x312, 0x0, x271, x299); + let mut x313: u32 = 0; + let mut x314: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x313, &mut x314, x312, x273, x301); + let mut x315: u32 = 0; + let mut x316: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x315, &mut x316, x314, x275, ((x302 as u32) + x298)); + let mut x317: u32 = 0; + let mut x318: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x317, &mut x318, x316, x277, x295); + let mut x319: u32 = 0; + let mut x320: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x319, &mut x320, x318, x279, x303); + let mut x321: u32 = 0; + let mut x322: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x321, &mut x322, x320, x281, x305); + let mut x323: u32 = 0; + let mut x324: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x323, &mut x324, x322, x283, x307); + let mut x325: u32 = 0; + let mut x326: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x325, &mut x326, x324, x285, x309); + let mut x327: u32 = 0; + let mut x328: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x327, &mut x328, x326, (((x286 as u32) + (x244 as u32)) + ((x270 as u32) + x246)), ((x310 as u32) + x288)); + let mut x329: u32 = 0; + let mut x330: u32 = 0; + fiat_sm2_mulx_u32(&mut x329, &mut x330, x4, 0x4); + let mut x331: u32 = 0; + let mut x332: u32 = 0; + fiat_sm2_mulx_u32(&mut x331, &mut x332, x4, 0x2); + let mut x333: u32 = 0; + let mut x334: u32 = 0; + fiat_sm2_mulx_u32(&mut x333, &mut x334, x4, 0x2); + let mut x335: u32 = 0; + let mut x336: u32 = 0; + fiat_sm2_mulx_u32(&mut x335, &mut x336, x4, 0xffffffff); + let mut x337: u32 = 0; + let mut x338: u32 = 0; + fiat_sm2_mulx_u32(&mut x337, &mut x338, x4, 0x2); + let mut x339: u32 = 0; + let mut x340: u32 = 0; + fiat_sm2_mulx_u32(&mut x339, &mut x340, x4, 0x3); + let mut x341: u32 = 0; + let mut x342: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x341, &mut x342, 0x0, x340, x337); + let mut x343: u32 = 0; + let mut x344: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x343, &mut x344, x342, ((x338 as fiat_sm2_u1) as u32), x335); + let mut x345: u32 = 0; + let mut x346: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x345, &mut x346, x344, x336, x333); + let mut x347: u32 = 0; + let mut x348: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x347, &mut x348, x346, ((x334 as fiat_sm2_u1) as u32), x4); + let mut x349: u32 = 0; + let mut x350: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x349, &mut x350, x348, (0x0 as u32), x4); + let mut x351: u32 = 0; + let mut x352: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x351, &mut x352, x350, (0x0 as u32), x331); + let mut x353: u32 = 0; + let mut x354: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x353, &mut x354, x352, ((x332 as fiat_sm2_u1) as u32), x329); + let mut x355: u32 = 0; + let mut x356: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x355, &mut x356, 0x0, x313, x339); + let mut x357: u32 = 0; + let mut x358: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x357, &mut x358, x356, x315, x341); + let mut x359: u32 = 0; + let mut x360: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x359, &mut x360, x358, x317, x343); + let mut x361: u32 = 0; + let mut x362: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x361, &mut x362, x360, x319, x345); + let mut x363: u32 = 0; + let mut x364: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x363, &mut x364, x362, x321, x347); + let mut x365: u32 = 0; + let mut x366: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x365, &mut x366, x364, x323, x349); + let mut x367: u32 = 0; + let mut x368: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x367, &mut x368, x366, x325, x351); + let mut x369: u32 = 0; + let mut x370: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x369, &mut x370, x368, x327, x353); + let mut x371: u32 = 0; + let mut x372: u32 = 0; + fiat_sm2_mulx_u32(&mut x371, &mut x372, x355, 0xfffffffe); + let mut x373: u32 = 0; + let mut x374: u32 = 0; + fiat_sm2_mulx_u32(&mut x373, &mut x374, x355, 0xffffffff); + let mut x375: u32 = 0; + let mut x376: u32 = 0; + fiat_sm2_mulx_u32(&mut x375, &mut x376, x355, 0xffffffff); + let mut x377: u32 = 0; + let mut x378: u32 = 0; + fiat_sm2_mulx_u32(&mut x377, &mut x378, x355, 0xffffffff); + let mut x379: u32 = 0; + let mut x380: u32 = 0; + fiat_sm2_mulx_u32(&mut x379, &mut x380, x355, 0xffffffff); + let mut x381: u32 = 0; + let mut x382: u32 = 0; + fiat_sm2_mulx_u32(&mut x381, &mut x382, x355, 0xffffffff); + let mut x383: u32 = 0; + let mut x384: u32 = 0; + fiat_sm2_mulx_u32(&mut x383, &mut x384, x355, 0xffffffff); + let mut x385: u32 = 0; + let mut x386: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x385, &mut x386, 0x0, x384, x381); + let mut x387: u32 = 0; + let mut x388: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x387, &mut x388, 0x0, x380, x377); + let mut x389: u32 = 0; + let mut x390: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x389, &mut x390, x388, x378, x375); + let mut x391: u32 = 0; + let mut x392: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x391, &mut x392, x390, x376, x373); + let mut x393: u32 = 0; + let mut x394: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x393, &mut x394, x392, x374, x371); + let mut x395: u32 = 0; + let mut x396: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x395, &mut x396, 0x0, x355, x383); + let mut x397: u32 = 0; + let mut x398: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x397, &mut x398, x396, x357, x385); + let mut x399: u32 = 0; + let mut x400: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x399, &mut x400, x398, x359, ((x386 as u32) + x382)); + let mut x401: u32 = 0; + let mut x402: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x401, &mut x402, x400, x361, x379); + let mut x403: u32 = 0; + let mut x404: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x403, &mut x404, x402, x363, x387); + let mut x405: u32 = 0; + let mut x406: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x405, &mut x406, x404, x365, x389); + let mut x407: u32 = 0; + let mut x408: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x407, &mut x408, x406, x367, x391); + let mut x409: u32 = 0; + let mut x410: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x409, &mut x410, x408, x369, x393); + let mut x411: u32 = 0; + let mut x412: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x411, &mut x412, x410, (((x370 as u32) + (x328 as u32)) + ((x354 as u32) + x330)), ((x394 as u32) + x372)); + let mut x413: u32 = 0; + let mut x414: u32 = 0; + fiat_sm2_mulx_u32(&mut x413, &mut x414, x5, 0x4); + let mut x415: u32 = 0; + let mut x416: u32 = 0; + fiat_sm2_mulx_u32(&mut x415, &mut x416, x5, 0x2); + let mut x417: u32 = 0; + let mut x418: u32 = 0; + fiat_sm2_mulx_u32(&mut x417, &mut x418, x5, 0x2); + let mut x419: u32 = 0; + let mut x420: u32 = 0; + fiat_sm2_mulx_u32(&mut x419, &mut x420, x5, 0xffffffff); + let mut x421: u32 = 0; + let mut x422: u32 = 0; + fiat_sm2_mulx_u32(&mut x421, &mut x422, x5, 0x2); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_sm2_mulx_u32(&mut x423, &mut x424, x5, 0x3); + let mut x425: u32 = 0; + let mut x426: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x425, &mut x426, 0x0, x424, x421); + let mut x427: u32 = 0; + let mut x428: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x427, &mut x428, x426, ((x422 as fiat_sm2_u1) as u32), x419); + let mut x429: u32 = 0; + let mut x430: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x429, &mut x430, x428, x420, x417); + let mut x431: u32 = 0; + let mut x432: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x431, &mut x432, x430, ((x418 as fiat_sm2_u1) as u32), x5); + let mut x433: u32 = 0; + let mut x434: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x433, &mut x434, x432, (0x0 as u32), x5); + let mut x435: u32 = 0; + let mut x436: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x435, &mut x436, x434, (0x0 as u32), x415); + let mut x437: u32 = 0; + let mut x438: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x437, &mut x438, x436, ((x416 as fiat_sm2_u1) as u32), x413); + let mut x439: u32 = 0; + let mut x440: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x439, &mut x440, 0x0, x397, x423); + let mut x441: u32 = 0; + let mut x442: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x441, &mut x442, x440, x399, x425); + let mut x443: u32 = 0; + let mut x444: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x443, &mut x444, x442, x401, x427); + let mut x445: u32 = 0; + let mut x446: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x445, &mut x446, x444, x403, x429); + let mut x447: u32 = 0; + let mut x448: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x447, &mut x448, x446, x405, x431); + let mut x449: u32 = 0; + let mut x450: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x449, &mut x450, x448, x407, x433); + let mut x451: u32 = 0; + let mut x452: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x451, &mut x452, x450, x409, x435); + let mut x453: u32 = 0; + let mut x454: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x453, &mut x454, x452, x411, x437); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_sm2_mulx_u32(&mut x455, &mut x456, x439, 0xfffffffe); + let mut x457: u32 = 0; + let mut x458: u32 = 0; + fiat_sm2_mulx_u32(&mut x457, &mut x458, x439, 0xffffffff); + let mut x459: u32 = 0; + let mut x460: u32 = 0; + fiat_sm2_mulx_u32(&mut x459, &mut x460, x439, 0xffffffff); + let mut x461: u32 = 0; + let mut x462: u32 = 0; + fiat_sm2_mulx_u32(&mut x461, &mut x462, x439, 0xffffffff); + let mut x463: u32 = 0; + let mut x464: u32 = 0; + fiat_sm2_mulx_u32(&mut x463, &mut x464, x439, 0xffffffff); + let mut x465: u32 = 0; + let mut x466: u32 = 0; + fiat_sm2_mulx_u32(&mut x465, &mut x466, x439, 0xffffffff); + let mut x467: u32 = 0; + let mut x468: u32 = 0; + fiat_sm2_mulx_u32(&mut x467, &mut x468, x439, 0xffffffff); + let mut x469: u32 = 0; + let mut x470: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x469, &mut x470, 0x0, x468, x465); + let mut x471: u32 = 0; + let mut x472: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x471, &mut x472, 0x0, x464, x461); + let mut x473: u32 = 0; + let mut x474: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x473, &mut x474, x472, x462, x459); + let mut x475: u32 = 0; + let mut x476: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x475, &mut x476, x474, x460, x457); + let mut x477: u32 = 0; + let mut x478: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x477, &mut x478, x476, x458, x455); + let mut x479: u32 = 0; + let mut x480: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x479, &mut x480, 0x0, x439, x467); + let mut x481: u32 = 0; + let mut x482: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x481, &mut x482, x480, x441, x469); + let mut x483: u32 = 0; + let mut x484: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x483, &mut x484, x482, x443, ((x470 as u32) + x466)); + let mut x485: u32 = 0; + let mut x486: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x485, &mut x486, x484, x445, x463); + let mut x487: u32 = 0; + let mut x488: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x487, &mut x488, x486, x447, x471); + let mut x489: u32 = 0; + let mut x490: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x489, &mut x490, x488, x449, x473); + let mut x491: u32 = 0; + let mut x492: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x491, &mut x492, x490, x451, x475); + let mut x493: u32 = 0; + let mut x494: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x493, &mut x494, x492, x453, x477); + let mut x495: u32 = 0; + let mut x496: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x495, &mut x496, x494, (((x454 as u32) + (x412 as u32)) + ((x438 as u32) + x414)), ((x478 as u32) + x456)); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_sm2_mulx_u32(&mut x497, &mut x498, x6, 0x4); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_sm2_mulx_u32(&mut x499, &mut x500, x6, 0x2); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_sm2_mulx_u32(&mut x501, &mut x502, x6, 0x2); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_sm2_mulx_u32(&mut x503, &mut x504, x6, 0xffffffff); + let mut x505: u32 = 0; + let mut x506: u32 = 0; + fiat_sm2_mulx_u32(&mut x505, &mut x506, x6, 0x2); + let mut x507: u32 = 0; + let mut x508: u32 = 0; + fiat_sm2_mulx_u32(&mut x507, &mut x508, x6, 0x3); + let mut x509: u32 = 0; + let mut x510: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x509, &mut x510, 0x0, x508, x505); + let mut x511: u32 = 0; + let mut x512: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x511, &mut x512, x510, ((x506 as fiat_sm2_u1) as u32), x503); + let mut x513: u32 = 0; + let mut x514: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x513, &mut x514, x512, x504, x501); + let mut x515: u32 = 0; + let mut x516: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x515, &mut x516, x514, ((x502 as fiat_sm2_u1) as u32), x6); + let mut x517: u32 = 0; + let mut x518: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x517, &mut x518, x516, (0x0 as u32), x6); + let mut x519: u32 = 0; + let mut x520: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x519, &mut x520, x518, (0x0 as u32), x499); + let mut x521: u32 = 0; + let mut x522: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x521, &mut x522, x520, ((x500 as fiat_sm2_u1) as u32), x497); + let mut x523: u32 = 0; + let mut x524: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x523, &mut x524, 0x0, x481, x507); + let mut x525: u32 = 0; + let mut x526: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x525, &mut x526, x524, x483, x509); + let mut x527: u32 = 0; + let mut x528: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x527, &mut x528, x526, x485, x511); + let mut x529: u32 = 0; + let mut x530: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x529, &mut x530, x528, x487, x513); + let mut x531: u32 = 0; + let mut x532: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x531, &mut x532, x530, x489, x515); + let mut x533: u32 = 0; + let mut x534: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x533, &mut x534, x532, x491, x517); + let mut x535: u32 = 0; + let mut x536: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x535, &mut x536, x534, x493, x519); + let mut x537: u32 = 0; + let mut x538: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x537, &mut x538, x536, x495, x521); + let mut x539: u32 = 0; + let mut x540: u32 = 0; + fiat_sm2_mulx_u32(&mut x539, &mut x540, x523, 0xfffffffe); + let mut x541: u32 = 0; + let mut x542: u32 = 0; + fiat_sm2_mulx_u32(&mut x541, &mut x542, x523, 0xffffffff); + let mut x543: u32 = 0; + let mut x544: u32 = 0; + fiat_sm2_mulx_u32(&mut x543, &mut x544, x523, 0xffffffff); + let mut x545: u32 = 0; + let mut x546: u32 = 0; + fiat_sm2_mulx_u32(&mut x545, &mut x546, x523, 0xffffffff); + let mut x547: u32 = 0; + let mut x548: u32 = 0; + fiat_sm2_mulx_u32(&mut x547, &mut x548, x523, 0xffffffff); + let mut x549: u32 = 0; + let mut x550: u32 = 0; + fiat_sm2_mulx_u32(&mut x549, &mut x550, x523, 0xffffffff); + let mut x551: u32 = 0; + let mut x552: u32 = 0; + fiat_sm2_mulx_u32(&mut x551, &mut x552, x523, 0xffffffff); + let mut x553: u32 = 0; + let mut x554: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x553, &mut x554, 0x0, x552, x549); + let mut x555: u32 = 0; + let mut x556: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x555, &mut x556, 0x0, x548, x545); + let mut x557: u32 = 0; + let mut x558: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x557, &mut x558, x556, x546, x543); + let mut x559: u32 = 0; + let mut x560: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x559, &mut x560, x558, x544, x541); + let mut x561: u32 = 0; + let mut x562: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x561, &mut x562, x560, x542, x539); + let mut x563: u32 = 0; + let mut x564: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x563, &mut x564, 0x0, x523, x551); + let mut x565: u32 = 0; + let mut x566: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x565, &mut x566, x564, x525, x553); + let mut x567: u32 = 0; + let mut x568: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x567, &mut x568, x566, x527, ((x554 as u32) + x550)); + let mut x569: u32 = 0; + let mut x570: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x569, &mut x570, x568, x529, x547); + let mut x571: u32 = 0; + let mut x572: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x571, &mut x572, x570, x531, x555); + let mut x573: u32 = 0; + let mut x574: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x573, &mut x574, x572, x533, x557); + let mut x575: u32 = 0; + let mut x576: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x575, &mut x576, x574, x535, x559); + let mut x577: u32 = 0; + let mut x578: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x577, &mut x578, x576, x537, x561); + let mut x579: u32 = 0; + let mut x580: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x579, &mut x580, x578, (((x538 as u32) + (x496 as u32)) + ((x522 as u32) + x498)), ((x562 as u32) + x540)); + let mut x581: u32 = 0; + let mut x582: u32 = 0; + fiat_sm2_mulx_u32(&mut x581, &mut x582, x7, 0x4); + let mut x583: u32 = 0; + let mut x584: u32 = 0; + fiat_sm2_mulx_u32(&mut x583, &mut x584, x7, 0x2); + let mut x585: u32 = 0; + let mut x586: u32 = 0; + fiat_sm2_mulx_u32(&mut x585, &mut x586, x7, 0x2); + let mut x587: u32 = 0; + let mut x588: u32 = 0; + fiat_sm2_mulx_u32(&mut x587, &mut x588, x7, 0xffffffff); + let mut x589: u32 = 0; + let mut x590: u32 = 0; + fiat_sm2_mulx_u32(&mut x589, &mut x590, x7, 0x2); + let mut x591: u32 = 0; + let mut x592: u32 = 0; + fiat_sm2_mulx_u32(&mut x591, &mut x592, x7, 0x3); + let mut x593: u32 = 0; + let mut x594: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x593, &mut x594, 0x0, x592, x589); + let mut x595: u32 = 0; + let mut x596: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x595, &mut x596, x594, ((x590 as fiat_sm2_u1) as u32), x587); + let mut x597: u32 = 0; + let mut x598: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x597, &mut x598, x596, x588, x585); + let mut x599: u32 = 0; + let mut x600: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x599, &mut x600, x598, ((x586 as fiat_sm2_u1) as u32), x7); + let mut x601: u32 = 0; + let mut x602: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x601, &mut x602, x600, (0x0 as u32), x7); + let mut x603: u32 = 0; + let mut x604: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x603, &mut x604, x602, (0x0 as u32), x583); + let mut x605: u32 = 0; + let mut x606: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x605, &mut x606, x604, ((x584 as fiat_sm2_u1) as u32), x581); + let mut x607: u32 = 0; + let mut x608: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x607, &mut x608, 0x0, x565, x591); + let mut x609: u32 = 0; + let mut x610: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x609, &mut x610, x608, x567, x593); + let mut x611: u32 = 0; + let mut x612: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x611, &mut x612, x610, x569, x595); + let mut x613: u32 = 0; + let mut x614: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x613, &mut x614, x612, x571, x597); + let mut x615: u32 = 0; + let mut x616: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x615, &mut x616, x614, x573, x599); + let mut x617: u32 = 0; + let mut x618: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x617, &mut x618, x616, x575, x601); + let mut x619: u32 = 0; + let mut x620: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x619, &mut x620, x618, x577, x603); + let mut x621: u32 = 0; + let mut x622: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x621, &mut x622, x620, x579, x605); + let mut x623: u32 = 0; + let mut x624: u32 = 0; + fiat_sm2_mulx_u32(&mut x623, &mut x624, x607, 0xfffffffe); + let mut x625: u32 = 0; + let mut x626: u32 = 0; + fiat_sm2_mulx_u32(&mut x625, &mut x626, x607, 0xffffffff); + let mut x627: u32 = 0; + let mut x628: u32 = 0; + fiat_sm2_mulx_u32(&mut x627, &mut x628, x607, 0xffffffff); + let mut x629: u32 = 0; + let mut x630: u32 = 0; + fiat_sm2_mulx_u32(&mut x629, &mut x630, x607, 0xffffffff); + let mut x631: u32 = 0; + let mut x632: u32 = 0; + fiat_sm2_mulx_u32(&mut x631, &mut x632, x607, 0xffffffff); + let mut x633: u32 = 0; + let mut x634: u32 = 0; + fiat_sm2_mulx_u32(&mut x633, &mut x634, x607, 0xffffffff); + let mut x635: u32 = 0; + let mut x636: u32 = 0; + fiat_sm2_mulx_u32(&mut x635, &mut x636, x607, 0xffffffff); + let mut x637: u32 = 0; + let mut x638: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x637, &mut x638, 0x0, x636, x633); + let mut x639: u32 = 0; + let mut x640: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x639, &mut x640, 0x0, x632, x629); + let mut x641: u32 = 0; + let mut x642: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x641, &mut x642, x640, x630, x627); + let mut x643: u32 = 0; + let mut x644: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x643, &mut x644, x642, x628, x625); + let mut x645: u32 = 0; + let mut x646: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x645, &mut x646, x644, x626, x623); + let mut x647: u32 = 0; + let mut x648: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x647, &mut x648, 0x0, x607, x635); + let mut x649: u32 = 0; + let mut x650: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x649, &mut x650, x648, x609, x637); + let mut x651: u32 = 0; + let mut x652: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x651, &mut x652, x650, x611, ((x638 as u32) + x634)); + let mut x653: u32 = 0; + let mut x654: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x653, &mut x654, x652, x613, x631); + let mut x655: u32 = 0; + let mut x656: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x655, &mut x656, x654, x615, x639); + let mut x657: u32 = 0; + let mut x658: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x657, &mut x658, x656, x617, x641); + let mut x659: u32 = 0; + let mut x660: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x659, &mut x660, x658, x619, x643); + let mut x661: u32 = 0; + let mut x662: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x661, &mut x662, x660, x621, x645); + let mut x663: u32 = 0; + let mut x664: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x663, &mut x664, x662, (((x622 as u32) + (x580 as u32)) + ((x606 as u32) + x582)), ((x646 as u32) + x624)); + let mut x665: u32 = 0; + let mut x666: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x665, &mut x666, 0x0, x649, 0xffffffff); + let mut x667: u32 = 0; + let mut x668: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x667, &mut x668, x666, x651, 0xffffffff); + let mut x669: u32 = 0; + let mut x670: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x669, &mut x670, x668, x653, (0x0 as u32)); + let mut x671: u32 = 0; + let mut x672: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x671, &mut x672, x670, x655, 0xffffffff); + let mut x673: u32 = 0; + let mut x674: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x673, &mut x674, x672, x657, 0xffffffff); + let mut x675: u32 = 0; + let mut x676: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x675, &mut x676, x674, x659, 0xffffffff); + let mut x677: u32 = 0; + let mut x678: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x677, &mut x678, x676, x661, 0xffffffff); + let mut x679: u32 = 0; + let mut x680: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x679, &mut x680, x678, x663, 0xfffffffe); + let mut x681: u32 = 0; + let mut x682: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x681, &mut x682, x680, (x664 as u32), (0x0 as u32)); + let mut x683: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x683, x682, x665, x649); + let mut x684: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x684, x682, x667, x651); + let mut x685: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x685, x682, x669, x653); + let mut x686: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x686, x682, x671, x655); + let mut x687: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x687, x682, x673, x657); + let mut x688: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x688, x682, x675, x659); + let mut x689: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x689, x682, x677, x661); + let mut x690: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x690, x682, x679, x663); + out1[0] = x683; + out1[1] = x684; + out1[2] = x685; + out1[3] = x686; + out1[4] = x687; + out1[5] = x688; + out1[6] = x689; + out1[7] = x690; +} + +/// The function fiat_sm2_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_sm2_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_sm2_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_sm2_selectznz(out1: &mut [u32; 8], arg1: fiat_sm2_u1, arg2: &[u32; 8], arg3: &[u32; 8]) { + let mut x1: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x6, arg1, (arg2[5]), (arg3[5])); + let mut x7: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x7, arg1, (arg2[6]), (arg3[6])); + let mut x8: u32 = 0; + fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_set_one(out1: &mut fiat_sm2_montgomery_domain_field_element) { + out1[0] = (0x1 as u32); + out1[1] = (0x0 as u32); + out1[2] = 0xffffffff; + out1[3] = (0x0 as u32); + out1[4] = (0x0 as u32); + out1[5] = (0x0 as u32); + out1[6] = (0x0 as u32); + out1[7] = (0x1 as u32); +} + +/// The function fiat_sm2_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_sm2_msat(out1: &mut [u32; 9]) { + out1[0] = 0xffffffff; + out1[1] = 0xffffffff; + out1[2] = (0x0 as u32); + out1[3] = 0xffffffff; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffffe; + out1[8] = (0x0 as u32); +} + +/// The function fiat_sm2_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_sm2_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_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u32)); + let x3: fiat_sm2_u1 = (((x1 >> 31) as fiat_sm2_u1) & (((arg3[0]) & (0x1 as u32)) as fiat_sm2_u1)); + let mut x4: u32 = 0; + let mut x5: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u32)); + let mut x6: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x6, x3, arg1, x4); + let mut x7: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x14, x3, (arg2[7]), (arg3[7])); + let mut x15: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x15, x3, (arg2[8]), (arg3[8])); + let mut x16: u32 = 0; + let mut x17: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x16, &mut x17, 0x0, (0x1 as u32), (!(arg2[0]))); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x18, &mut x19, x17, (0x0 as u32), (!(arg2[1]))); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x20, &mut x21, x19, (0x0 as u32), (!(arg2[2]))); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), (!(arg2[3]))); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), (!(arg2[4]))); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), (!(arg2[5]))); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), (!(arg2[6]))); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), (!(arg2[7]))); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), (!(arg2[8]))); + let mut x34: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x34, x3, (arg3[0]), x16); + let mut x35: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x35, x3, (arg3[1]), x18); + let mut x36: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x36, x3, (arg3[2]), x20); + let mut x37: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x37, x3, (arg3[3]), x22); + let mut x38: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x38, x3, (arg3[4]), x24); + let mut x39: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x39, x3, (arg3[5]), x26); + let mut x40: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x40, x3, (arg3[6]), x28); + let mut x41: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x41, x3, (arg3[7]), x30); + let mut x42: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x42, x3, (arg3[8]), x32); + let mut x43: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x43, x3, (arg4[0]), (arg5[0])); + let mut x44: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x44, x3, (arg4[1]), (arg5[1])); + let mut x45: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x45, x3, (arg4[2]), (arg5[2])); + let mut x46: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x46, x3, (arg4[3]), (arg5[3])); + let mut x47: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x47, x3, (arg4[4]), (arg5[4])); + let mut x48: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x48, x3, (arg4[5]), (arg5[5])); + let mut x49: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x49, x3, (arg4[6]), (arg5[6])); + let mut x50: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x50, x3, (arg4[7]), (arg5[7])); + let mut x51: u32 = 0; + let mut x52: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x51, &mut x52, 0x0, x43, x43); + let mut x53: u32 = 0; + let mut x54: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x53, &mut x54, x52, x44, x44); + let mut x55: u32 = 0; + let mut x56: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x55, &mut x56, x54, x45, x45); + let mut x57: u32 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x57, &mut x58, x56, x46, x46); + let mut x59: u32 = 0; + let mut x60: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x59, &mut x60, x58, x47, x47); + let mut x61: u32 = 0; + let mut x62: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x61, &mut x62, x60, x48, x48); + let mut x63: u32 = 0; + let mut x64: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x63, &mut x64, x62, x49, x49); + let mut x65: u32 = 0; + let mut x66: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x65, &mut x66, x64, x50, x50); + let mut x67: u32 = 0; + let mut x68: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x67, &mut x68, 0x0, x51, 0xffffffff); + let mut x69: u32 = 0; + let mut x70: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x69, &mut x70, x68, x53, 0xffffffff); + let mut x71: u32 = 0; + let mut x72: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x71, &mut x72, x70, x55, (0x0 as u32)); + let mut x73: u32 = 0; + let mut x74: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x73, &mut x74, x72, x57, 0xffffffff); + let mut x75: u32 = 0; + let mut x76: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x75, &mut x76, x74, x59, 0xffffffff); + let mut x77: u32 = 0; + let mut x78: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x77, &mut x78, x76, x61, 0xffffffff); + let mut x79: u32 = 0; + let mut x80: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x79, &mut x80, x78, x63, 0xffffffff); + let mut x81: u32 = 0; + let mut x82: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x81, &mut x82, x80, x65, 0xfffffffe); + let mut x83: u32 = 0; + let mut x84: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x93, &mut x94, 0x0, (0x0 as u32), x92); + let mut x95: u32 = 0; + let mut x96: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x95, &mut x96, x94, (0x0 as u32), x91); + let mut x97: u32 = 0; + let mut x98: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x97, &mut x98, x96, (0x0 as u32), x90); + let mut x99: u32 = 0; + let mut x100: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x99, &mut x100, x98, (0x0 as u32), x89); + let mut x101: u32 = 0; + let mut x102: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x101, &mut x102, x100, (0x0 as u32), x88); + let mut x103: u32 = 0; + let mut x104: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x103, &mut x104, x102, (0x0 as u32), x87); + let mut x105: u32 = 0; + let mut x106: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x105, &mut x106, x104, (0x0 as u32), x86); + let mut x107: u32 = 0; + let mut x108: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x107, &mut x108, x106, (0x0 as u32), x85); + let mut x109: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x109, x108, (0x0 as u32), 0xffffffff); + let mut x110: u32 = 0; + let mut x111: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x110, &mut x111, 0x0, x93, x109); + let mut x112: u32 = 0; + let mut x113: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x112, &mut x113, x111, x95, x109); + let mut x114: u32 = 0; + let mut x115: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x114, &mut x115, x113, x97, (0x0 as u32)); + let mut x116: u32 = 0; + let mut x117: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x116, &mut x117, x115, x99, x109); + let mut x118: u32 = 0; + let mut x119: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x118, &mut x119, x117, x101, x109); + let mut x120: u32 = 0; + let mut x121: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x120, &mut x121, x119, x103, x109); + let mut x122: u32 = 0; + let mut x123: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x122, &mut x123, x121, x105, x109); + let mut x124: u32 = 0; + let mut x125: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x124, &mut x125, x123, x107, (x109 & 0xfffffffe)); + let mut x126: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x126, x3, (arg5[0]), x110); + let mut x127: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x127, x3, (arg5[1]), x112); + let mut x128: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x128, x3, (arg5[2]), x114); + let mut x129: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x129, x3, (arg5[3]), x116); + let mut x130: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x130, x3, (arg5[4]), x118); + let mut x131: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x131, x3, (arg5[5]), x120); + let mut x132: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x132, x3, (arg5[6]), x122); + let mut x133: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x133, x3, (arg5[7]), x124); + let x134: fiat_sm2_u1 = ((x34 & (0x1 as u32)) as fiat_sm2_u1); + let mut x135: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x135, x134, (0x0 as u32), x7); + let mut x136: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x136, x134, (0x0 as u32), x8); + let mut x137: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x137, x134, (0x0 as u32), x9); + let mut x138: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x138, x134, (0x0 as u32), x10); + let mut x139: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x139, x134, (0x0 as u32), x11); + let mut x140: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x140, x134, (0x0 as u32), x12); + let mut x141: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x141, x134, (0x0 as u32), x13); + let mut x142: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x142, x134, (0x0 as u32), x14); + let mut x143: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x143, x134, (0x0 as u32), x15); + let mut x144: u32 = 0; + let mut x145: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x144, &mut x145, 0x0, x34, x135); + let mut x146: u32 = 0; + let mut x147: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x146, &mut x147, x145, x35, x136); + let mut x148: u32 = 0; + let mut x149: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x148, &mut x149, x147, x36, x137); + let mut x150: u32 = 0; + let mut x151: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x150, &mut x151, x149, x37, x138); + let mut x152: u32 = 0; + let mut x153: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x152, &mut x153, x151, x38, x139); + let mut x154: u32 = 0; + let mut x155: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x154, &mut x155, x153, x39, x140); + let mut x156: u32 = 0; + let mut x157: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x156, &mut x157, x155, x40, x141); + let mut x158: u32 = 0; + let mut x159: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x158, &mut x159, x157, x41, x142); + let mut x160: u32 = 0; + let mut x161: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x160, &mut x161, x159, x42, x143); + let mut x162: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x162, x134, (0x0 as u32), x43); + let mut x163: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x163, x134, (0x0 as u32), x44); + let mut x164: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x164, x134, (0x0 as u32), x45); + let mut x165: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x165, x134, (0x0 as u32), x46); + let mut x166: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x166, x134, (0x0 as u32), x47); + let mut x167: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x167, x134, (0x0 as u32), x48); + let mut x168: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x168, x134, (0x0 as u32), x49); + let mut x169: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x169, x134, (0x0 as u32), x50); + let mut x170: u32 = 0; + let mut x171: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x170, &mut x171, 0x0, x126, x162); + let mut x172: u32 = 0; + let mut x173: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x172, &mut x173, x171, x127, x163); + let mut x174: u32 = 0; + let mut x175: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x174, &mut x175, x173, x128, x164); + let mut x176: u32 = 0; + let mut x177: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x176, &mut x177, x175, x129, x165); + let mut x178: u32 = 0; + let mut x179: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x178, &mut x179, x177, x130, x166); + let mut x180: u32 = 0; + let mut x181: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x180, &mut x181, x179, x131, x167); + let mut x182: u32 = 0; + let mut x183: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x182, &mut x183, x181, x132, x168); + let mut x184: u32 = 0; + let mut x185: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u32(&mut x184, &mut x185, x183, x133, x169); + let mut x186: u32 = 0; + let mut x187: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x186, &mut x187, 0x0, x170, 0xffffffff); + let mut x188: u32 = 0; + let mut x189: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x188, &mut x189, x187, x172, 0xffffffff); + let mut x190: u32 = 0; + let mut x191: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x190, &mut x191, x189, x174, (0x0 as u32)); + let mut x192: u32 = 0; + let mut x193: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x192, &mut x193, x191, x176, 0xffffffff); + let mut x194: u32 = 0; + let mut x195: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x194, &mut x195, x193, x178, 0xffffffff); + let mut x196: u32 = 0; + let mut x197: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x196, &mut x197, x195, x180, 0xffffffff); + let mut x198: u32 = 0; + let mut x199: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x198, &mut x199, x197, x182, 0xffffffff); + let mut x200: u32 = 0; + let mut x201: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x200, &mut x201, x199, x184, 0xfffffffe); + let mut x202: u32 = 0; + let mut x203: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u32(&mut x202, &mut x203, x201, (x185 as u32), (0x0 as u32)); + let mut x204: u32 = 0; + let mut x205: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_cmovznz_u32(&mut x215, x84, x67, x51); + let mut x216: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x216, x84, x69, x53); + let mut x217: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x217, x84, x71, x55); + let mut x218: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x218, x84, x73, x57); + let mut x219: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x219, x84, x75, x59); + let mut x220: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x220, x84, x77, x61); + let mut x221: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x221, x84, x79, x63); + let mut x222: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x222, x84, x81, x65); + let mut x223: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x223, x203, x186, x170); + let mut x224: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x224, x203, x188, x172); + let mut x225: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x225, x203, x190, x174); + let mut x226: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x226, x203, x192, x176); + let mut x227: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x227, x203, x194, x178); + let mut x228: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x228, x203, x196, x180); + let mut x229: u32 = 0; + fiat_sm2_cmovznz_u32(&mut x229, x203, x198, x182); + let mut x230: u32 = 0; + fiat_sm2_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_sm2_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_sm2_divstep_precomp(out1: &mut [u32; 8]) { + out1[0] = 0x8ffffffe; + out1[1] = 0x50000002; + out1[2] = 0x9ffffffe; + out1[3] = 0xe8000000; + out1[4] = 0x8ffffffe; + out1[5] = 0xd0000001; + out1[6] = 0x1ffffffd; + out1[7] = 0x28000001; +} diff --git a/fiat-rust/src/sm2_64.rs b/fiat-rust/src/sm2_64.rs new file mode 100644 index 00000000000..30988ea635d --- /dev/null +++ b/fiat-rust/src/sm2_64.rs @@ -0,0 +1,1985 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline sm2 64 '2^256 - 2^224 - 2^96 + 2^64 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: sm2 +//! 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") +//! +//! 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)] + +/** fiat_sm2_u1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_u1 = u8; +/** fiat_sm2_i1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_i1 = i8; +/** fiat_sm2_u2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_u2 = u8; +/** fiat_sm2_i2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_i2 = i8; + +/** The type fiat_sm2_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/** Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_montgomery_domain_field_element(pub [u64; 4]); + +impl core::ops::Index for fiat_sm2_montgomery_domain_field_element { + type Output = u64; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + +/** The type fiat_sm2_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/** Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_non_montgomery_domain_field_element(pub [u64; 4]); + +impl core::ops::Index for fiat_sm2_non_montgomery_domain_field_element { + type Output = u64; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_non_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + + +/// The function fiat_sm2_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_sm2_addcarryx_u64(out1: &mut u64, out2: &mut fiat_sm2_u1, arg1: fiat_sm2_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_sm2_u1 = ((x1 >> 64) as fiat_sm2_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_sm2_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_sm2_subborrowx_u64(out1: &mut u64, out2: &mut fiat_sm2_u1, arg1: fiat_sm2_u1, arg2: u64, arg3: u64) { + let x1: i128 = (((arg2 as i128) - (arg1 as i128)) - (arg3 as i128)); + let x2: fiat_sm2_i1 = ((x1 >> 64) as fiat_sm2_i1); + let x3: u64 = ((x1 & (0xffffffffffffffff as i128)) as u64); + *out1 = x3; + *out2 = (((0x0 as fiat_sm2_i2) - (x2 as fiat_sm2_i2)) as fiat_sm2_u1); +} + +/// The function fiat_sm2_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_sm2_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_sm2_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_sm2_cmovznz_u64(out1: &mut u64, arg1: fiat_sm2_u1, arg2: u64, arg3: u64) { + let x1: fiat_sm2_u1 = (!(!arg1)); + let x2: u64 = ((((((0x0 as fiat_sm2_i2) - (x1 as fiat_sm2_i2)) as fiat_sm2_i1) as i128) & (0xffffffffffffffff as i128)) as u64); + let x3: u64 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_sm2_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_sm2_mul(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element, arg2: &fiat_sm2_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_sm2_mulx_u64(&mut x5, &mut x6, x4, (arg2[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_sm2_mulx_u64(&mut x7, &mut x8, x4, (arg2[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_sm2_mulx_u64(&mut x9, &mut x10, x4, (arg2[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_sm2_mulx_u64(&mut x11, &mut x12, x4, (arg2[0])); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_mulx_u64(&mut x20, &mut x21, x11, 0xfffffffeffffffff); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_sm2_mulx_u64(&mut x22, &mut x23, x11, 0xffffffffffffffff); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_sm2_mulx_u64(&mut x24, &mut x25, x11, 0xffffffff00000000); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_sm2_mulx_u64(&mut x26, &mut x27, x11, 0xffffffffffffffff); + let mut x28: u64 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x28, &mut x29, 0x0, x27, x24); + let mut x30: u64 = 0; + let mut x31: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x30, &mut x31, x29, x25, x22); + let mut x32: u64 = 0; + let mut x33: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x32, &mut x33, x31, x23, x20); + let x34: u64 = ((x33 as u64) + x21); + let mut x35: u64 = 0; + let mut x36: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x35, &mut x36, 0x0, x11, x26); + let mut x37: u64 = 0; + let mut x38: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x37, &mut x38, x36, x13, x28); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x39, &mut x40, x38, x15, x30); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x41, &mut x42, x40, x17, x32); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x43, &mut x44, x42, x19, x34); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_sm2_mulx_u64(&mut x45, &mut x46, x1, (arg2[3])); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_sm2_mulx_u64(&mut x47, &mut x48, x1, (arg2[2])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_sm2_mulx_u64(&mut x49, &mut x50, x1, (arg2[1])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_sm2_mulx_u64(&mut x51, &mut x52, x1, (arg2[0])); + let mut x53: u64 = 0; + let mut x54: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x53, &mut x54, 0x0, x52, x49); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x55, &mut x56, x54, x50, x47); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x57, &mut x58, x56, x48, x45); + let x59: u64 = ((x58 as u64) + x46); + let mut x60: u64 = 0; + let mut x61: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x60, &mut x61, 0x0, x37, x51); + let mut x62: u64 = 0; + let mut x63: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x62, &mut x63, x61, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x68, &mut x69, x67, (x44 as u64), x59); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_sm2_mulx_u64(&mut x70, &mut x71, x60, 0xfffffffeffffffff); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_sm2_mulx_u64(&mut x72, &mut x73, x60, 0xffffffffffffffff); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_sm2_mulx_u64(&mut x74, &mut x75, x60, 0xffffffff00000000); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_sm2_mulx_u64(&mut x76, &mut x77, x60, 0xffffffffffffffff); + let mut x78: u64 = 0; + let mut x79: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x78, &mut x79, 0x0, x77, x74); + let mut x80: u64 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x80, &mut x81, x79, x75, x72); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x82, &mut x83, x81, x73, x70); + let x84: u64 = ((x83 as u64) + x71); + let mut x85: u64 = 0; + let mut x86: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x85, &mut x86, 0x0, x60, x76); + let mut x87: u64 = 0; + let mut x88: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x87, &mut x88, x86, x62, x78); + let mut x89: u64 = 0; + let mut x90: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x89, &mut x90, x88, x64, x80); + let mut x91: u64 = 0; + let mut x92: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x91, &mut x92, x90, x66, x82); + let mut x93: u64 = 0; + let mut x94: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x93, &mut x94, x92, x68, x84); + let x95: u64 = ((x94 as u64) + (x69 as u64)); + let mut x96: u64 = 0; + let mut x97: u64 = 0; + fiat_sm2_mulx_u64(&mut x96, &mut x97, x2, (arg2[3])); + let mut x98: u64 = 0; + let mut x99: u64 = 0; + fiat_sm2_mulx_u64(&mut x98, &mut x99, x2, (arg2[2])); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_sm2_mulx_u64(&mut x100, &mut x101, x2, (arg2[1])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_sm2_mulx_u64(&mut x102, &mut x103, x2, (arg2[0])); + let mut x104: u64 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x104, &mut x105, 0x0, x103, x100); + let mut x106: u64 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x106, &mut x107, x105, x101, x98); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x108, &mut x109, x107, x99, x96); + let x110: u64 = ((x109 as u64) + x97); + let mut x111: u64 = 0; + let mut x112: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x111, &mut x112, 0x0, x87, x102); + let mut x113: u64 = 0; + let mut x114: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x113, &mut x114, x112, x89, x104); + let mut x115: u64 = 0; + let mut x116: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x115, &mut x116, x114, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: u64 = 0; + fiat_sm2_mulx_u64(&mut x121, &mut x122, x111, 0xfffffffeffffffff); + let mut x123: u64 = 0; + let mut x124: u64 = 0; + fiat_sm2_mulx_u64(&mut x123, &mut x124, x111, 0xffffffffffffffff); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_sm2_mulx_u64(&mut x125, &mut x126, x111, 0xffffffff00000000); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_sm2_mulx_u64(&mut x127, &mut x128, x111, 0xffffffffffffffff); + let mut x129: u64 = 0; + let mut x130: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x129, &mut x130, 0x0, x128, x125); + let mut x131: u64 = 0; + let mut x132: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x131, &mut x132, x130, x126, x123); + let mut x133: u64 = 0; + let mut x134: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x133, &mut x134, x132, x124, x121); + let x135: u64 = ((x134 as u64) + x122); + let mut x136: u64 = 0; + let mut x137: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x136, &mut x137, 0x0, x111, x127); + let mut x138: u64 = 0; + let mut x139: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x138, &mut x139, x137, x113, x129); + let mut x140: u64 = 0; + let mut x141: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x140, &mut x141, x139, x115, x131); + let mut x142: u64 = 0; + let mut x143: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x142, &mut x143, x141, x117, x133); + let mut x144: u64 = 0; + let mut x145: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x144, &mut x145, x143, x119, x135); + let x146: u64 = ((x145 as u64) + (x120 as u64)); + let mut x147: u64 = 0; + let mut x148: u64 = 0; + fiat_sm2_mulx_u64(&mut x147, &mut x148, x3, (arg2[3])); + let mut x149: u64 = 0; + let mut x150: u64 = 0; + fiat_sm2_mulx_u64(&mut x149, &mut x150, x3, (arg2[2])); + let mut x151: u64 = 0; + let mut x152: u64 = 0; + fiat_sm2_mulx_u64(&mut x151, &mut x152, x3, (arg2[1])); + let mut x153: u64 = 0; + let mut x154: u64 = 0; + fiat_sm2_mulx_u64(&mut x153, &mut x154, x3, (arg2[0])); + let mut x155: u64 = 0; + let mut x156: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x155, &mut x156, 0x0, x154, x151); + let mut x157: u64 = 0; + let mut x158: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x157, &mut x158, x156, x152, x149); + let mut x159: u64 = 0; + let mut x160: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x159, &mut x160, x158, x150, x147); + let x161: u64 = ((x160 as u64) + x148); + let mut x162: u64 = 0; + let mut x163: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x162, &mut x163, 0x0, x138, x153); + let mut x164: u64 = 0; + let mut x165: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x164, &mut x165, x163, x140, x155); + let mut x166: u64 = 0; + let mut x167: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x166, &mut x167, x165, x142, x157); + let mut x168: u64 = 0; + let mut x169: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x168, &mut x169, x167, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: u64 = 0; + fiat_sm2_mulx_u64(&mut x172, &mut x173, x162, 0xfffffffeffffffff); + let mut x174: u64 = 0; + let mut x175: u64 = 0; + fiat_sm2_mulx_u64(&mut x174, &mut x175, x162, 0xffffffffffffffff); + let mut x176: u64 = 0; + let mut x177: u64 = 0; + fiat_sm2_mulx_u64(&mut x176, &mut x177, x162, 0xffffffff00000000); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_sm2_mulx_u64(&mut x178, &mut x179, x162, 0xffffffffffffffff); + let mut x180: u64 = 0; + let mut x181: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x180, &mut x181, 0x0, x179, x176); + let mut x182: u64 = 0; + let mut x183: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x182, &mut x183, x181, x177, x174); + let mut x184: u64 = 0; + let mut x185: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x184, &mut x185, x183, x175, x172); + let x186: u64 = ((x185 as u64) + x173); + let mut x187: u64 = 0; + let mut x188: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x187, &mut x188, 0x0, x162, x178); + let mut x189: u64 = 0; + let mut x190: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x189, &mut x190, x188, x164, x180); + let mut x191: u64 = 0; + let mut x192: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x191, &mut x192, x190, x166, x182); + let mut x193: u64 = 0; + let mut x194: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x193, &mut x194, x192, x168, x184); + let mut x195: u64 = 0; + let mut x196: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x195, &mut x196, x194, x170, x186); + let x197: u64 = ((x196 as u64) + (x171 as u64)); + let mut x198: u64 = 0; + let mut x199: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x198, &mut x199, 0x0, x189, 0xffffffffffffffff); + let mut x200: u64 = 0; + let mut x201: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x200, &mut x201, x199, x191, 0xffffffff00000000); + let mut x202: u64 = 0; + let mut x203: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x202, &mut x203, x201, x193, 0xffffffffffffffff); + let mut x204: u64 = 0; + let mut x205: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x204, &mut x205, x203, x195, 0xfffffffeffffffff); + let mut x206: u64 = 0; + let mut x207: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x206, &mut x207, x205, x197, (0x0 as u64)); + let mut x208: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x208, x207, x198, x189); + let mut x209: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x209, x207, x200, x191); + let mut x210: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x210, x207, x202, x193); + let mut x211: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x211, x207, x204, x195); + out1[0] = x208; + out1[1] = x209; + out1[2] = x210; + out1[3] = x211; +} + +/// The function fiat_sm2_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_sm2_square(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_mulx_u64(&mut x5, &mut x6, x4, (arg1[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_sm2_mulx_u64(&mut x7, &mut x8, x4, (arg1[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_sm2_mulx_u64(&mut x9, &mut x10, x4, (arg1[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_sm2_mulx_u64(&mut x11, &mut x12, x4, (arg1[0])); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_mulx_u64(&mut x20, &mut x21, x11, 0xfffffffeffffffff); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_sm2_mulx_u64(&mut x22, &mut x23, x11, 0xffffffffffffffff); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_sm2_mulx_u64(&mut x24, &mut x25, x11, 0xffffffff00000000); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_sm2_mulx_u64(&mut x26, &mut x27, x11, 0xffffffffffffffff); + let mut x28: u64 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x28, &mut x29, 0x0, x27, x24); + let mut x30: u64 = 0; + let mut x31: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x30, &mut x31, x29, x25, x22); + let mut x32: u64 = 0; + let mut x33: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x32, &mut x33, x31, x23, x20); + let x34: u64 = ((x33 as u64) + x21); + let mut x35: u64 = 0; + let mut x36: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x35, &mut x36, 0x0, x11, x26); + let mut x37: u64 = 0; + let mut x38: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x37, &mut x38, x36, x13, x28); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x39, &mut x40, x38, x15, x30); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x41, &mut x42, x40, x17, x32); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x43, &mut x44, x42, x19, x34); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_sm2_mulx_u64(&mut x45, &mut x46, x1, (arg1[3])); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_sm2_mulx_u64(&mut x47, &mut x48, x1, (arg1[2])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_sm2_mulx_u64(&mut x49, &mut x50, x1, (arg1[1])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_sm2_mulx_u64(&mut x51, &mut x52, x1, (arg1[0])); + let mut x53: u64 = 0; + let mut x54: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x53, &mut x54, 0x0, x52, x49); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x55, &mut x56, x54, x50, x47); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x57, &mut x58, x56, x48, x45); + let x59: u64 = ((x58 as u64) + x46); + let mut x60: u64 = 0; + let mut x61: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x60, &mut x61, 0x0, x37, x51); + let mut x62: u64 = 0; + let mut x63: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x62, &mut x63, x61, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x68, &mut x69, x67, (x44 as u64), x59); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_sm2_mulx_u64(&mut x70, &mut x71, x60, 0xfffffffeffffffff); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_sm2_mulx_u64(&mut x72, &mut x73, x60, 0xffffffffffffffff); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_sm2_mulx_u64(&mut x74, &mut x75, x60, 0xffffffff00000000); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_sm2_mulx_u64(&mut x76, &mut x77, x60, 0xffffffffffffffff); + let mut x78: u64 = 0; + let mut x79: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x78, &mut x79, 0x0, x77, x74); + let mut x80: u64 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x80, &mut x81, x79, x75, x72); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x82, &mut x83, x81, x73, x70); + let x84: u64 = ((x83 as u64) + x71); + let mut x85: u64 = 0; + let mut x86: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x85, &mut x86, 0x0, x60, x76); + let mut x87: u64 = 0; + let mut x88: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x87, &mut x88, x86, x62, x78); + let mut x89: u64 = 0; + let mut x90: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x89, &mut x90, x88, x64, x80); + let mut x91: u64 = 0; + let mut x92: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x91, &mut x92, x90, x66, x82); + let mut x93: u64 = 0; + let mut x94: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x93, &mut x94, x92, x68, x84); + let x95: u64 = ((x94 as u64) + (x69 as u64)); + let mut x96: u64 = 0; + let mut x97: u64 = 0; + fiat_sm2_mulx_u64(&mut x96, &mut x97, x2, (arg1[3])); + let mut x98: u64 = 0; + let mut x99: u64 = 0; + fiat_sm2_mulx_u64(&mut x98, &mut x99, x2, (arg1[2])); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_sm2_mulx_u64(&mut x100, &mut x101, x2, (arg1[1])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_sm2_mulx_u64(&mut x102, &mut x103, x2, (arg1[0])); + let mut x104: u64 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x104, &mut x105, 0x0, x103, x100); + let mut x106: u64 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x106, &mut x107, x105, x101, x98); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x108, &mut x109, x107, x99, x96); + let x110: u64 = ((x109 as u64) + x97); + let mut x111: u64 = 0; + let mut x112: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x111, &mut x112, 0x0, x87, x102); + let mut x113: u64 = 0; + let mut x114: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x113, &mut x114, x112, x89, x104); + let mut x115: u64 = 0; + let mut x116: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x115, &mut x116, x114, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: u64 = 0; + fiat_sm2_mulx_u64(&mut x121, &mut x122, x111, 0xfffffffeffffffff); + let mut x123: u64 = 0; + let mut x124: u64 = 0; + fiat_sm2_mulx_u64(&mut x123, &mut x124, x111, 0xffffffffffffffff); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_sm2_mulx_u64(&mut x125, &mut x126, x111, 0xffffffff00000000); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_sm2_mulx_u64(&mut x127, &mut x128, x111, 0xffffffffffffffff); + let mut x129: u64 = 0; + let mut x130: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x129, &mut x130, 0x0, x128, x125); + let mut x131: u64 = 0; + let mut x132: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x131, &mut x132, x130, x126, x123); + let mut x133: u64 = 0; + let mut x134: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x133, &mut x134, x132, x124, x121); + let x135: u64 = ((x134 as u64) + x122); + let mut x136: u64 = 0; + let mut x137: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x136, &mut x137, 0x0, x111, x127); + let mut x138: u64 = 0; + let mut x139: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x138, &mut x139, x137, x113, x129); + let mut x140: u64 = 0; + let mut x141: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x140, &mut x141, x139, x115, x131); + let mut x142: u64 = 0; + let mut x143: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x142, &mut x143, x141, x117, x133); + let mut x144: u64 = 0; + let mut x145: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x144, &mut x145, x143, x119, x135); + let x146: u64 = ((x145 as u64) + (x120 as u64)); + let mut x147: u64 = 0; + let mut x148: u64 = 0; + fiat_sm2_mulx_u64(&mut x147, &mut x148, x3, (arg1[3])); + let mut x149: u64 = 0; + let mut x150: u64 = 0; + fiat_sm2_mulx_u64(&mut x149, &mut x150, x3, (arg1[2])); + let mut x151: u64 = 0; + let mut x152: u64 = 0; + fiat_sm2_mulx_u64(&mut x151, &mut x152, x3, (arg1[1])); + let mut x153: u64 = 0; + let mut x154: u64 = 0; + fiat_sm2_mulx_u64(&mut x153, &mut x154, x3, (arg1[0])); + let mut x155: u64 = 0; + let mut x156: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x155, &mut x156, 0x0, x154, x151); + let mut x157: u64 = 0; + let mut x158: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x157, &mut x158, x156, x152, x149); + let mut x159: u64 = 0; + let mut x160: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x159, &mut x160, x158, x150, x147); + let x161: u64 = ((x160 as u64) + x148); + let mut x162: u64 = 0; + let mut x163: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x162, &mut x163, 0x0, x138, x153); + let mut x164: u64 = 0; + let mut x165: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x164, &mut x165, x163, x140, x155); + let mut x166: u64 = 0; + let mut x167: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x166, &mut x167, x165, x142, x157); + let mut x168: u64 = 0; + let mut x169: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x168, &mut x169, x167, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: u64 = 0; + fiat_sm2_mulx_u64(&mut x172, &mut x173, x162, 0xfffffffeffffffff); + let mut x174: u64 = 0; + let mut x175: u64 = 0; + fiat_sm2_mulx_u64(&mut x174, &mut x175, x162, 0xffffffffffffffff); + let mut x176: u64 = 0; + let mut x177: u64 = 0; + fiat_sm2_mulx_u64(&mut x176, &mut x177, x162, 0xffffffff00000000); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_sm2_mulx_u64(&mut x178, &mut x179, x162, 0xffffffffffffffff); + let mut x180: u64 = 0; + let mut x181: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x180, &mut x181, 0x0, x179, x176); + let mut x182: u64 = 0; + let mut x183: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x182, &mut x183, x181, x177, x174); + let mut x184: u64 = 0; + let mut x185: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x184, &mut x185, x183, x175, x172); + let x186: u64 = ((x185 as u64) + x173); + let mut x187: u64 = 0; + let mut x188: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x187, &mut x188, 0x0, x162, x178); + let mut x189: u64 = 0; + let mut x190: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x189, &mut x190, x188, x164, x180); + let mut x191: u64 = 0; + let mut x192: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x191, &mut x192, x190, x166, x182); + let mut x193: u64 = 0; + let mut x194: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x193, &mut x194, x192, x168, x184); + let mut x195: u64 = 0; + let mut x196: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x195, &mut x196, x194, x170, x186); + let x197: u64 = ((x196 as u64) + (x171 as u64)); + let mut x198: u64 = 0; + let mut x199: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x198, &mut x199, 0x0, x189, 0xffffffffffffffff); + let mut x200: u64 = 0; + let mut x201: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x200, &mut x201, x199, x191, 0xffffffff00000000); + let mut x202: u64 = 0; + let mut x203: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x202, &mut x203, x201, x193, 0xffffffffffffffff); + let mut x204: u64 = 0; + let mut x205: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x204, &mut x205, x203, x195, 0xfffffffeffffffff); + let mut x206: u64 = 0; + let mut x207: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x206, &mut x207, x205, x197, (0x0 as u64)); + let mut x208: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x208, x207, x198, x189); + let mut x209: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x209, x207, x200, x191); + let mut x210: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x210, x207, x202, x193); + let mut x211: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x211, x207, x204, x195); + out1[0] = x208; + out1[1] = x209; + out1[2] = x210; + out1[3] = x211; +} + +/// The function fiat_sm2_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_sm2_add(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element, arg2: &fiat_sm2_montgomery_domain_field_element) { + let mut x1: u64 = 0; + let mut x2: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x9, &mut x10, 0x0, x1, 0xffffffffffffffff); + let mut x11: u64 = 0; + let mut x12: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x11, &mut x12, x10, x3, 0xffffffff00000000); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x13, &mut x14, x12, x5, 0xffffffffffffffff); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x15, &mut x16, x14, x7, 0xfffffffeffffffff); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x17, &mut x18, x16, (x8 as u64), (0x0 as u64)); + let mut x19: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x19, x18, x9, x1); + let mut x20: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x20, x18, x11, x3); + let mut x21: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x21, x18, x13, x5); + let mut x22: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function fiat_sm2_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_sm2_sub(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element, arg2: &fiat_sm2_montgomery_domain_field_element) { + let mut x1: u64 = 0; + let mut x2: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, x9); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0xffffffff00000000)); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x14, &mut x15, x13, x5, x9); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0xfffffffeffffffff)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_sm2_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_sm2_opp(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element) { + let mut x1: u64 = 0; + let mut x2: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x1, &mut x2, 0x0, (0x0 as u64), (arg1[0])); + let mut x3: u64 = 0; + let mut x4: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x3, &mut x4, x2, (0x0 as u64), (arg1[1])); + let mut x5: u64 = 0; + let mut x6: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x5, &mut x6, x4, (0x0 as u64), (arg1[2])); + let mut x7: u64 = 0; + let mut x8: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x7, &mut x8, x6, (0x0 as u64), (arg1[3])); + let mut x9: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, x9); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0xffffffff00000000)); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x14, &mut x15, x13, x5, x9); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0xfffffffeffffffff)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_sm2_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_sm2_from_montgomery(out1: &mut fiat_sm2_non_montgomery_domain_field_element, arg1: &fiat_sm2_montgomery_domain_field_element) { + let x1: u64 = (arg1[0]); + let mut x2: u64 = 0; + let mut x3: u64 = 0; + fiat_sm2_mulx_u64(&mut x2, &mut x3, x1, 0xfffffffeffffffff); + let mut x4: u64 = 0; + let mut x5: u64 = 0; + fiat_sm2_mulx_u64(&mut x4, &mut x5, x1, 0xffffffffffffffff); + let mut x6: u64 = 0; + let mut x7: u64 = 0; + fiat_sm2_mulx_u64(&mut x6, &mut x7, x1, 0xffffffff00000000); + let mut x8: u64 = 0; + let mut x9: u64 = 0; + fiat_sm2_mulx_u64(&mut x8, &mut x9, x1, 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x10, &mut x11, 0x0, x9, x6); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x12, &mut x13, x11, x7, x4); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x14, &mut x15, x13, x5, x2); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x16, &mut x17, 0x0, x1, x8); + let mut x18: u64 = 0; + let mut x19: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), x10); + let mut x20: u64 = 0; + let mut x21: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), x12); + let mut x22: u64 = 0; + let mut x23: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x22, &mut x23, x21, (0x0 as u64), x14); + let mut x24: u64 = 0; + let mut x25: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x24, &mut x25, 0x0, x18, (arg1[1])); + let mut x26: u64 = 0; + let mut x27: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x26, &mut x27, x25, x20, (0x0 as u64)); + let mut x28: u64 = 0; + let mut x29: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x28, &mut x29, x27, x22, (0x0 as u64)); + let mut x30: u64 = 0; + let mut x31: u64 = 0; + fiat_sm2_mulx_u64(&mut x30, &mut x31, x24, 0xfffffffeffffffff); + let mut x32: u64 = 0; + let mut x33: u64 = 0; + fiat_sm2_mulx_u64(&mut x32, &mut x33, x24, 0xffffffffffffffff); + let mut x34: u64 = 0; + let mut x35: u64 = 0; + fiat_sm2_mulx_u64(&mut x34, &mut x35, x24, 0xffffffff00000000); + let mut x36: u64 = 0; + let mut x37: u64 = 0; + fiat_sm2_mulx_u64(&mut x36, &mut x37, x24, 0xffffffffffffffff); + let mut x38: u64 = 0; + let mut x39: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x38, &mut x39, 0x0, x37, x34); + let mut x40: u64 = 0; + let mut x41: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x40, &mut x41, x39, x35, x32); + let mut x42: u64 = 0; + let mut x43: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x42, &mut x43, x41, x33, x30); + let mut x44: u64 = 0; + let mut x45: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x44, &mut x45, 0x0, x24, x36); + let mut x46: u64 = 0; + let mut x47: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x46, &mut x47, x45, x26, x38); + let mut x48: u64 = 0; + let mut x49: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x48, &mut x49, x47, x28, x40); + let mut x50: u64 = 0; + let mut x51: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x50, &mut x51, x49, ((x29 as u64) + ((x23 as u64) + ((x15 as u64) + x3))), x42); + let mut x52: u64 = 0; + let mut x53: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x52, &mut x53, 0x0, x46, (arg1[2])); + let mut x54: u64 = 0; + let mut x55: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x54, &mut x55, x53, x48, (0x0 as u64)); + let mut x56: u64 = 0; + let mut x57: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x56, &mut x57, x55, x50, (0x0 as u64)); + let mut x58: u64 = 0; + let mut x59: u64 = 0; + fiat_sm2_mulx_u64(&mut x58, &mut x59, x52, 0xfffffffeffffffff); + let mut x60: u64 = 0; + let mut x61: u64 = 0; + fiat_sm2_mulx_u64(&mut x60, &mut x61, x52, 0xffffffffffffffff); + let mut x62: u64 = 0; + let mut x63: u64 = 0; + fiat_sm2_mulx_u64(&mut x62, &mut x63, x52, 0xffffffff00000000); + let mut x64: u64 = 0; + let mut x65: u64 = 0; + fiat_sm2_mulx_u64(&mut x64, &mut x65, x52, 0xffffffffffffffff); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x66, &mut x67, 0x0, x65, x62); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x68, &mut x69, x67, x63, x60); + let mut x70: u64 = 0; + let mut x71: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x70, &mut x71, x69, x61, x58); + let mut x72: u64 = 0; + let mut x73: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x72, &mut x73, 0x0, x52, x64); + let mut x74: u64 = 0; + let mut x75: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x74, &mut x75, x73, x54, x66); + let mut x76: u64 = 0; + let mut x77: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x76, &mut x77, x75, x56, x68); + let mut x78: u64 = 0; + let mut x79: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x78, &mut x79, x77, ((x57 as u64) + ((x51 as u64) + ((x43 as u64) + x31))), x70); + let mut x80: u64 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x80, &mut x81, 0x0, x74, (arg1[3])); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x82, &mut x83, x81, x76, (0x0 as u64)); + let mut x84: u64 = 0; + let mut x85: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x84, &mut x85, x83, x78, (0x0 as u64)); + let mut x86: u64 = 0; + let mut x87: u64 = 0; + fiat_sm2_mulx_u64(&mut x86, &mut x87, x80, 0xfffffffeffffffff); + let mut x88: u64 = 0; + let mut x89: u64 = 0; + fiat_sm2_mulx_u64(&mut x88, &mut x89, x80, 0xffffffffffffffff); + let mut x90: u64 = 0; + let mut x91: u64 = 0; + fiat_sm2_mulx_u64(&mut x90, &mut x91, x80, 0xffffffff00000000); + let mut x92: u64 = 0; + let mut x93: u64 = 0; + fiat_sm2_mulx_u64(&mut x92, &mut x93, x80, 0xffffffffffffffff); + let mut x94: u64 = 0; + let mut x95: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x94, &mut x95, 0x0, x93, x90); + let mut x96: u64 = 0; + let mut x97: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x96, &mut x97, x95, x91, x88); + let mut x98: u64 = 0; + let mut x99: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x98, &mut x99, x97, x89, x86); + let mut x100: u64 = 0; + let mut x101: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x100, &mut x101, 0x0, x80, x92); + let mut x102: u64 = 0; + let mut x103: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x102, &mut x103, x101, x82, x94); + let mut x104: u64 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x104, &mut x105, x103, x84, x96); + let mut x106: u64 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x106, &mut x107, x105, ((x85 as u64) + ((x79 as u64) + ((x71 as u64) + x59))), x98); + let x108: u64 = ((x107 as u64) + ((x99 as u64) + x87)); + let mut x109: u64 = 0; + let mut x110: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x109, &mut x110, 0x0, x102, 0xffffffffffffffff); + let mut x111: u64 = 0; + let mut x112: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x111, &mut x112, x110, x104, 0xffffffff00000000); + let mut x113: u64 = 0; + let mut x114: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x113, &mut x114, x112, x106, 0xffffffffffffffff); + let mut x115: u64 = 0; + let mut x116: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x115, &mut x116, x114, x108, 0xfffffffeffffffff); + let mut x117: u64 = 0; + let mut x118: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x117, &mut x118, x116, (0x0 as u64), (0x0 as u64)); + let mut x119: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x119, x118, x109, x102); + let mut x120: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x120, x118, x111, x104); + let mut x121: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x121, x118, x113, x106); + let mut x122: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x122, x118, x115, x108); + out1[0] = x119; + out1[1] = x120; + out1[2] = x121; + out1[3] = x122; +} + +/// The function fiat_sm2_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_sm2_to_montgomery(out1: &mut fiat_sm2_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_mulx_u64(&mut x5, &mut x6, x4, 0x400000002); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_sm2_mulx_u64(&mut x7, &mut x8, x4, 0x100000001); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_sm2_mulx_u64(&mut x9, &mut x10, x4, 0x2ffffffff); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_sm2_mulx_u64(&mut x11, &mut x12, x4, 0x200000003); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let mut x19: u64 = 0; + let mut x20: u64 = 0; + fiat_sm2_mulx_u64(&mut x19, &mut x20, x11, 0xfffffffeffffffff); + let mut x21: u64 = 0; + let mut x22: u64 = 0; + fiat_sm2_mulx_u64(&mut x21, &mut x22, x11, 0xffffffffffffffff); + let mut x23: u64 = 0; + let mut x24: u64 = 0; + fiat_sm2_mulx_u64(&mut x23, &mut x24, x11, 0xffffffff00000000); + let mut x25: u64 = 0; + let mut x26: u64 = 0; + fiat_sm2_mulx_u64(&mut x25, &mut x26, x11, 0xffffffffffffffff); + let mut x27: u64 = 0; + let mut x28: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x27, &mut x28, 0x0, x26, x23); + let mut x29: u64 = 0; + let mut x30: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x29, &mut x30, x28, x24, x21); + let mut x31: u64 = 0; + let mut x32: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x31, &mut x32, x30, x22, x19); + let mut x33: u64 = 0; + let mut x34: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x33, &mut x34, 0x0, x11, x25); + let mut x35: u64 = 0; + let mut x36: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x35, &mut x36, x34, x13, x27); + let mut x37: u64 = 0; + let mut x38: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x37, &mut x38, x36, x15, x29); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x39, &mut x40, x38, x17, x31); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x41, &mut x42, x40, ((x18 as u64) + x6), ((x32 as u64) + x20)); + let mut x43: u64 = 0; + let mut x44: u64 = 0; + fiat_sm2_mulx_u64(&mut x43, &mut x44, x1, 0x400000002); + let mut x45: u64 = 0; + let mut x46: u64 = 0; + fiat_sm2_mulx_u64(&mut x45, &mut x46, x1, 0x100000001); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_sm2_mulx_u64(&mut x47, &mut x48, x1, 0x2ffffffff); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_sm2_mulx_u64(&mut x49, &mut x50, x1, 0x200000003); + let mut x51: u64 = 0; + let mut x52: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x51, &mut x52, 0x0, x50, x47); + let mut x53: u64 = 0; + let mut x54: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x53, &mut x54, x52, x48, x45); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x55, &mut x56, x54, x46, x43); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x57, &mut x58, 0x0, x35, x49); + let mut x59: u64 = 0; + let mut x60: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x59, &mut x60, x58, x37, x51); + let mut x61: u64 = 0; + let mut x62: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x61, &mut x62, x60, x39, x53); + let mut x63: u64 = 0; + let mut x64: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x63, &mut x64, x62, x41, x55); + let mut x65: u64 = 0; + let mut x66: u64 = 0; + fiat_sm2_mulx_u64(&mut x65, &mut x66, x57, 0xfffffffeffffffff); + let mut x67: u64 = 0; + let mut x68: u64 = 0; + fiat_sm2_mulx_u64(&mut x67, &mut x68, x57, 0xffffffffffffffff); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_sm2_mulx_u64(&mut x69, &mut x70, x57, 0xffffffff00000000); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_sm2_mulx_u64(&mut x71, &mut x72, x57, 0xffffffffffffffff); + let mut x73: u64 = 0; + let mut x74: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x73, &mut x74, 0x0, x72, x69); + let mut x75: u64 = 0; + let mut x76: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x75, &mut x76, x74, x70, x67); + let mut x77: u64 = 0; + let mut x78: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x77, &mut x78, x76, x68, x65); + let mut x79: u64 = 0; + let mut x80: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x79, &mut x80, 0x0, x57, x71); + let mut x81: u64 = 0; + let mut x82: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x81, &mut x82, x80, x59, x73); + let mut x83: u64 = 0; + let mut x84: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x83, &mut x84, x82, x61, x75); + let mut x85: u64 = 0; + let mut x86: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x85, &mut x86, x84, x63, x77); + let mut x87: u64 = 0; + let mut x88: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x87, &mut x88, x86, (((x64 as u64) + (x42 as u64)) + ((x56 as u64) + x44)), ((x78 as u64) + x66)); + let mut x89: u64 = 0; + let mut x90: u64 = 0; + fiat_sm2_mulx_u64(&mut x89, &mut x90, x2, 0x400000002); + let mut x91: u64 = 0; + let mut x92: u64 = 0; + fiat_sm2_mulx_u64(&mut x91, &mut x92, x2, 0x100000001); + let mut x93: u64 = 0; + let mut x94: u64 = 0; + fiat_sm2_mulx_u64(&mut x93, &mut x94, x2, 0x2ffffffff); + let mut x95: u64 = 0; + let mut x96: u64 = 0; + fiat_sm2_mulx_u64(&mut x95, &mut x96, x2, 0x200000003); + let mut x97: u64 = 0; + let mut x98: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x97, &mut x98, 0x0, x96, x93); + let mut x99: u64 = 0; + let mut x100: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x99, &mut x100, x98, x94, x91); + let mut x101: u64 = 0; + let mut x102: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x101, &mut x102, x100, x92, x89); + let mut x103: u64 = 0; + let mut x104: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x103, &mut x104, 0x0, x81, x95); + let mut x105: u64 = 0; + let mut x106: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x105, &mut x106, x104, x83, x97); + let mut x107: u64 = 0; + let mut x108: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x107, &mut x108, x106, x85, x99); + let mut x109: u64 = 0; + let mut x110: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x109, &mut x110, x108, x87, x101); + let mut x111: u64 = 0; + let mut x112: u64 = 0; + fiat_sm2_mulx_u64(&mut x111, &mut x112, x103, 0xfffffffeffffffff); + let mut x113: u64 = 0; + let mut x114: u64 = 0; + fiat_sm2_mulx_u64(&mut x113, &mut x114, x103, 0xffffffffffffffff); + let mut x115: u64 = 0; + let mut x116: u64 = 0; + fiat_sm2_mulx_u64(&mut x115, &mut x116, x103, 0xffffffff00000000); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_sm2_mulx_u64(&mut x117, &mut x118, x103, 0xffffffffffffffff); + let mut x119: u64 = 0; + let mut x120: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x119, &mut x120, 0x0, x118, x115); + let mut x121: u64 = 0; + let mut x122: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x121, &mut x122, x120, x116, x113); + let mut x123: u64 = 0; + let mut x124: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x123, &mut x124, x122, x114, x111); + let mut x125: u64 = 0; + let mut x126: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x125, &mut x126, 0x0, x103, x117); + let mut x127: u64 = 0; + let mut x128: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x127, &mut x128, x126, x105, x119); + let mut x129: u64 = 0; + let mut x130: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x129, &mut x130, x128, x107, x121); + let mut x131: u64 = 0; + let mut x132: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x131, &mut x132, x130, x109, x123); + let mut x133: u64 = 0; + let mut x134: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x133, &mut x134, x132, (((x110 as u64) + (x88 as u64)) + ((x102 as u64) + x90)), ((x124 as u64) + x112)); + let mut x135: u64 = 0; + let mut x136: u64 = 0; + fiat_sm2_mulx_u64(&mut x135, &mut x136, x3, 0x400000002); + let mut x137: u64 = 0; + let mut x138: u64 = 0; + fiat_sm2_mulx_u64(&mut x137, &mut x138, x3, 0x100000001); + let mut x139: u64 = 0; + let mut x140: u64 = 0; + fiat_sm2_mulx_u64(&mut x139, &mut x140, x3, 0x2ffffffff); + let mut x141: u64 = 0; + let mut x142: u64 = 0; + fiat_sm2_mulx_u64(&mut x141, &mut x142, x3, 0x200000003); + let mut x143: u64 = 0; + let mut x144: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x143, &mut x144, 0x0, x142, x139); + let mut x145: u64 = 0; + let mut x146: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x145, &mut x146, x144, x140, x137); + let mut x147: u64 = 0; + let mut x148: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x147, &mut x148, x146, x138, x135); + let mut x149: u64 = 0; + let mut x150: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x149, &mut x150, 0x0, x127, x141); + let mut x151: u64 = 0; + let mut x152: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x151, &mut x152, x150, x129, x143); + let mut x153: u64 = 0; + let mut x154: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x153, &mut x154, x152, x131, x145); + let mut x155: u64 = 0; + let mut x156: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x155, &mut x156, x154, x133, x147); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_sm2_mulx_u64(&mut x157, &mut x158, x149, 0xfffffffeffffffff); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_sm2_mulx_u64(&mut x159, &mut x160, x149, 0xffffffffffffffff); + let mut x161: u64 = 0; + let mut x162: u64 = 0; + fiat_sm2_mulx_u64(&mut x161, &mut x162, x149, 0xffffffff00000000); + let mut x163: u64 = 0; + let mut x164: u64 = 0; + fiat_sm2_mulx_u64(&mut x163, &mut x164, x149, 0xffffffffffffffff); + let mut x165: u64 = 0; + let mut x166: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x165, &mut x166, 0x0, x164, x161); + let mut x167: u64 = 0; + let mut x168: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x167, &mut x168, x166, x162, x159); + let mut x169: u64 = 0; + let mut x170: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x169, &mut x170, x168, x160, x157); + let mut x171: u64 = 0; + let mut x172: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x171, &mut x172, 0x0, x149, x163); + let mut x173: u64 = 0; + let mut x174: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x173, &mut x174, x172, x151, x165); + let mut x175: u64 = 0; + let mut x176: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x175, &mut x176, x174, x153, x167); + let mut x177: u64 = 0; + let mut x178: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x177, &mut x178, x176, x155, x169); + let mut x179: u64 = 0; + let mut x180: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x179, &mut x180, x178, (((x156 as u64) + (x134 as u64)) + ((x148 as u64) + x136)), ((x170 as u64) + x158)); + let mut x181: u64 = 0; + let mut x182: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x181, &mut x182, 0x0, x173, 0xffffffffffffffff); + let mut x183: u64 = 0; + let mut x184: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x183, &mut x184, x182, x175, 0xffffffff00000000); + let mut x185: u64 = 0; + let mut x186: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x185, &mut x186, x184, x177, 0xffffffffffffffff); + let mut x187: u64 = 0; + let mut x188: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x187, &mut x188, x186, x179, 0xfffffffeffffffff); + let mut x189: u64 = 0; + let mut x190: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x189, &mut x190, x188, (x180 as u64), (0x0 as u64)); + let mut x191: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x191, x190, x181, x173); + let mut x192: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x192, x190, x183, x175); + let mut x193: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x193, x190, x185, x177); + let mut x194: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x194, x190, x187, x179); + out1[0] = x191; + out1[1] = x192; + out1[2] = x193; + out1[3] = x194; +} + +/// The function fiat_sm2_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_sm2_nonzero(out1: &mut u64, arg1: &[u64; 4]) { + let x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/// The function fiat_sm2_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_sm2_selectznz(out1: &mut [u64; 4], arg1: fiat_sm2_u1, arg2: &[u64; 4], arg3: &[u64; 4]) { + let mut x1: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x4, arg1, (arg2[3]), (arg3[3])); + out1[0] = x1; + out1[1] = x2; + out1[2] = x3; + out1[3] = x4; +} + +/// The function fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_set_one(out1: &mut fiat_sm2_montgomery_domain_field_element) { + out1[0] = (0x1 as u64); + out1[1] = 0xffffffff; + out1[2] = (0x0 as u64); + out1[3] = 0x100000000; +} + +/// The function fiat_sm2_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_sm2_msat(out1: &mut [u64; 5]) { + out1[0] = 0xffffffffffffffff; + out1[1] = 0xffffffff00000000; + out1[2] = 0xffffffffffffffff; + out1[3] = 0xfffffffeffffffff; + out1[4] = (0x0 as u64); +} + +/// The function fiat_sm2_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_sm2_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_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u64)); + let x3: fiat_sm2_u1 = (((x1 >> 63) as fiat_sm2_u1) & (((arg3[0]) & (0x1 as u64)) as fiat_sm2_u1)); + let mut x4: u64 = 0; + let mut x5: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u64)); + let mut x6: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x6, x3, arg1, x4); + let mut x7: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x12, &mut x13, 0x0, (0x1 as u64), (!(arg2[0]))); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x14, &mut x15, x13, (0x0 as u64), (!(arg2[1]))); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x16, &mut x17, x15, (0x0 as u64), (!(arg2[2]))); + let mut x18: u64 = 0; + let mut x19: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), (!(arg2[3]))); + let mut x20: u64 = 0; + let mut x21: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), (!(arg2[4]))); + let mut x22: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x22, x3, (arg3[0]), x12); + let mut x23: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x23, x3, (arg3[1]), x14); + let mut x24: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x24, x3, (arg3[2]), x16); + let mut x25: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x25, x3, (arg3[3]), x18); + let mut x26: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x26, x3, (arg3[4]), x20); + let mut x27: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x27, x3, (arg4[0]), (arg5[0])); + let mut x28: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x28, x3, (arg4[1]), (arg5[1])); + let mut x29: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x29, x3, (arg4[2]), (arg5[2])); + let mut x30: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x30, x3, (arg4[3]), (arg5[3])); + let mut x31: u64 = 0; + let mut x32: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x31, &mut x32, 0x0, x27, x27); + let mut x33: u64 = 0; + let mut x34: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x33, &mut x34, x32, x28, x28); + let mut x35: u64 = 0; + let mut x36: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x35, &mut x36, x34, x29, x29); + let mut x37: u64 = 0; + let mut x38: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x37, &mut x38, x36, x30, x30); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x39, &mut x40, 0x0, x31, 0xffffffffffffffff); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x41, &mut x42, x40, x33, 0xffffffff00000000); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x43, &mut x44, x42, x35, 0xffffffffffffffff); + let mut x45: u64 = 0; + let mut x46: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x45, &mut x46, x44, x37, 0xfffffffeffffffff); + let mut x47: u64 = 0; + let mut x48: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x53, &mut x54, 0x0, (0x0 as u64), x52); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x55, &mut x56, x54, (0x0 as u64), x51); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x57, &mut x58, x56, (0x0 as u64), x50); + let mut x59: u64 = 0; + let mut x60: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x59, &mut x60, x58, (0x0 as u64), x49); + let mut x61: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x61, x60, (0x0 as u64), 0xffffffffffffffff); + let mut x62: u64 = 0; + let mut x63: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x62, &mut x63, 0x0, x53, x61); + let mut x64: u64 = 0; + let mut x65: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x64, &mut x65, x63, x55, (x61 & 0xffffffff00000000)); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x66, &mut x67, x65, x57, x61); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x68, &mut x69, x67, x59, (x61 & 0xfffffffeffffffff)); + let mut x70: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x70, x3, (arg5[0]), x62); + let mut x71: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x71, x3, (arg5[1]), x64); + let mut x72: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x72, x3, (arg5[2]), x66); + let mut x73: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x73, x3, (arg5[3]), x68); + let x74: fiat_sm2_u1 = ((x22 & (0x1 as u64)) as fiat_sm2_u1); + let mut x75: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x75, x74, (0x0 as u64), x7); + let mut x76: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x76, x74, (0x0 as u64), x8); + let mut x77: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x77, x74, (0x0 as u64), x9); + let mut x78: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x78, x74, (0x0 as u64), x10); + let mut x79: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x79, x74, (0x0 as u64), x11); + let mut x80: u64 = 0; + let mut x81: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x80, &mut x81, 0x0, x22, x75); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x82, &mut x83, x81, x23, x76); + let mut x84: u64 = 0; + let mut x85: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x84, &mut x85, x83, x24, x77); + let mut x86: u64 = 0; + let mut x87: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x86, &mut x87, x85, x25, x78); + let mut x88: u64 = 0; + let mut x89: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x88, &mut x89, x87, x26, x79); + let mut x90: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x90, x74, (0x0 as u64), x27); + let mut x91: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x91, x74, (0x0 as u64), x28); + let mut x92: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x92, x74, (0x0 as u64), x29); + let mut x93: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x93, x74, (0x0 as u64), x30); + let mut x94: u64 = 0; + let mut x95: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x94, &mut x95, 0x0, x70, x90); + let mut x96: u64 = 0; + let mut x97: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x96, &mut x97, x95, x71, x91); + let mut x98: u64 = 0; + let mut x99: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x98, &mut x99, x97, x72, x92); + let mut x100: u64 = 0; + let mut x101: fiat_sm2_u1 = 0; + fiat_sm2_addcarryx_u64(&mut x100, &mut x101, x99, x73, x93); + let mut x102: u64 = 0; + let mut x103: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x102, &mut x103, 0x0, x94, 0xffffffffffffffff); + let mut x104: u64 = 0; + let mut x105: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x104, &mut x105, x103, x96, 0xffffffff00000000); + let mut x106: u64 = 0; + let mut x107: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x106, &mut x107, x105, x98, 0xffffffffffffffff); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x108, &mut x109, x107, x100, 0xfffffffeffffffff); + let mut x110: u64 = 0; + let mut x111: fiat_sm2_u1 = 0; + fiat_sm2_subborrowx_u64(&mut x110, &mut x111, x109, (x101 as u64), (0x0 as u64)); + let mut x112: u64 = 0; + let mut x113: fiat_sm2_u1 = 0; + fiat_sm2_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_sm2_cmovznz_u64(&mut x119, x48, x39, x31); + let mut x120: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x120, x48, x41, x33); + let mut x121: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x121, x48, x43, x35); + let mut x122: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x122, x48, x45, x37); + let mut x123: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x123, x111, x102, x94); + let mut x124: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x124, x111, x104, x96); + let mut x125: u64 = 0; + fiat_sm2_cmovznz_u64(&mut x125, x111, x106, x98); + let mut x126: u64 = 0; + fiat_sm2_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_sm2_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_sm2_divstep_precomp(out1: &mut [u64; 4]) { + out1[0] = 0x500000028ffffffe; + out1[1] = 0xe80000009ffffffe; + out1[2] = 0xd00000018ffffffe; + out1[3] = 0x280000011ffffffd; +} diff --git a/fiat-rust/src/sm2_scalar_32.rs b/fiat-rust/src/sm2_scalar_32.rs new file mode 100644 index 00000000000..e164fb7743f --- /dev/null +++ b/fiat-rust/src/sm2_scalar_32.rs @@ -0,0 +1,5634 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline sm2_scalar 32 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") +//! +//! 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)] + +/** fiat_sm2_scalar_u1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_scalar_u1 = u8; +/** fiat_sm2_scalar_i1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_scalar_i1 = i8; +/** fiat_sm2_scalar_u2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_scalar_u2 = u8; +/** fiat_sm2_scalar_i2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_scalar_i2 = i8; + +/** The type fiat_sm2_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]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_scalar_montgomery_domain_field_element(pub [u32; 8]); + +impl core::ops::Index for fiat_sm2_scalar_montgomery_domain_field_element { + type Output = u32; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_scalar_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + +/** The type fiat_sm2_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]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_scalar_non_montgomery_domain_field_element(pub [u32; 8]); + +impl core::ops::Index for fiat_sm2_scalar_non_montgomery_domain_field_element { + type Output = u32; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_scalar_non_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + + +/// The function fiat_sm2_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_sm2_scalar_addcarryx_u32(out1: &mut u32, out2: &mut fiat_sm2_scalar_u1, arg1: fiat_sm2_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_sm2_scalar_u1 = ((x1 >> 32) as fiat_sm2_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_sm2_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_sm2_scalar_subborrowx_u32(out1: &mut u32, out2: &mut fiat_sm2_scalar_u1, arg1: fiat_sm2_scalar_u1, arg2: u32, arg3: u32) { + let x1: i64 = (((arg2 as i64) - (arg1 as i64)) - (arg3 as i64)); + let x2: fiat_sm2_scalar_i1 = ((x1 >> 32) as fiat_sm2_scalar_i1); + let x3: u32 = ((x1 & (0xffffffff as i64)) as u32); + *out1 = x3; + *out2 = (((0x0 as fiat_sm2_scalar_i2) - (x2 as fiat_sm2_scalar_i2)) as fiat_sm2_scalar_u1); +} + +/// The function fiat_sm2_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_sm2_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_sm2_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_sm2_scalar_cmovznz_u32(out1: &mut u32, arg1: fiat_sm2_scalar_u1, arg2: u32, arg3: u32) { + let x1: fiat_sm2_scalar_u1 = (!(!arg1)); + let x2: u32 = ((((((0x0 as fiat_sm2_scalar_i2) - (x1 as fiat_sm2_scalar_i2)) as fiat_sm2_scalar_i1) as i64) & (0xffffffff as i64)) as u32); + let x3: u32 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_sm2_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_sm2_scalar_mul(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element, arg2: &fiat_sm2_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_sm2_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg2[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg2[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg2[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg2[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg2[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg2[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg2[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg2[0])); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x40, &mut x41, x23, 0x72350975); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x42, &mut x43, x40, 0xfffffffe); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x44, &mut x45, x40, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x48, &mut x49, x40, 0xffffffff); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x50, &mut x51, x40, 0x7203df6b); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x52, &mut x53, x40, 0x21c6052b); + let mut x54: u32 = 0; + let mut x55: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x54, &mut x55, x40, 0x53bbf409); + let mut x56: u32 = 0; + let mut x57: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x56, &mut x57, x40, 0x39d54123); + let mut x58: u32 = 0; + let mut x59: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x58, &mut x59, 0x0, x57, x54); + let mut x60: u32 = 0; + let mut x61: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x55, x52); + let mut x62: u32 = 0; + let mut x63: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x53, x50); + let mut x64: u32 = 0; + let mut x65: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x51, x48); + let mut x66: u32 = 0; + let mut x67: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x66, &mut x67, x65, x49, x46); + let mut x68: u32 = 0; + let mut x69: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x68, &mut x69, x67, x47, x44); + let mut x70: u32 = 0; + let mut x71: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x73, &mut x74, 0x0, x23, x56); + let mut x75: u32 = 0; + let mut x76: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x25, x58); + let mut x77: u32 = 0; + let mut x78: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x27, x60); + let mut x79: u32 = 0; + let mut x80: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x29, x62); + let mut x81: u32 = 0; + let mut x82: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x31, x64); + let mut x83: u32 = 0; + let mut x84: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x33, x66); + let mut x85: u32 = 0; + let mut x86: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x35, x68); + let mut x87: u32 = 0; + let mut x88: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x87, &mut x88, x86, x37, x70); + let mut x89: u32 = 0; + let mut x90: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x89, &mut x90, x88, x39, x72); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg2[7])); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x93, &mut x94, x1, (arg2[6])); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x95, &mut x96, x1, (arg2[5])); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x97, &mut x98, x1, (arg2[4])); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x99, &mut x100, x1, (arg2[3])); + let mut x101: u32 = 0; + let mut x102: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x101, &mut x102, x1, (arg2[2])); + let mut x103: u32 = 0; + let mut x104: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x103, &mut x104, x1, (arg2[1])); + let mut x105: u32 = 0; + let mut x106: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x105, &mut x106, x1, (arg2[0])); + let mut x107: u32 = 0; + let mut x108: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x107, &mut x108, 0x0, x106, x103); + let mut x109: u32 = 0; + let mut x110: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x104, x101); + let mut x111: u32 = 0; + let mut x112: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x102, x99); + let mut x113: u32 = 0; + let mut x114: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x100, x97); + let mut x115: u32 = 0; + let mut x116: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x98, x95); + let mut x117: u32 = 0; + let mut x118: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x96, x93); + let mut x119: u32 = 0; + let mut x120: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x122, &mut x123, 0x0, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x77, x107); + let mut x126: u32 = 0; + let mut x127: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x79, x109); + let mut x128: u32 = 0; + let mut x129: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x81, x111); + let mut x130: u32 = 0; + let mut x131: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x83, x113); + let mut x132: u32 = 0; + let mut x133: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x85, x115); + let mut x134: u32 = 0; + let mut x135: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x134, &mut x135, x133, x87, x117); + let mut x136: u32 = 0; + let mut x137: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x136, &mut x137, x135, x89, x119); + let mut x138: u32 = 0; + let mut x139: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x138, &mut x139, x137, (x90 as u32), x121); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x140, &mut x141, x122, 0x72350975); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x142, &mut x143, x140, 0xfffffffe); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x144, &mut x145, x140, 0xffffffff); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x146, &mut x147, x140, 0xffffffff); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x148, &mut x149, x140, 0xffffffff); + let mut x150: u32 = 0; + let mut x151: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x150, &mut x151, x140, 0x7203df6b); + let mut x152: u32 = 0; + let mut x153: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x152, &mut x153, x140, 0x21c6052b); + let mut x154: u32 = 0; + let mut x155: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x154, &mut x155, x140, 0x53bbf409); + let mut x156: u32 = 0; + let mut x157: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x156, &mut x157, x140, 0x39d54123); + let mut x158: u32 = 0; + let mut x159: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x158, &mut x159, 0x0, x157, x154); + let mut x160: u32 = 0; + let mut x161: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x155, x152); + let mut x162: u32 = 0; + let mut x163: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x153, x150); + let mut x164: u32 = 0; + let mut x165: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x151, x148); + let mut x166: u32 = 0; + let mut x167: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x149, x146); + let mut x168: u32 = 0; + let mut x169: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x147, x144); + let mut x170: u32 = 0; + let mut x171: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x173, &mut x174, 0x0, x122, x156); + let mut x175: u32 = 0; + let mut x176: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x124, x158); + let mut x177: u32 = 0; + let mut x178: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x126, x160); + let mut x179: u32 = 0; + let mut x180: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x128, x162); + let mut x181: u32 = 0; + let mut x182: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x130, x164); + let mut x183: u32 = 0; + let mut x184: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x183, &mut x184, x182, x132, x166); + let mut x185: u32 = 0; + let mut x186: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x185, &mut x186, x184, x134, x168); + let mut x187: u32 = 0; + let mut x188: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x187, &mut x188, x186, x136, x170); + let mut x189: u32 = 0; + let mut x190: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x192, &mut x193, x2, (arg2[7])); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x194, &mut x195, x2, (arg2[6])); + let mut x196: u32 = 0; + let mut x197: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x196, &mut x197, x2, (arg2[5])); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x198, &mut x199, x2, (arg2[4])); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x200, &mut x201, x2, (arg2[3])); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x202, &mut x203, x2, (arg2[2])); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x204, &mut x205, x2, (arg2[1])); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x206, &mut x207, x2, (arg2[0])); + let mut x208: u32 = 0; + let mut x209: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x208, &mut x209, 0x0, x207, x204); + let mut x210: u32 = 0; + let mut x211: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x210, &mut x211, x209, x205, x202); + let mut x212: u32 = 0; + let mut x213: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x203, x200); + let mut x214: u32 = 0; + let mut x215: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x201, x198); + let mut x216: u32 = 0; + let mut x217: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x216, &mut x217, x215, x199, x196); + let mut x218: u32 = 0; + let mut x219: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x197, x194); + let mut x220: u32 = 0; + let mut x221: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x223, &mut x224, 0x0, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x179, x210); + let mut x229: u32 = 0; + let mut x230: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x181, x212); + let mut x231: u32 = 0; + let mut x232: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x231, &mut x232, x230, x183, x214); + let mut x233: u32 = 0; + let mut x234: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x233, &mut x234, x232, x185, x216); + let mut x235: u32 = 0; + let mut x236: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x235, &mut x236, x234, x187, x218); + let mut x237: u32 = 0; + let mut x238: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x237, &mut x238, x236, x189, x220); + let mut x239: u32 = 0; + let mut x240: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x239, &mut x240, x238, x191, x222); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x241, &mut x242, x223, 0x72350975); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x243, &mut x244, x241, 0xfffffffe); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x245, &mut x246, x241, 0xffffffff); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x247, &mut x248, x241, 0xffffffff); + let mut x249: u32 = 0; + let mut x250: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x249, &mut x250, x241, 0xffffffff); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x251, &mut x252, x241, 0x7203df6b); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x253, &mut x254, x241, 0x21c6052b); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x255, &mut x256, x241, 0x53bbf409); + let mut x257: u32 = 0; + let mut x258: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x257, &mut x258, x241, 0x39d54123); + let mut x259: u32 = 0; + let mut x260: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x259, &mut x260, 0x0, x258, x255); + let mut x261: u32 = 0; + let mut x262: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x256, x253); + let mut x263: u32 = 0; + let mut x264: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x254, x251); + let mut x265: u32 = 0; + let mut x266: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x252, x249); + let mut x267: u32 = 0; + let mut x268: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x250, x247); + let mut x269: u32 = 0; + let mut x270: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x248, x245); + let mut x271: u32 = 0; + let mut x272: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x274, &mut x275, 0x0, x223, x257); + let mut x276: u32 = 0; + let mut x277: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x225, x259); + let mut x278: u32 = 0; + let mut x279: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x278, &mut x279, x277, x227, x261); + let mut x280: u32 = 0; + let mut x281: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x280, &mut x281, x279, x229, x263); + let mut x282: u32 = 0; + let mut x283: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x282, &mut x283, x281, x231, x265); + let mut x284: u32 = 0; + let mut x285: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x233, x267); + let mut x286: u32 = 0; + let mut x287: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x235, x269); + let mut x288: u32 = 0; + let mut x289: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x237, x271); + let mut x290: u32 = 0; + let mut x291: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x293, &mut x294, x3, (arg2[7])); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x295, &mut x296, x3, (arg2[6])); + let mut x297: u32 = 0; + let mut x298: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x297, &mut x298, x3, (arg2[5])); + let mut x299: u32 = 0; + let mut x300: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x299, &mut x300, x3, (arg2[4])); + let mut x301: u32 = 0; + let mut x302: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x301, &mut x302, x3, (arg2[3])); + let mut x303: u32 = 0; + let mut x304: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x303, &mut x304, x3, (arg2[2])); + let mut x305: u32 = 0; + let mut x306: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x305, &mut x306, x3, (arg2[1])); + let mut x307: u32 = 0; + let mut x308: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x307, &mut x308, x3, (arg2[0])); + let mut x309: u32 = 0; + let mut x310: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x309, &mut x310, 0x0, x308, x305); + let mut x311: u32 = 0; + let mut x312: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x311, &mut x312, x310, x306, x303); + let mut x313: u32 = 0; + let mut x314: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x304, x301); + let mut x315: u32 = 0; + let mut x316: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x302, x299); + let mut x317: u32 = 0; + let mut x318: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x300, x297); + let mut x319: u32 = 0; + let mut x320: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x298, x295); + let mut x321: u32 = 0; + let mut x322: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x324, &mut x325, 0x0, x276, x307); + let mut x326: u32 = 0; + let mut x327: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x278, x309); + let mut x328: u32 = 0; + let mut x329: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x280, x311); + let mut x330: u32 = 0; + let mut x331: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x282, x313); + let mut x332: u32 = 0; + let mut x333: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x332, &mut x333, x331, x284, x315); + let mut x334: u32 = 0; + let mut x335: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x334, &mut x335, x333, x286, x317); + let mut x336: u32 = 0; + let mut x337: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x336, &mut x337, x335, x288, x319); + let mut x338: u32 = 0; + let mut x339: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x338, &mut x339, x337, x290, x321); + let mut x340: u32 = 0; + let mut x341: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x340, &mut x341, x339, x292, x323); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x342, &mut x343, x324, 0x72350975); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x344, &mut x345, x342, 0xfffffffe); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x346, &mut x347, x342, 0xffffffff); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x348, &mut x349, x342, 0xffffffff); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x350, &mut x351, x342, 0xffffffff); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x352, &mut x353, x342, 0x7203df6b); + let mut x354: u32 = 0; + let mut x355: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x354, &mut x355, x342, 0x21c6052b); + let mut x356: u32 = 0; + let mut x357: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x356, &mut x357, x342, 0x53bbf409); + let mut x358: u32 = 0; + let mut x359: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x358, &mut x359, x342, 0x39d54123); + let mut x360: u32 = 0; + let mut x361: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x360, &mut x361, 0x0, x359, x356); + let mut x362: u32 = 0; + let mut x363: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x357, x354); + let mut x364: u32 = 0; + let mut x365: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x355, x352); + let mut x366: u32 = 0; + let mut x367: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x353, x350); + let mut x368: u32 = 0; + let mut x369: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x368, &mut x369, x367, x351, x348); + let mut x370: u32 = 0; + let mut x371: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x370, &mut x371, x369, x349, x346); + let mut x372: u32 = 0; + let mut x373: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x375, &mut x376, 0x0, x324, x358); + let mut x377: u32 = 0; + let mut x378: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x326, x360); + let mut x379: u32 = 0; + let mut x380: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x328, x362); + let mut x381: u32 = 0; + let mut x382: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x330, x364); + let mut x383: u32 = 0; + let mut x384: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x332, x366); + let mut x385: u32 = 0; + let mut x386: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x334, x368); + let mut x387: u32 = 0; + let mut x388: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x336, x370); + let mut x389: u32 = 0; + let mut x390: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x338, x372); + let mut x391: u32 = 0; + let mut x392: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x394, &mut x395, x4, (arg2[7])); + let mut x396: u32 = 0; + let mut x397: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x396, &mut x397, x4, (arg2[6])); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x398, &mut x399, x4, (arg2[5])); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x400, &mut x401, x4, (arg2[4])); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x402, &mut x403, x4, (arg2[3])); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x404, &mut x405, x4, (arg2[2])); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x406, &mut x407, x4, (arg2[1])); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x408, &mut x409, x4, (arg2[0])); + let mut x410: u32 = 0; + let mut x411: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x410, &mut x411, 0x0, x409, x406); + let mut x412: u32 = 0; + let mut x413: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x407, x404); + let mut x414: u32 = 0; + let mut x415: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x405, x402); + let mut x416: u32 = 0; + let mut x417: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x403, x400); + let mut x418: u32 = 0; + let mut x419: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x401, x398); + let mut x420: u32 = 0; + let mut x421: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x399, x396); + let mut x422: u32 = 0; + let mut x423: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x425, &mut x426, 0x0, x377, x408); + let mut x427: u32 = 0; + let mut x428: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x427, &mut x428, x426, x379, x410); + let mut x429: u32 = 0; + let mut x430: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x429, &mut x430, x428, x381, x412); + let mut x431: u32 = 0; + let mut x432: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x431, &mut x432, x430, x383, x414); + let mut x433: u32 = 0; + let mut x434: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x433, &mut x434, x432, x385, x416); + let mut x435: u32 = 0; + let mut x436: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x435, &mut x436, x434, x387, x418); + let mut x437: u32 = 0; + let mut x438: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x389, x420); + let mut x439: u32 = 0; + let mut x440: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x391, x422); + let mut x441: u32 = 0; + let mut x442: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x441, &mut x442, x440, x393, x424); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x443, &mut x444, x425, 0x72350975); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x445, &mut x446, x443, 0xfffffffe); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x447, &mut x448, x443, 0xffffffff); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x449, &mut x450, x443, 0xffffffff); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x451, &mut x452, x443, 0xffffffff); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x453, &mut x454, x443, 0x7203df6b); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x455, &mut x456, x443, 0x21c6052b); + let mut x457: u32 = 0; + let mut x458: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x457, &mut x458, x443, 0x53bbf409); + let mut x459: u32 = 0; + let mut x460: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x459, &mut x460, x443, 0x39d54123); + let mut x461: u32 = 0; + let mut x462: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x461, &mut x462, 0x0, x460, x457); + let mut x463: u32 = 0; + let mut x464: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x458, x455); + let mut x465: u32 = 0; + let mut x466: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x456, x453); + let mut x467: u32 = 0; + let mut x468: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x454, x451); + let mut x469: u32 = 0; + let mut x470: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x452, x449); + let mut x471: u32 = 0; + let mut x472: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x450, x447); + let mut x473: u32 = 0; + let mut x474: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x476, &mut x477, 0x0, x425, x459); + let mut x478: u32 = 0; + let mut x479: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x478, &mut x479, x477, x427, x461); + let mut x480: u32 = 0; + let mut x481: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x480, &mut x481, x479, x429, x463); + let mut x482: u32 = 0; + let mut x483: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x431, x465); + let mut x484: u32 = 0; + let mut x485: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x433, x467); + let mut x486: u32 = 0; + let mut x487: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x435, x469); + let mut x488: u32 = 0; + let mut x489: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x437, x471); + let mut x490: u32 = 0; + let mut x491: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x439, x473); + let mut x492: u32 = 0; + let mut x493: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x495, &mut x496, x5, (arg2[7])); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x497, &mut x498, x5, (arg2[6])); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x499, &mut x500, x5, (arg2[5])); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x501, &mut x502, x5, (arg2[4])); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x503, &mut x504, x5, (arg2[3])); + let mut x505: u32 = 0; + let mut x506: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x505, &mut x506, x5, (arg2[2])); + let mut x507: u32 = 0; + let mut x508: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x507, &mut x508, x5, (arg2[1])); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x509, &mut x510, x5, (arg2[0])); + let mut x511: u32 = 0; + let mut x512: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x511, &mut x512, 0x0, x510, x507); + let mut x513: u32 = 0; + let mut x514: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x508, x505); + let mut x515: u32 = 0; + let mut x516: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x506, x503); + let mut x517: u32 = 0; + let mut x518: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x504, x501); + let mut x519: u32 = 0; + let mut x520: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x519, &mut x520, x518, x502, x499); + let mut x521: u32 = 0; + let mut x522: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x521, &mut x522, x520, x500, x497); + let mut x523: u32 = 0; + let mut x524: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x526, &mut x527, 0x0, x478, x509); + let mut x528: u32 = 0; + let mut x529: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x528, &mut x529, x527, x480, x511); + let mut x530: u32 = 0; + let mut x531: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x482, x513); + let mut x532: u32 = 0; + let mut x533: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x484, x515); + let mut x534: u32 = 0; + let mut x535: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x486, x517); + let mut x536: u32 = 0; + let mut x537: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x488, x519); + let mut x538: u32 = 0; + let mut x539: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x490, x521); + let mut x540: u32 = 0; + let mut x541: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x492, x523); + let mut x542: u32 = 0; + let mut x543: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x494, x525); + let mut x544: u32 = 0; + let mut x545: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x544, &mut x545, x526, 0x72350975); + let mut x546: u32 = 0; + let mut x547: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x546, &mut x547, x544, 0xfffffffe); + let mut x548: u32 = 0; + let mut x549: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x548, &mut x549, x544, 0xffffffff); + let mut x550: u32 = 0; + let mut x551: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x550, &mut x551, x544, 0xffffffff); + let mut x552: u32 = 0; + let mut x553: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x552, &mut x553, x544, 0xffffffff); + let mut x554: u32 = 0; + let mut x555: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x554, &mut x555, x544, 0x7203df6b); + let mut x556: u32 = 0; + let mut x557: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x556, &mut x557, x544, 0x21c6052b); + let mut x558: u32 = 0; + let mut x559: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x558, &mut x559, x544, 0x53bbf409); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x560, &mut x561, x544, 0x39d54123); + let mut x562: u32 = 0; + let mut x563: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x562, &mut x563, 0x0, x561, x558); + let mut x564: u32 = 0; + let mut x565: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x564, &mut x565, x563, x559, x556); + let mut x566: u32 = 0; + let mut x567: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x566, &mut x567, x565, x557, x554); + let mut x568: u32 = 0; + let mut x569: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x568, &mut x569, x567, x555, x552); + let mut x570: u32 = 0; + let mut x571: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x570, &mut x571, x569, x553, x550); + let mut x572: u32 = 0; + let mut x573: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x572, &mut x573, x571, x551, x548); + let mut x574: u32 = 0; + let mut x575: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x577, &mut x578, 0x0, x526, x560); + let mut x579: u32 = 0; + let mut x580: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x528, x562); + let mut x581: u32 = 0; + let mut x582: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x581, &mut x582, x580, x530, x564); + let mut x583: u32 = 0; + let mut x584: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x583, &mut x584, x582, x532, x566); + let mut x585: u32 = 0; + let mut x586: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x585, &mut x586, x584, x534, x568); + let mut x587: u32 = 0; + let mut x588: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x536, x570); + let mut x589: u32 = 0; + let mut x590: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x538, x572); + let mut x591: u32 = 0; + let mut x592: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x540, x574); + let mut x593: u32 = 0; + let mut x594: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x596, &mut x597, x6, (arg2[7])); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x598, &mut x599, x6, (arg2[6])); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x600, &mut x601, x6, (arg2[5])); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x602, &mut x603, x6, (arg2[4])); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x604, &mut x605, x6, (arg2[3])); + let mut x606: u32 = 0; + let mut x607: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x606, &mut x607, x6, (arg2[2])); + let mut x608: u32 = 0; + let mut x609: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x608, &mut x609, x6, (arg2[1])); + let mut x610: u32 = 0; + let mut x611: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x610, &mut x611, x6, (arg2[0])); + let mut x612: u32 = 0; + let mut x613: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x612, &mut x613, 0x0, x611, x608); + let mut x614: u32 = 0; + let mut x615: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x614, &mut x615, x613, x609, x606); + let mut x616: u32 = 0; + let mut x617: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x616, &mut x617, x615, x607, x604); + let mut x618: u32 = 0; + let mut x619: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x605, x602); + let mut x620: u32 = 0; + let mut x621: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x603, x600); + let mut x622: u32 = 0; + let mut x623: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x601, x598); + let mut x624: u32 = 0; + let mut x625: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x627, &mut x628, 0x0, x579, x610); + let mut x629: u32 = 0; + let mut x630: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x581, x612); + let mut x631: u32 = 0; + let mut x632: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x583, x614); + let mut x633: u32 = 0; + let mut x634: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x585, x616); + let mut x635: u32 = 0; + let mut x636: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x587, x618); + let mut x637: u32 = 0; + let mut x638: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x589, x620); + let mut x639: u32 = 0; + let mut x640: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x591, x622); + let mut x641: u32 = 0; + let mut x642: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x593, x624); + let mut x643: u32 = 0; + let mut x644: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x595, x626); + let mut x645: u32 = 0; + let mut x646: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x645, &mut x646, x627, 0x72350975); + let mut x647: u32 = 0; + let mut x648: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x647, &mut x648, x645, 0xfffffffe); + let mut x649: u32 = 0; + let mut x650: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x649, &mut x650, x645, 0xffffffff); + let mut x651: u32 = 0; + let mut x652: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x651, &mut x652, x645, 0xffffffff); + let mut x653: u32 = 0; + let mut x654: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x653, &mut x654, x645, 0xffffffff); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x655, &mut x656, x645, 0x7203df6b); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x657, &mut x658, x645, 0x21c6052b); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x659, &mut x660, x645, 0x53bbf409); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x661, &mut x662, x645, 0x39d54123); + let mut x663: u32 = 0; + let mut x664: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x663, &mut x664, 0x0, x662, x659); + let mut x665: u32 = 0; + let mut x666: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x665, &mut x666, x664, x660, x657); + let mut x667: u32 = 0; + let mut x668: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x667, &mut x668, x666, x658, x655); + let mut x669: u32 = 0; + let mut x670: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x656, x653); + let mut x671: u32 = 0; + let mut x672: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x654, x651); + let mut x673: u32 = 0; + let mut x674: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x652, x649); + let mut x675: u32 = 0; + let mut x676: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x678, &mut x679, 0x0, x627, x661); + let mut x680: u32 = 0; + let mut x681: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x680, &mut x681, x679, x629, x663); + let mut x682: u32 = 0; + let mut x683: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x682, &mut x683, x681, x631, x665); + let mut x684: u32 = 0; + let mut x685: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x684, &mut x685, x683, x633, x667); + let mut x686: u32 = 0; + let mut x687: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x686, &mut x687, x685, x635, x669); + let mut x688: u32 = 0; + let mut x689: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x688, &mut x689, x687, x637, x671); + let mut x690: u32 = 0; + let mut x691: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x690, &mut x691, x689, x639, x673); + let mut x692: u32 = 0; + let mut x693: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x692, &mut x693, x691, x641, x675); + let mut x694: u32 = 0; + let mut x695: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x697, &mut x698, x7, (arg2[7])); + let mut x699: u32 = 0; + let mut x700: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x699, &mut x700, x7, (arg2[6])); + let mut x701: u32 = 0; + let mut x702: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x701, &mut x702, x7, (arg2[5])); + let mut x703: u32 = 0; + let mut x704: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x703, &mut x704, x7, (arg2[4])); + let mut x705: u32 = 0; + let mut x706: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x705, &mut x706, x7, (arg2[3])); + let mut x707: u32 = 0; + let mut x708: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x707, &mut x708, x7, (arg2[2])); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x709, &mut x710, x7, (arg2[1])); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x711, &mut x712, x7, (arg2[0])); + let mut x713: u32 = 0; + let mut x714: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x713, &mut x714, 0x0, x712, x709); + let mut x715: u32 = 0; + let mut x716: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x715, &mut x716, x714, x710, x707); + let mut x717: u32 = 0; + let mut x718: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x717, &mut x718, x716, x708, x705); + let mut x719: u32 = 0; + let mut x720: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x719, &mut x720, x718, x706, x703); + let mut x721: u32 = 0; + let mut x722: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x721, &mut x722, x720, x704, x701); + let mut x723: u32 = 0; + let mut x724: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x723, &mut x724, x722, x702, x699); + let mut x725: u32 = 0; + let mut x726: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x728, &mut x729, 0x0, x680, x711); + let mut x730: u32 = 0; + let mut x731: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x730, &mut x731, x729, x682, x713); + let mut x732: u32 = 0; + let mut x733: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x732, &mut x733, x731, x684, x715); + let mut x734: u32 = 0; + let mut x735: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x734, &mut x735, x733, x686, x717); + let mut x736: u32 = 0; + let mut x737: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x736, &mut x737, x735, x688, x719); + let mut x738: u32 = 0; + let mut x739: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x738, &mut x739, x737, x690, x721); + let mut x740: u32 = 0; + let mut x741: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x740, &mut x741, x739, x692, x723); + let mut x742: u32 = 0; + let mut x743: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x742, &mut x743, x741, x694, x725); + let mut x744: u32 = 0; + let mut x745: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x744, &mut x745, x743, x696, x727); + let mut x746: u32 = 0; + let mut x747: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x746, &mut x747, x728, 0x72350975); + let mut x748: u32 = 0; + let mut x749: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x748, &mut x749, x746, 0xfffffffe); + let mut x750: u32 = 0; + let mut x751: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x750, &mut x751, x746, 0xffffffff); + let mut x752: u32 = 0; + let mut x753: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x752, &mut x753, x746, 0xffffffff); + let mut x754: u32 = 0; + let mut x755: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x754, &mut x755, x746, 0xffffffff); + let mut x756: u32 = 0; + let mut x757: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x756, &mut x757, x746, 0x7203df6b); + let mut x758: u32 = 0; + let mut x759: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x758, &mut x759, x746, 0x21c6052b); + let mut x760: u32 = 0; + let mut x761: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x760, &mut x761, x746, 0x53bbf409); + let mut x762: u32 = 0; + let mut x763: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x762, &mut x763, x746, 0x39d54123); + let mut x764: u32 = 0; + let mut x765: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x764, &mut x765, 0x0, x763, x760); + let mut x766: u32 = 0; + let mut x767: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x766, &mut x767, x765, x761, x758); + let mut x768: u32 = 0; + let mut x769: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x768, &mut x769, x767, x759, x756); + let mut x770: u32 = 0; + let mut x771: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x770, &mut x771, x769, x757, x754); + let mut x772: u32 = 0; + let mut x773: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x772, &mut x773, x771, x755, x752); + let mut x774: u32 = 0; + let mut x775: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x774, &mut x775, x773, x753, x750); + let mut x776: u32 = 0; + let mut x777: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x779, &mut x780, 0x0, x728, x762); + let mut x781: u32 = 0; + let mut x782: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x781, &mut x782, x780, x730, x764); + let mut x783: u32 = 0; + let mut x784: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x783, &mut x784, x782, x732, x766); + let mut x785: u32 = 0; + let mut x786: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x785, &mut x786, x784, x734, x768); + let mut x787: u32 = 0; + let mut x788: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x787, &mut x788, x786, x736, x770); + let mut x789: u32 = 0; + let mut x790: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x789, &mut x790, x788, x738, x772); + let mut x791: u32 = 0; + let mut x792: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x791, &mut x792, x790, x740, x774); + let mut x793: u32 = 0; + let mut x794: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x793, &mut x794, x792, x742, x776); + let mut x795: u32 = 0; + let mut x796: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x798, &mut x799, 0x0, x781, 0x39d54123); + let mut x800: u32 = 0; + let mut x801: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x800, &mut x801, x799, x783, 0x53bbf409); + let mut x802: u32 = 0; + let mut x803: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x802, &mut x803, x801, x785, 0x21c6052b); + let mut x804: u32 = 0; + let mut x805: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x804, &mut x805, x803, x787, 0x7203df6b); + let mut x806: u32 = 0; + let mut x807: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x806, &mut x807, x805, x789, 0xffffffff); + let mut x808: u32 = 0; + let mut x809: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x808, &mut x809, x807, x791, 0xffffffff); + let mut x810: u32 = 0; + let mut x811: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x810, &mut x811, x809, x793, 0xffffffff); + let mut x812: u32 = 0; + let mut x813: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x812, &mut x813, x811, x795, 0xfffffffe); + let mut x814: u32 = 0; + let mut x815: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x814, &mut x815, x813, x797, (0x0 as u32)); + let mut x816: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x816, x815, x798, x781); + let mut x817: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x817, x815, x800, x783); + let mut x818: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x818, x815, x802, x785); + let mut x819: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x819, x815, x804, x787); + let mut x820: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x820, x815, x806, x789); + let mut x821: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x821, x815, x808, x791); + let mut x822: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x822, x815, x810, x793); + let mut x823: u32 = 0; + fiat_sm2_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_sm2_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_sm2_scalar_square(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_scalar_mulx_u32(&mut x9, &mut x10, x8, (arg1[7])); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x11, &mut x12, x8, (arg1[6])); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x13, &mut x14, x8, (arg1[5])); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x15, &mut x16, x8, (arg1[4])); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x17, &mut x18, x8, (arg1[3])); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x19, &mut x20, x8, (arg1[2])); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x21, &mut x22, x8, (arg1[1])); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x23, &mut x24, x8, (arg1[0])); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x40, &mut x41, x23, 0x72350975); + let mut x42: u32 = 0; + let mut x43: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x42, &mut x43, x40, 0xfffffffe); + let mut x44: u32 = 0; + let mut x45: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x44, &mut x45, x40, 0xffffffff); + let mut x46: u32 = 0; + let mut x47: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x46, &mut x47, x40, 0xffffffff); + let mut x48: u32 = 0; + let mut x49: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x48, &mut x49, x40, 0xffffffff); + let mut x50: u32 = 0; + let mut x51: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x50, &mut x51, x40, 0x7203df6b); + let mut x52: u32 = 0; + let mut x53: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x52, &mut x53, x40, 0x21c6052b); + let mut x54: u32 = 0; + let mut x55: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x54, &mut x55, x40, 0x53bbf409); + let mut x56: u32 = 0; + let mut x57: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x56, &mut x57, x40, 0x39d54123); + let mut x58: u32 = 0; + let mut x59: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x58, &mut x59, 0x0, x57, x54); + let mut x60: u32 = 0; + let mut x61: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x55, x52); + let mut x62: u32 = 0; + let mut x63: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x53, x50); + let mut x64: u32 = 0; + let mut x65: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x64, &mut x65, x63, x51, x48); + let mut x66: u32 = 0; + let mut x67: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x66, &mut x67, x65, x49, x46); + let mut x68: u32 = 0; + let mut x69: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x68, &mut x69, x67, x47, x44); + let mut x70: u32 = 0; + let mut x71: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x73, &mut x74, 0x0, x23, x56); + let mut x75: u32 = 0; + let mut x76: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x25, x58); + let mut x77: u32 = 0; + let mut x78: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x27, x60); + let mut x79: u32 = 0; + let mut x80: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x29, x62); + let mut x81: u32 = 0; + let mut x82: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x31, x64); + let mut x83: u32 = 0; + let mut x84: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x33, x66); + let mut x85: u32 = 0; + let mut x86: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x35, x68); + let mut x87: u32 = 0; + let mut x88: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x87, &mut x88, x86, x37, x70); + let mut x89: u32 = 0; + let mut x90: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x89, &mut x90, x88, x39, x72); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x91, &mut x92, x1, (arg1[7])); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x93, &mut x94, x1, (arg1[6])); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x95, &mut x96, x1, (arg1[5])); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x97, &mut x98, x1, (arg1[4])); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x99, &mut x100, x1, (arg1[3])); + let mut x101: u32 = 0; + let mut x102: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x101, &mut x102, x1, (arg1[2])); + let mut x103: u32 = 0; + let mut x104: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x103, &mut x104, x1, (arg1[1])); + let mut x105: u32 = 0; + let mut x106: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x105, &mut x106, x1, (arg1[0])); + let mut x107: u32 = 0; + let mut x108: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x107, &mut x108, 0x0, x106, x103); + let mut x109: u32 = 0; + let mut x110: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x104, x101); + let mut x111: u32 = 0; + let mut x112: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x102, x99); + let mut x113: u32 = 0; + let mut x114: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x100, x97); + let mut x115: u32 = 0; + let mut x116: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x98, x95); + let mut x117: u32 = 0; + let mut x118: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x96, x93); + let mut x119: u32 = 0; + let mut x120: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x122, &mut x123, 0x0, x75, x105); + let mut x124: u32 = 0; + let mut x125: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x77, x107); + let mut x126: u32 = 0; + let mut x127: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x79, x109); + let mut x128: u32 = 0; + let mut x129: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x81, x111); + let mut x130: u32 = 0; + let mut x131: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x83, x113); + let mut x132: u32 = 0; + let mut x133: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x132, &mut x133, x131, x85, x115); + let mut x134: u32 = 0; + let mut x135: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x134, &mut x135, x133, x87, x117); + let mut x136: u32 = 0; + let mut x137: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x136, &mut x137, x135, x89, x119); + let mut x138: u32 = 0; + let mut x139: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x138, &mut x139, x137, (x90 as u32), x121); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x140, &mut x141, x122, 0x72350975); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x142, &mut x143, x140, 0xfffffffe); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x144, &mut x145, x140, 0xffffffff); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x146, &mut x147, x140, 0xffffffff); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x148, &mut x149, x140, 0xffffffff); + let mut x150: u32 = 0; + let mut x151: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x150, &mut x151, x140, 0x7203df6b); + let mut x152: u32 = 0; + let mut x153: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x152, &mut x153, x140, 0x21c6052b); + let mut x154: u32 = 0; + let mut x155: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x154, &mut x155, x140, 0x53bbf409); + let mut x156: u32 = 0; + let mut x157: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x156, &mut x157, x140, 0x39d54123); + let mut x158: u32 = 0; + let mut x159: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x158, &mut x159, 0x0, x157, x154); + let mut x160: u32 = 0; + let mut x161: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x155, x152); + let mut x162: u32 = 0; + let mut x163: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x153, x150); + let mut x164: u32 = 0; + let mut x165: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x164, &mut x165, x163, x151, x148); + let mut x166: u32 = 0; + let mut x167: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x149, x146); + let mut x168: u32 = 0; + let mut x169: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x147, x144); + let mut x170: u32 = 0; + let mut x171: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x173, &mut x174, 0x0, x122, x156); + let mut x175: u32 = 0; + let mut x176: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x124, x158); + let mut x177: u32 = 0; + let mut x178: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x126, x160); + let mut x179: u32 = 0; + let mut x180: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x128, x162); + let mut x181: u32 = 0; + let mut x182: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x130, x164); + let mut x183: u32 = 0; + let mut x184: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x183, &mut x184, x182, x132, x166); + let mut x185: u32 = 0; + let mut x186: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x185, &mut x186, x184, x134, x168); + let mut x187: u32 = 0; + let mut x188: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x187, &mut x188, x186, x136, x170); + let mut x189: u32 = 0; + let mut x190: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x192, &mut x193, x2, (arg1[7])); + let mut x194: u32 = 0; + let mut x195: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x194, &mut x195, x2, (arg1[6])); + let mut x196: u32 = 0; + let mut x197: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x196, &mut x197, x2, (arg1[5])); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x198, &mut x199, x2, (arg1[4])); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x200, &mut x201, x2, (arg1[3])); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x202, &mut x203, x2, (arg1[2])); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x204, &mut x205, x2, (arg1[1])); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x206, &mut x207, x2, (arg1[0])); + let mut x208: u32 = 0; + let mut x209: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x208, &mut x209, 0x0, x207, x204); + let mut x210: u32 = 0; + let mut x211: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x210, &mut x211, x209, x205, x202); + let mut x212: u32 = 0; + let mut x213: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x212, &mut x213, x211, x203, x200); + let mut x214: u32 = 0; + let mut x215: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x214, &mut x215, x213, x201, x198); + let mut x216: u32 = 0; + let mut x217: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x216, &mut x217, x215, x199, x196); + let mut x218: u32 = 0; + let mut x219: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x197, x194); + let mut x220: u32 = 0; + let mut x221: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x223, &mut x224, 0x0, x175, x206); + let mut x225: u32 = 0; + let mut x226: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x177, x208); + let mut x227: u32 = 0; + let mut x228: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x179, x210); + let mut x229: u32 = 0; + let mut x230: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x181, x212); + let mut x231: u32 = 0; + let mut x232: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x231, &mut x232, x230, x183, x214); + let mut x233: u32 = 0; + let mut x234: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x233, &mut x234, x232, x185, x216); + let mut x235: u32 = 0; + let mut x236: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x235, &mut x236, x234, x187, x218); + let mut x237: u32 = 0; + let mut x238: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x237, &mut x238, x236, x189, x220); + let mut x239: u32 = 0; + let mut x240: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x239, &mut x240, x238, x191, x222); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x241, &mut x242, x223, 0x72350975); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x243, &mut x244, x241, 0xfffffffe); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x245, &mut x246, x241, 0xffffffff); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x247, &mut x248, x241, 0xffffffff); + let mut x249: u32 = 0; + let mut x250: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x249, &mut x250, x241, 0xffffffff); + let mut x251: u32 = 0; + let mut x252: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x251, &mut x252, x241, 0x7203df6b); + let mut x253: u32 = 0; + let mut x254: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x253, &mut x254, x241, 0x21c6052b); + let mut x255: u32 = 0; + let mut x256: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x255, &mut x256, x241, 0x53bbf409); + let mut x257: u32 = 0; + let mut x258: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x257, &mut x258, x241, 0x39d54123); + let mut x259: u32 = 0; + let mut x260: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x259, &mut x260, 0x0, x258, x255); + let mut x261: u32 = 0; + let mut x262: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x256, x253); + let mut x263: u32 = 0; + let mut x264: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x263, &mut x264, x262, x254, x251); + let mut x265: u32 = 0; + let mut x266: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x252, x249); + let mut x267: u32 = 0; + let mut x268: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x250, x247); + let mut x269: u32 = 0; + let mut x270: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x248, x245); + let mut x271: u32 = 0; + let mut x272: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x274, &mut x275, 0x0, x223, x257); + let mut x276: u32 = 0; + let mut x277: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x276, &mut x277, x275, x225, x259); + let mut x278: u32 = 0; + let mut x279: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x278, &mut x279, x277, x227, x261); + let mut x280: u32 = 0; + let mut x281: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x280, &mut x281, x279, x229, x263); + let mut x282: u32 = 0; + let mut x283: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x282, &mut x283, x281, x231, x265); + let mut x284: u32 = 0; + let mut x285: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x233, x267); + let mut x286: u32 = 0; + let mut x287: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x235, x269); + let mut x288: u32 = 0; + let mut x289: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x237, x271); + let mut x290: u32 = 0; + let mut x291: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x293, &mut x294, x3, (arg1[7])); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x295, &mut x296, x3, (arg1[6])); + let mut x297: u32 = 0; + let mut x298: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x297, &mut x298, x3, (arg1[5])); + let mut x299: u32 = 0; + let mut x300: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x299, &mut x300, x3, (arg1[4])); + let mut x301: u32 = 0; + let mut x302: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x301, &mut x302, x3, (arg1[3])); + let mut x303: u32 = 0; + let mut x304: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x303, &mut x304, x3, (arg1[2])); + let mut x305: u32 = 0; + let mut x306: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x305, &mut x306, x3, (arg1[1])); + let mut x307: u32 = 0; + let mut x308: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x307, &mut x308, x3, (arg1[0])); + let mut x309: u32 = 0; + let mut x310: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x309, &mut x310, 0x0, x308, x305); + let mut x311: u32 = 0; + let mut x312: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x311, &mut x312, x310, x306, x303); + let mut x313: u32 = 0; + let mut x314: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x304, x301); + let mut x315: u32 = 0; + let mut x316: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x302, x299); + let mut x317: u32 = 0; + let mut x318: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x300, x297); + let mut x319: u32 = 0; + let mut x320: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x298, x295); + let mut x321: u32 = 0; + let mut x322: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x324, &mut x325, 0x0, x276, x307); + let mut x326: u32 = 0; + let mut x327: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x278, x309); + let mut x328: u32 = 0; + let mut x329: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x280, x311); + let mut x330: u32 = 0; + let mut x331: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x330, &mut x331, x329, x282, x313); + let mut x332: u32 = 0; + let mut x333: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x332, &mut x333, x331, x284, x315); + let mut x334: u32 = 0; + let mut x335: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x334, &mut x335, x333, x286, x317); + let mut x336: u32 = 0; + let mut x337: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x336, &mut x337, x335, x288, x319); + let mut x338: u32 = 0; + let mut x339: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x338, &mut x339, x337, x290, x321); + let mut x340: u32 = 0; + let mut x341: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x340, &mut x341, x339, x292, x323); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x342, &mut x343, x324, 0x72350975); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x344, &mut x345, x342, 0xfffffffe); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x346, &mut x347, x342, 0xffffffff); + let mut x348: u32 = 0; + let mut x349: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x348, &mut x349, x342, 0xffffffff); + let mut x350: u32 = 0; + let mut x351: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x350, &mut x351, x342, 0xffffffff); + let mut x352: u32 = 0; + let mut x353: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x352, &mut x353, x342, 0x7203df6b); + let mut x354: u32 = 0; + let mut x355: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x354, &mut x355, x342, 0x21c6052b); + let mut x356: u32 = 0; + let mut x357: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x356, &mut x357, x342, 0x53bbf409); + let mut x358: u32 = 0; + let mut x359: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x358, &mut x359, x342, 0x39d54123); + let mut x360: u32 = 0; + let mut x361: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x360, &mut x361, 0x0, x359, x356); + let mut x362: u32 = 0; + let mut x363: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x362, &mut x363, x361, x357, x354); + let mut x364: u32 = 0; + let mut x365: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x355, x352); + let mut x366: u32 = 0; + let mut x367: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x353, x350); + let mut x368: u32 = 0; + let mut x369: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x368, &mut x369, x367, x351, x348); + let mut x370: u32 = 0; + let mut x371: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x370, &mut x371, x369, x349, x346); + let mut x372: u32 = 0; + let mut x373: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x375, &mut x376, 0x0, x324, x358); + let mut x377: u32 = 0; + let mut x378: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x377, &mut x378, x376, x326, x360); + let mut x379: u32 = 0; + let mut x380: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x379, &mut x380, x378, x328, x362); + let mut x381: u32 = 0; + let mut x382: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x381, &mut x382, x380, x330, x364); + let mut x383: u32 = 0; + let mut x384: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x383, &mut x384, x382, x332, x366); + let mut x385: u32 = 0; + let mut x386: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x385, &mut x386, x384, x334, x368); + let mut x387: u32 = 0; + let mut x388: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x387, &mut x388, x386, x336, x370); + let mut x389: u32 = 0; + let mut x390: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x389, &mut x390, x388, x338, x372); + let mut x391: u32 = 0; + let mut x392: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x394, &mut x395, x4, (arg1[7])); + let mut x396: u32 = 0; + let mut x397: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x396, &mut x397, x4, (arg1[6])); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x398, &mut x399, x4, (arg1[5])); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x400, &mut x401, x4, (arg1[4])); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x402, &mut x403, x4, (arg1[3])); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x404, &mut x405, x4, (arg1[2])); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x406, &mut x407, x4, (arg1[1])); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x408, &mut x409, x4, (arg1[0])); + let mut x410: u32 = 0; + let mut x411: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x410, &mut x411, 0x0, x409, x406); + let mut x412: u32 = 0; + let mut x413: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x412, &mut x413, x411, x407, x404); + let mut x414: u32 = 0; + let mut x415: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x414, &mut x415, x413, x405, x402); + let mut x416: u32 = 0; + let mut x417: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x403, x400); + let mut x418: u32 = 0; + let mut x419: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x401, x398); + let mut x420: u32 = 0; + let mut x421: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x399, x396); + let mut x422: u32 = 0; + let mut x423: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x425, &mut x426, 0x0, x377, x408); + let mut x427: u32 = 0; + let mut x428: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x427, &mut x428, x426, x379, x410); + let mut x429: u32 = 0; + let mut x430: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x429, &mut x430, x428, x381, x412); + let mut x431: u32 = 0; + let mut x432: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x431, &mut x432, x430, x383, x414); + let mut x433: u32 = 0; + let mut x434: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x433, &mut x434, x432, x385, x416); + let mut x435: u32 = 0; + let mut x436: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x435, &mut x436, x434, x387, x418); + let mut x437: u32 = 0; + let mut x438: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x437, &mut x438, x436, x389, x420); + let mut x439: u32 = 0; + let mut x440: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x439, &mut x440, x438, x391, x422); + let mut x441: u32 = 0; + let mut x442: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x441, &mut x442, x440, x393, x424); + let mut x443: u32 = 0; + let mut x444: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x443, &mut x444, x425, 0x72350975); + let mut x445: u32 = 0; + let mut x446: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x445, &mut x446, x443, 0xfffffffe); + let mut x447: u32 = 0; + let mut x448: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x447, &mut x448, x443, 0xffffffff); + let mut x449: u32 = 0; + let mut x450: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x449, &mut x450, x443, 0xffffffff); + let mut x451: u32 = 0; + let mut x452: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x451, &mut x452, x443, 0xffffffff); + let mut x453: u32 = 0; + let mut x454: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x453, &mut x454, x443, 0x7203df6b); + let mut x455: u32 = 0; + let mut x456: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x455, &mut x456, x443, 0x21c6052b); + let mut x457: u32 = 0; + let mut x458: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x457, &mut x458, x443, 0x53bbf409); + let mut x459: u32 = 0; + let mut x460: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x459, &mut x460, x443, 0x39d54123); + let mut x461: u32 = 0; + let mut x462: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x461, &mut x462, 0x0, x460, x457); + let mut x463: u32 = 0; + let mut x464: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x458, x455); + let mut x465: u32 = 0; + let mut x466: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x456, x453); + let mut x467: u32 = 0; + let mut x468: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x454, x451); + let mut x469: u32 = 0; + let mut x470: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x452, x449); + let mut x471: u32 = 0; + let mut x472: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x471, &mut x472, x470, x450, x447); + let mut x473: u32 = 0; + let mut x474: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x476, &mut x477, 0x0, x425, x459); + let mut x478: u32 = 0; + let mut x479: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x478, &mut x479, x477, x427, x461); + let mut x480: u32 = 0; + let mut x481: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x480, &mut x481, x479, x429, x463); + let mut x482: u32 = 0; + let mut x483: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x431, x465); + let mut x484: u32 = 0; + let mut x485: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x433, x467); + let mut x486: u32 = 0; + let mut x487: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x435, x469); + let mut x488: u32 = 0; + let mut x489: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x437, x471); + let mut x490: u32 = 0; + let mut x491: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x439, x473); + let mut x492: u32 = 0; + let mut x493: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x495, &mut x496, x5, (arg1[7])); + let mut x497: u32 = 0; + let mut x498: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x497, &mut x498, x5, (arg1[6])); + let mut x499: u32 = 0; + let mut x500: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x499, &mut x500, x5, (arg1[5])); + let mut x501: u32 = 0; + let mut x502: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x501, &mut x502, x5, (arg1[4])); + let mut x503: u32 = 0; + let mut x504: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x503, &mut x504, x5, (arg1[3])); + let mut x505: u32 = 0; + let mut x506: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x505, &mut x506, x5, (arg1[2])); + let mut x507: u32 = 0; + let mut x508: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x507, &mut x508, x5, (arg1[1])); + let mut x509: u32 = 0; + let mut x510: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x509, &mut x510, x5, (arg1[0])); + let mut x511: u32 = 0; + let mut x512: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x511, &mut x512, 0x0, x510, x507); + let mut x513: u32 = 0; + let mut x514: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x508, x505); + let mut x515: u32 = 0; + let mut x516: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x506, x503); + let mut x517: u32 = 0; + let mut x518: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x504, x501); + let mut x519: u32 = 0; + let mut x520: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x519, &mut x520, x518, x502, x499); + let mut x521: u32 = 0; + let mut x522: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x521, &mut x522, x520, x500, x497); + let mut x523: u32 = 0; + let mut x524: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x526, &mut x527, 0x0, x478, x509); + let mut x528: u32 = 0; + let mut x529: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x528, &mut x529, x527, x480, x511); + let mut x530: u32 = 0; + let mut x531: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x530, &mut x531, x529, x482, x513); + let mut x532: u32 = 0; + let mut x533: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x532, &mut x533, x531, x484, x515); + let mut x534: u32 = 0; + let mut x535: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x534, &mut x535, x533, x486, x517); + let mut x536: u32 = 0; + let mut x537: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x536, &mut x537, x535, x488, x519); + let mut x538: u32 = 0; + let mut x539: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x538, &mut x539, x537, x490, x521); + let mut x540: u32 = 0; + let mut x541: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x540, &mut x541, x539, x492, x523); + let mut x542: u32 = 0; + let mut x543: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x542, &mut x543, x541, x494, x525); + let mut x544: u32 = 0; + let mut x545: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x544, &mut x545, x526, 0x72350975); + let mut x546: u32 = 0; + let mut x547: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x546, &mut x547, x544, 0xfffffffe); + let mut x548: u32 = 0; + let mut x549: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x548, &mut x549, x544, 0xffffffff); + let mut x550: u32 = 0; + let mut x551: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x550, &mut x551, x544, 0xffffffff); + let mut x552: u32 = 0; + let mut x553: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x552, &mut x553, x544, 0xffffffff); + let mut x554: u32 = 0; + let mut x555: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x554, &mut x555, x544, 0x7203df6b); + let mut x556: u32 = 0; + let mut x557: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x556, &mut x557, x544, 0x21c6052b); + let mut x558: u32 = 0; + let mut x559: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x558, &mut x559, x544, 0x53bbf409); + let mut x560: u32 = 0; + let mut x561: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x560, &mut x561, x544, 0x39d54123); + let mut x562: u32 = 0; + let mut x563: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x562, &mut x563, 0x0, x561, x558); + let mut x564: u32 = 0; + let mut x565: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x564, &mut x565, x563, x559, x556); + let mut x566: u32 = 0; + let mut x567: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x566, &mut x567, x565, x557, x554); + let mut x568: u32 = 0; + let mut x569: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x568, &mut x569, x567, x555, x552); + let mut x570: u32 = 0; + let mut x571: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x570, &mut x571, x569, x553, x550); + let mut x572: u32 = 0; + let mut x573: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x572, &mut x573, x571, x551, x548); + let mut x574: u32 = 0; + let mut x575: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x577, &mut x578, 0x0, x526, x560); + let mut x579: u32 = 0; + let mut x580: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x579, &mut x580, x578, x528, x562); + let mut x581: u32 = 0; + let mut x582: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x581, &mut x582, x580, x530, x564); + let mut x583: u32 = 0; + let mut x584: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x583, &mut x584, x582, x532, x566); + let mut x585: u32 = 0; + let mut x586: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x585, &mut x586, x584, x534, x568); + let mut x587: u32 = 0; + let mut x588: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x536, x570); + let mut x589: u32 = 0; + let mut x590: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x538, x572); + let mut x591: u32 = 0; + let mut x592: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x540, x574); + let mut x593: u32 = 0; + let mut x594: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x596, &mut x597, x6, (arg1[7])); + let mut x598: u32 = 0; + let mut x599: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x598, &mut x599, x6, (arg1[6])); + let mut x600: u32 = 0; + let mut x601: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x600, &mut x601, x6, (arg1[5])); + let mut x602: u32 = 0; + let mut x603: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x602, &mut x603, x6, (arg1[4])); + let mut x604: u32 = 0; + let mut x605: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x604, &mut x605, x6, (arg1[3])); + let mut x606: u32 = 0; + let mut x607: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x606, &mut x607, x6, (arg1[2])); + let mut x608: u32 = 0; + let mut x609: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x608, &mut x609, x6, (arg1[1])); + let mut x610: u32 = 0; + let mut x611: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x610, &mut x611, x6, (arg1[0])); + let mut x612: u32 = 0; + let mut x613: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x612, &mut x613, 0x0, x611, x608); + let mut x614: u32 = 0; + let mut x615: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x614, &mut x615, x613, x609, x606); + let mut x616: u32 = 0; + let mut x617: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x616, &mut x617, x615, x607, x604); + let mut x618: u32 = 0; + let mut x619: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x618, &mut x619, x617, x605, x602); + let mut x620: u32 = 0; + let mut x621: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x620, &mut x621, x619, x603, x600); + let mut x622: u32 = 0; + let mut x623: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x622, &mut x623, x621, x601, x598); + let mut x624: u32 = 0; + let mut x625: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x627, &mut x628, 0x0, x579, x610); + let mut x629: u32 = 0; + let mut x630: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x629, &mut x630, x628, x581, x612); + let mut x631: u32 = 0; + let mut x632: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x631, &mut x632, x630, x583, x614); + let mut x633: u32 = 0; + let mut x634: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x633, &mut x634, x632, x585, x616); + let mut x635: u32 = 0; + let mut x636: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x587, x618); + let mut x637: u32 = 0; + let mut x638: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x589, x620); + let mut x639: u32 = 0; + let mut x640: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x591, x622); + let mut x641: u32 = 0; + let mut x642: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x593, x624); + let mut x643: u32 = 0; + let mut x644: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x595, x626); + let mut x645: u32 = 0; + let mut x646: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x645, &mut x646, x627, 0x72350975); + let mut x647: u32 = 0; + let mut x648: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x647, &mut x648, x645, 0xfffffffe); + let mut x649: u32 = 0; + let mut x650: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x649, &mut x650, x645, 0xffffffff); + let mut x651: u32 = 0; + let mut x652: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x651, &mut x652, x645, 0xffffffff); + let mut x653: u32 = 0; + let mut x654: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x653, &mut x654, x645, 0xffffffff); + let mut x655: u32 = 0; + let mut x656: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x655, &mut x656, x645, 0x7203df6b); + let mut x657: u32 = 0; + let mut x658: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x657, &mut x658, x645, 0x21c6052b); + let mut x659: u32 = 0; + let mut x660: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x659, &mut x660, x645, 0x53bbf409); + let mut x661: u32 = 0; + let mut x662: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x661, &mut x662, x645, 0x39d54123); + let mut x663: u32 = 0; + let mut x664: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x663, &mut x664, 0x0, x662, x659); + let mut x665: u32 = 0; + let mut x666: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x665, &mut x666, x664, x660, x657); + let mut x667: u32 = 0; + let mut x668: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x667, &mut x668, x666, x658, x655); + let mut x669: u32 = 0; + let mut x670: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x669, &mut x670, x668, x656, x653); + let mut x671: u32 = 0; + let mut x672: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x671, &mut x672, x670, x654, x651); + let mut x673: u32 = 0; + let mut x674: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x673, &mut x674, x672, x652, x649); + let mut x675: u32 = 0; + let mut x676: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x678, &mut x679, 0x0, x627, x661); + let mut x680: u32 = 0; + let mut x681: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x680, &mut x681, x679, x629, x663); + let mut x682: u32 = 0; + let mut x683: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x682, &mut x683, x681, x631, x665); + let mut x684: u32 = 0; + let mut x685: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x684, &mut x685, x683, x633, x667); + let mut x686: u32 = 0; + let mut x687: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x686, &mut x687, x685, x635, x669); + let mut x688: u32 = 0; + let mut x689: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x688, &mut x689, x687, x637, x671); + let mut x690: u32 = 0; + let mut x691: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x690, &mut x691, x689, x639, x673); + let mut x692: u32 = 0; + let mut x693: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x692, &mut x693, x691, x641, x675); + let mut x694: u32 = 0; + let mut x695: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x697, &mut x698, x7, (arg1[7])); + let mut x699: u32 = 0; + let mut x700: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x699, &mut x700, x7, (arg1[6])); + let mut x701: u32 = 0; + let mut x702: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x701, &mut x702, x7, (arg1[5])); + let mut x703: u32 = 0; + let mut x704: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x703, &mut x704, x7, (arg1[4])); + let mut x705: u32 = 0; + let mut x706: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x705, &mut x706, x7, (arg1[3])); + let mut x707: u32 = 0; + let mut x708: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x707, &mut x708, x7, (arg1[2])); + let mut x709: u32 = 0; + let mut x710: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x709, &mut x710, x7, (arg1[1])); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x711, &mut x712, x7, (arg1[0])); + let mut x713: u32 = 0; + let mut x714: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x713, &mut x714, 0x0, x712, x709); + let mut x715: u32 = 0; + let mut x716: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x715, &mut x716, x714, x710, x707); + let mut x717: u32 = 0; + let mut x718: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x717, &mut x718, x716, x708, x705); + let mut x719: u32 = 0; + let mut x720: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x719, &mut x720, x718, x706, x703); + let mut x721: u32 = 0; + let mut x722: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x721, &mut x722, x720, x704, x701); + let mut x723: u32 = 0; + let mut x724: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x723, &mut x724, x722, x702, x699); + let mut x725: u32 = 0; + let mut x726: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x728, &mut x729, 0x0, x680, x711); + let mut x730: u32 = 0; + let mut x731: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x730, &mut x731, x729, x682, x713); + let mut x732: u32 = 0; + let mut x733: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x732, &mut x733, x731, x684, x715); + let mut x734: u32 = 0; + let mut x735: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x734, &mut x735, x733, x686, x717); + let mut x736: u32 = 0; + let mut x737: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x736, &mut x737, x735, x688, x719); + let mut x738: u32 = 0; + let mut x739: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x738, &mut x739, x737, x690, x721); + let mut x740: u32 = 0; + let mut x741: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x740, &mut x741, x739, x692, x723); + let mut x742: u32 = 0; + let mut x743: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x742, &mut x743, x741, x694, x725); + let mut x744: u32 = 0; + let mut x745: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x744, &mut x745, x743, x696, x727); + let mut x746: u32 = 0; + let mut x747: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x746, &mut x747, x728, 0x72350975); + let mut x748: u32 = 0; + let mut x749: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x748, &mut x749, x746, 0xfffffffe); + let mut x750: u32 = 0; + let mut x751: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x750, &mut x751, x746, 0xffffffff); + let mut x752: u32 = 0; + let mut x753: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x752, &mut x753, x746, 0xffffffff); + let mut x754: u32 = 0; + let mut x755: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x754, &mut x755, x746, 0xffffffff); + let mut x756: u32 = 0; + let mut x757: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x756, &mut x757, x746, 0x7203df6b); + let mut x758: u32 = 0; + let mut x759: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x758, &mut x759, x746, 0x21c6052b); + let mut x760: u32 = 0; + let mut x761: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x760, &mut x761, x746, 0x53bbf409); + let mut x762: u32 = 0; + let mut x763: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x762, &mut x763, x746, 0x39d54123); + let mut x764: u32 = 0; + let mut x765: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x764, &mut x765, 0x0, x763, x760); + let mut x766: u32 = 0; + let mut x767: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x766, &mut x767, x765, x761, x758); + let mut x768: u32 = 0; + let mut x769: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x768, &mut x769, x767, x759, x756); + let mut x770: u32 = 0; + let mut x771: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x770, &mut x771, x769, x757, x754); + let mut x772: u32 = 0; + let mut x773: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x772, &mut x773, x771, x755, x752); + let mut x774: u32 = 0; + let mut x775: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x774, &mut x775, x773, x753, x750); + let mut x776: u32 = 0; + let mut x777: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x779, &mut x780, 0x0, x728, x762); + let mut x781: u32 = 0; + let mut x782: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x781, &mut x782, x780, x730, x764); + let mut x783: u32 = 0; + let mut x784: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x783, &mut x784, x782, x732, x766); + let mut x785: u32 = 0; + let mut x786: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x785, &mut x786, x784, x734, x768); + let mut x787: u32 = 0; + let mut x788: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x787, &mut x788, x786, x736, x770); + let mut x789: u32 = 0; + let mut x790: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x789, &mut x790, x788, x738, x772); + let mut x791: u32 = 0; + let mut x792: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x791, &mut x792, x790, x740, x774); + let mut x793: u32 = 0; + let mut x794: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x793, &mut x794, x792, x742, x776); + let mut x795: u32 = 0; + let mut x796: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x798, &mut x799, 0x0, x781, 0x39d54123); + let mut x800: u32 = 0; + let mut x801: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x800, &mut x801, x799, x783, 0x53bbf409); + let mut x802: u32 = 0; + let mut x803: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x802, &mut x803, x801, x785, 0x21c6052b); + let mut x804: u32 = 0; + let mut x805: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x804, &mut x805, x803, x787, 0x7203df6b); + let mut x806: u32 = 0; + let mut x807: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x806, &mut x807, x805, x789, 0xffffffff); + let mut x808: u32 = 0; + let mut x809: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x808, &mut x809, x807, x791, 0xffffffff); + let mut x810: u32 = 0; + let mut x811: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x810, &mut x811, x809, x793, 0xffffffff); + let mut x812: u32 = 0; + let mut x813: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x812, &mut x813, x811, x795, 0xfffffffe); + let mut x814: u32 = 0; + let mut x815: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x814, &mut x815, x813, x797, (0x0 as u32)); + let mut x816: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x816, x815, x798, x781); + let mut x817: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x817, x815, x800, x783); + let mut x818: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x818, x815, x802, x785); + let mut x819: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x819, x815, x804, x787); + let mut x820: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x820, x815, x806, x789); + let mut x821: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x821, x815, x808, x791); + let mut x822: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x822, x815, x810, x793); + let mut x823: u32 = 0; + fiat_sm2_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_sm2_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_sm2_scalar_add(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element, arg2: &fiat_sm2_scalar_montgomery_domain_field_element) { + let mut x1: u32 = 0; + let mut x2: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + let mut x18: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x17, &mut x18, 0x0, x1, 0x39d54123); + let mut x19: u32 = 0; + let mut x20: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x19, &mut x20, x18, x3, 0x53bbf409); + let mut x21: u32 = 0; + let mut x22: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x21, &mut x22, x20, x5, 0x21c6052b); + let mut x23: u32 = 0; + let mut x24: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x23, &mut x24, x22, x7, 0x7203df6b); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x25, &mut x26, x24, x9, 0xffffffff); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x27, &mut x28, x26, x11, 0xffffffff); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x29, &mut x30, x28, x13, 0xffffffff); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x31, &mut x32, x30, x15, 0xfffffffe); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x33, &mut x34, x32, (x16 as u32), (0x0 as u32)); + let mut x35: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x35, x34, x17, x1); + let mut x36: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x36, x34, x19, x3); + let mut x37: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x37, x34, x21, x5); + let mut x38: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x38, x34, x23, x7); + let mut x39: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x39, x34, x25, x9); + let mut x40: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x40, x34, x27, x11); + let mut x41: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x41, x34, x29, x13); + let mut x42: u32 = 0; + fiat_sm2_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_sm2_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_sm2_scalar_sub(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element, arg2: &fiat_sm2_scalar_montgomery_domain_field_element) { + let mut x1: u32 = 0; + let mut x2: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u32 = 0; + let mut x4: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u32 = 0; + let mut x6: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u32 = 0; + let mut x8: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u32 = 0; + let mut x10: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (arg1[4]), (arg2[4])); + let mut x11: u32 = 0; + let mut x12: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (arg1[5]), (arg2[5])); + let mut x13: u32 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (arg1[6]), (arg2[6])); + let mut x15: u32 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (arg1[7]), (arg2[7])); + let mut x17: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0x39d54123)); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0x53bbf409)); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0x21c6052b)); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0x7203df6b)); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, x17); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, x17); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, (x17 & 0xfffffffe)); + 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_sm2_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_sm2_scalar_opp(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element) { + let mut x1: u32 = 0; + let mut x2: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x1, &mut x2, 0x0, (0x0 as u32), (arg1[0])); + let mut x3: u32 = 0; + let mut x4: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x3, &mut x4, x2, (0x0 as u32), (arg1[1])); + let mut x5: u32 = 0; + let mut x6: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x5, &mut x6, x4, (0x0 as u32), (arg1[2])); + let mut x7: u32 = 0; + let mut x8: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x7, &mut x8, x6, (0x0 as u32), (arg1[3])); + let mut x9: u32 = 0; + let mut x10: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x9, &mut x10, x8, (0x0 as u32), (arg1[4])); + let mut x11: u32 = 0; + let mut x12: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x11, &mut x12, x10, (0x0 as u32), (arg1[5])); + let mut x13: u32 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x13, &mut x14, x12, (0x0 as u32), (arg1[6])); + let mut x15: u32 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x15, &mut x16, x14, (0x0 as u32), (arg1[7])); + let mut x17: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x17, x16, (0x0 as u32), 0xffffffff); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x18, &mut x19, 0x0, x1, (x17 & 0x39d54123)); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x20, &mut x21, x19, x3, (x17 & 0x53bbf409)); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x5, (x17 & 0x21c6052b)); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x7, (x17 & 0x7203df6b)); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x9, x17); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x17); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x13, x17); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x15, (x17 & 0xfffffffe)); + 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_sm2_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_sm2_scalar_from_montgomery(out1: &mut fiat_sm2_scalar_non_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element) { + let x1: u32 = (arg1[0]); + let mut x2: u32 = 0; + let mut x3: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x2, &mut x3, x1, 0x72350975); + let mut x4: u32 = 0; + let mut x5: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x4, &mut x5, x2, 0xfffffffe); + let mut x6: u32 = 0; + let mut x7: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x6, &mut x7, x2, 0xffffffff); + let mut x8: u32 = 0; + let mut x9: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x8, &mut x9, x2, 0xffffffff); + let mut x10: u32 = 0; + let mut x11: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x10, &mut x11, x2, 0xffffffff); + let mut x12: u32 = 0; + let mut x13: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x12, &mut x13, x2, 0x7203df6b); + let mut x14: u32 = 0; + let mut x15: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x14, &mut x15, x2, 0x21c6052b); + let mut x16: u32 = 0; + let mut x17: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x16, &mut x17, x2, 0x53bbf409); + let mut x18: u32 = 0; + let mut x19: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x18, &mut x19, x2, 0x39d54123); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x20, &mut x21, 0x0, x19, x16); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x22, &mut x23, x21, x17, x14); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x24, &mut x25, x23, x15, x12); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x26, &mut x27, x25, x13, x10); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x28, &mut x29, x27, x11, x8); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x30, &mut x31, x29, x9, x6); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x32, &mut x33, x31, x7, x4); + let mut x34: u32 = 0; + let mut x35: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x34, &mut x35, 0x0, x1, x18); + let mut x36: u32 = 0; + let mut x37: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x36, &mut x37, x35, (0x0 as u32), x20); + let mut x38: u32 = 0; + let mut x39: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x38, &mut x39, x37, (0x0 as u32), x22); + let mut x40: u32 = 0; + let mut x41: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x40, &mut x41, x39, (0x0 as u32), x24); + let mut x42: u32 = 0; + let mut x43: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x42, &mut x43, x41, (0x0 as u32), x26); + let mut x44: u32 = 0; + let mut x45: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x44, &mut x45, x43, (0x0 as u32), x28); + let mut x46: u32 = 0; + let mut x47: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x46, &mut x47, x45, (0x0 as u32), x30); + let mut x48: u32 = 0; + let mut x49: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x48, &mut x49, x47, (0x0 as u32), x32); + let mut x50: u32 = 0; + let mut x51: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x50, &mut x51, 0x0, x36, (arg1[1])); + let mut x52: u32 = 0; + let mut x53: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x52, &mut x53, x51, x38, (0x0 as u32)); + let mut x54: u32 = 0; + let mut x55: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x54, &mut x55, x53, x40, (0x0 as u32)); + let mut x56: u32 = 0; + let mut x57: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x56, &mut x57, x55, x42, (0x0 as u32)); + let mut x58: u32 = 0; + let mut x59: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x58, &mut x59, x57, x44, (0x0 as u32)); + let mut x60: u32 = 0; + let mut x61: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x60, &mut x61, x59, x46, (0x0 as u32)); + let mut x62: u32 = 0; + let mut x63: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x62, &mut x63, x61, x48, (0x0 as u32)); + let mut x64: u32 = 0; + let mut x65: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x64, &mut x65, x63, ((x49 as u32) + ((x33 as u32) + x5)), (0x0 as u32)); + let mut x66: u32 = 0; + let mut x67: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x66, &mut x67, x50, 0x72350975); + let mut x68: u32 = 0; + let mut x69: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x68, &mut x69, x66, 0xfffffffe); + let mut x70: u32 = 0; + let mut x71: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x70, &mut x71, x66, 0xffffffff); + let mut x72: u32 = 0; + let mut x73: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x72, &mut x73, x66, 0xffffffff); + let mut x74: u32 = 0; + let mut x75: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x74, &mut x75, x66, 0xffffffff); + let mut x76: u32 = 0; + let mut x77: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x76, &mut x77, x66, 0x7203df6b); + let mut x78: u32 = 0; + let mut x79: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x78, &mut x79, x66, 0x21c6052b); + let mut x80: u32 = 0; + let mut x81: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x80, &mut x81, x66, 0x53bbf409); + let mut x82: u32 = 0; + let mut x83: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x82, &mut x83, x66, 0x39d54123); + let mut x84: u32 = 0; + let mut x85: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x84, &mut x85, 0x0, x83, x80); + let mut x86: u32 = 0; + let mut x87: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x86, &mut x87, x85, x81, x78); + let mut x88: u32 = 0; + let mut x89: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x88, &mut x89, x87, x79, x76); + let mut x90: u32 = 0; + let mut x91: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x90, &mut x91, x89, x77, x74); + let mut x92: u32 = 0; + let mut x93: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x92, &mut x93, x91, x75, x72); + let mut x94: u32 = 0; + let mut x95: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x94, &mut x95, x93, x73, x70); + let mut x96: u32 = 0; + let mut x97: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x96, &mut x97, x95, x71, x68); + let mut x98: u32 = 0; + let mut x99: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x98, &mut x99, 0x0, x50, x82); + let mut x100: u32 = 0; + let mut x101: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x100, &mut x101, x99, x52, x84); + let mut x102: u32 = 0; + let mut x103: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x102, &mut x103, x101, x54, x86); + let mut x104: u32 = 0; + let mut x105: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x104, &mut x105, x103, x56, x88); + let mut x106: u32 = 0; + let mut x107: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x106, &mut x107, x105, x58, x90); + let mut x108: u32 = 0; + let mut x109: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x108, &mut x109, x107, x60, x92); + let mut x110: u32 = 0; + let mut x111: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x110, &mut x111, x109, x62, x94); + let mut x112: u32 = 0; + let mut x113: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x64, x96); + let mut x114: u32 = 0; + let mut x115: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x114, &mut x115, x113, (x65 as u32), ((x97 as u32) + x69)); + let mut x116: u32 = 0; + let mut x117: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x116, &mut x117, 0x0, x100, (arg1[2])); + let mut x118: u32 = 0; + let mut x119: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x102, (0x0 as u32)); + let mut x120: u32 = 0; + let mut x121: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x104, (0x0 as u32)); + let mut x122: u32 = 0; + let mut x123: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x106, (0x0 as u32)); + let mut x124: u32 = 0; + let mut x125: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x108, (0x0 as u32)); + let mut x126: u32 = 0; + let mut x127: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x126, &mut x127, x125, x110, (0x0 as u32)); + let mut x128: u32 = 0; + let mut x129: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x128, &mut x129, x127, x112, (0x0 as u32)); + let mut x130: u32 = 0; + let mut x131: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x130, &mut x131, x129, x114, (0x0 as u32)); + let mut x132: u32 = 0; + let mut x133: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x132, &mut x133, x116, 0x72350975); + let mut x134: u32 = 0; + let mut x135: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x134, &mut x135, x132, 0xfffffffe); + let mut x136: u32 = 0; + let mut x137: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x136, &mut x137, x132, 0xffffffff); + let mut x138: u32 = 0; + let mut x139: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x138, &mut x139, x132, 0xffffffff); + let mut x140: u32 = 0; + let mut x141: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x140, &mut x141, x132, 0xffffffff); + let mut x142: u32 = 0; + let mut x143: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x142, &mut x143, x132, 0x7203df6b); + let mut x144: u32 = 0; + let mut x145: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x144, &mut x145, x132, 0x21c6052b); + let mut x146: u32 = 0; + let mut x147: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x146, &mut x147, x132, 0x53bbf409); + let mut x148: u32 = 0; + let mut x149: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x148, &mut x149, x132, 0x39d54123); + let mut x150: u32 = 0; + let mut x151: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x150, &mut x151, 0x0, x149, x146); + let mut x152: u32 = 0; + let mut x153: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x147, x144); + let mut x154: u32 = 0; + let mut x155: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x145, x142); + let mut x156: u32 = 0; + let mut x157: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x143, x140); + let mut x158: u32 = 0; + let mut x159: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x141, x138); + let mut x160: u32 = 0; + let mut x161: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x139, x136); + let mut x162: u32 = 0; + let mut x163: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x162, &mut x163, x161, x137, x134); + let mut x164: u32 = 0; + let mut x165: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x164, &mut x165, 0x0, x116, x148); + let mut x166: u32 = 0; + let mut x167: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x166, &mut x167, x165, x118, x150); + let mut x168: u32 = 0; + let mut x169: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x168, &mut x169, x167, x120, x152); + let mut x170: u32 = 0; + let mut x171: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x170, &mut x171, x169, x122, x154); + let mut x172: u32 = 0; + let mut x173: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x124, x156); + let mut x174: u32 = 0; + let mut x175: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x126, x158); + let mut x176: u32 = 0; + let mut x177: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x128, x160); + let mut x178: u32 = 0; + let mut x179: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x130, x162); + let mut x180: u32 = 0; + let mut x181: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x180, &mut x181, x179, ((x131 as u32) + (x115 as u32)), ((x163 as u32) + x135)); + let mut x182: u32 = 0; + let mut x183: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x182, &mut x183, 0x0, x166, (arg1[3])); + let mut x184: u32 = 0; + let mut x185: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x168, (0x0 as u32)); + let mut x186: u32 = 0; + let mut x187: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x186, &mut x187, x185, x170, (0x0 as u32)); + let mut x188: u32 = 0; + let mut x189: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x188, &mut x189, x187, x172, (0x0 as u32)); + let mut x190: u32 = 0; + let mut x191: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x190, &mut x191, x189, x174, (0x0 as u32)); + let mut x192: u32 = 0; + let mut x193: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x192, &mut x193, x191, x176, (0x0 as u32)); + let mut x194: u32 = 0; + let mut x195: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x194, &mut x195, x193, x178, (0x0 as u32)); + let mut x196: u32 = 0; + let mut x197: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x196, &mut x197, x195, x180, (0x0 as u32)); + let mut x198: u32 = 0; + let mut x199: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x198, &mut x199, x182, 0x72350975); + let mut x200: u32 = 0; + let mut x201: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x200, &mut x201, x198, 0xfffffffe); + let mut x202: u32 = 0; + let mut x203: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x202, &mut x203, x198, 0xffffffff); + let mut x204: u32 = 0; + let mut x205: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x204, &mut x205, x198, 0xffffffff); + let mut x206: u32 = 0; + let mut x207: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x206, &mut x207, x198, 0xffffffff); + let mut x208: u32 = 0; + let mut x209: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x208, &mut x209, x198, 0x7203df6b); + let mut x210: u32 = 0; + let mut x211: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x210, &mut x211, x198, 0x21c6052b); + let mut x212: u32 = 0; + let mut x213: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x212, &mut x213, x198, 0x53bbf409); + let mut x214: u32 = 0; + let mut x215: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x214, &mut x215, x198, 0x39d54123); + let mut x216: u32 = 0; + let mut x217: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x216, &mut x217, 0x0, x215, x212); + let mut x218: u32 = 0; + let mut x219: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x218, &mut x219, x217, x213, x210); + let mut x220: u32 = 0; + let mut x221: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x220, &mut x221, x219, x211, x208); + let mut x222: u32 = 0; + let mut x223: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x222, &mut x223, x221, x209, x206); + let mut x224: u32 = 0; + let mut x225: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x224, &mut x225, x223, x207, x204); + let mut x226: u32 = 0; + let mut x227: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x226, &mut x227, x225, x205, x202); + let mut x228: u32 = 0; + let mut x229: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x228, &mut x229, x227, x203, x200); + let mut x230: u32 = 0; + let mut x231: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x230, &mut x231, 0x0, x182, x214); + let mut x232: u32 = 0; + let mut x233: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x232, &mut x233, x231, x184, x216); + let mut x234: u32 = 0; + let mut x235: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x234, &mut x235, x233, x186, x218); + let mut x236: u32 = 0; + let mut x237: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x236, &mut x237, x235, x188, x220); + let mut x238: u32 = 0; + let mut x239: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x238, &mut x239, x237, x190, x222); + let mut x240: u32 = 0; + let mut x241: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x240, &mut x241, x239, x192, x224); + let mut x242: u32 = 0; + let mut x243: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x242, &mut x243, x241, x194, x226); + let mut x244: u32 = 0; + let mut x245: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x244, &mut x245, x243, x196, x228); + let mut x246: u32 = 0; + let mut x247: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x246, &mut x247, x245, ((x197 as u32) + (x181 as u32)), ((x229 as u32) + x201)); + let mut x248: u32 = 0; + let mut x249: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x248, &mut x249, 0x0, x232, (arg1[4])); + let mut x250: u32 = 0; + let mut x251: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x250, &mut x251, x249, x234, (0x0 as u32)); + let mut x252: u32 = 0; + let mut x253: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x252, &mut x253, x251, x236, (0x0 as u32)); + let mut x254: u32 = 0; + let mut x255: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x254, &mut x255, x253, x238, (0x0 as u32)); + let mut x256: u32 = 0; + let mut x257: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x256, &mut x257, x255, x240, (0x0 as u32)); + let mut x258: u32 = 0; + let mut x259: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x258, &mut x259, x257, x242, (0x0 as u32)); + let mut x260: u32 = 0; + let mut x261: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x260, &mut x261, x259, x244, (0x0 as u32)); + let mut x262: u32 = 0; + let mut x263: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x262, &mut x263, x261, x246, (0x0 as u32)); + let mut x264: u32 = 0; + let mut x265: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x264, &mut x265, x248, 0x72350975); + let mut x266: u32 = 0; + let mut x267: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x266, &mut x267, x264, 0xfffffffe); + let mut x268: u32 = 0; + let mut x269: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x268, &mut x269, x264, 0xffffffff); + let mut x270: u32 = 0; + let mut x271: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x270, &mut x271, x264, 0xffffffff); + let mut x272: u32 = 0; + let mut x273: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x272, &mut x273, x264, 0xffffffff); + let mut x274: u32 = 0; + let mut x275: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x274, &mut x275, x264, 0x7203df6b); + let mut x276: u32 = 0; + let mut x277: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x276, &mut x277, x264, 0x21c6052b); + let mut x278: u32 = 0; + let mut x279: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x278, &mut x279, x264, 0x53bbf409); + let mut x280: u32 = 0; + let mut x281: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x280, &mut x281, x264, 0x39d54123); + let mut x282: u32 = 0; + let mut x283: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x282, &mut x283, 0x0, x281, x278); + let mut x284: u32 = 0; + let mut x285: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x284, &mut x285, x283, x279, x276); + let mut x286: u32 = 0; + let mut x287: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x286, &mut x287, x285, x277, x274); + let mut x288: u32 = 0; + let mut x289: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x288, &mut x289, x287, x275, x272); + let mut x290: u32 = 0; + let mut x291: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x290, &mut x291, x289, x273, x270); + let mut x292: u32 = 0; + let mut x293: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x292, &mut x293, x291, x271, x268); + let mut x294: u32 = 0; + let mut x295: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x294, &mut x295, x293, x269, x266); + let mut x296: u32 = 0; + let mut x297: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x296, &mut x297, 0x0, x248, x280); + let mut x298: u32 = 0; + let mut x299: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x298, &mut x299, x297, x250, x282); + let mut x300: u32 = 0; + let mut x301: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x300, &mut x301, x299, x252, x284); + let mut x302: u32 = 0; + let mut x303: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x302, &mut x303, x301, x254, x286); + let mut x304: u32 = 0; + let mut x305: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x304, &mut x305, x303, x256, x288); + let mut x306: u32 = 0; + let mut x307: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x306, &mut x307, x305, x258, x290); + let mut x308: u32 = 0; + let mut x309: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x308, &mut x309, x307, x260, x292); + let mut x310: u32 = 0; + let mut x311: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x310, &mut x311, x309, x262, x294); + let mut x312: u32 = 0; + let mut x313: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x312, &mut x313, x311, ((x263 as u32) + (x247 as u32)), ((x295 as u32) + x267)); + let mut x314: u32 = 0; + let mut x315: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x314, &mut x315, 0x0, x298, (arg1[5])); + let mut x316: u32 = 0; + let mut x317: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x316, &mut x317, x315, x300, (0x0 as u32)); + let mut x318: u32 = 0; + let mut x319: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x318, &mut x319, x317, x302, (0x0 as u32)); + let mut x320: u32 = 0; + let mut x321: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x320, &mut x321, x319, x304, (0x0 as u32)); + let mut x322: u32 = 0; + let mut x323: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x322, &mut x323, x321, x306, (0x0 as u32)); + let mut x324: u32 = 0; + let mut x325: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x324, &mut x325, x323, x308, (0x0 as u32)); + let mut x326: u32 = 0; + let mut x327: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x326, &mut x327, x325, x310, (0x0 as u32)); + let mut x328: u32 = 0; + let mut x329: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x328, &mut x329, x327, x312, (0x0 as u32)); + let mut x330: u32 = 0; + let mut x331: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x330, &mut x331, x314, 0x72350975); + let mut x332: u32 = 0; + let mut x333: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x332, &mut x333, x330, 0xfffffffe); + let mut x334: u32 = 0; + let mut x335: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x334, &mut x335, x330, 0xffffffff); + let mut x336: u32 = 0; + let mut x337: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x336, &mut x337, x330, 0xffffffff); + let mut x338: u32 = 0; + let mut x339: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x338, &mut x339, x330, 0xffffffff); + let mut x340: u32 = 0; + let mut x341: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x340, &mut x341, x330, 0x7203df6b); + let mut x342: u32 = 0; + let mut x343: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x342, &mut x343, x330, 0x21c6052b); + let mut x344: u32 = 0; + let mut x345: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x344, &mut x345, x330, 0x53bbf409); + let mut x346: u32 = 0; + let mut x347: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x346, &mut x347, x330, 0x39d54123); + let mut x348: u32 = 0; + let mut x349: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x348, &mut x349, 0x0, x347, x344); + let mut x350: u32 = 0; + let mut x351: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x350, &mut x351, x349, x345, x342); + let mut x352: u32 = 0; + let mut x353: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x352, &mut x353, x351, x343, x340); + let mut x354: u32 = 0; + let mut x355: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x354, &mut x355, x353, x341, x338); + let mut x356: u32 = 0; + let mut x357: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x356, &mut x357, x355, x339, x336); + let mut x358: u32 = 0; + let mut x359: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x358, &mut x359, x357, x337, x334); + let mut x360: u32 = 0; + let mut x361: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x360, &mut x361, x359, x335, x332); + let mut x362: u32 = 0; + let mut x363: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x362, &mut x363, 0x0, x314, x346); + let mut x364: u32 = 0; + let mut x365: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x364, &mut x365, x363, x316, x348); + let mut x366: u32 = 0; + let mut x367: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x366, &mut x367, x365, x318, x350); + let mut x368: u32 = 0; + let mut x369: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x368, &mut x369, x367, x320, x352); + let mut x370: u32 = 0; + let mut x371: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x370, &mut x371, x369, x322, x354); + let mut x372: u32 = 0; + let mut x373: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x372, &mut x373, x371, x324, x356); + let mut x374: u32 = 0; + let mut x375: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x374, &mut x375, x373, x326, x358); + let mut x376: u32 = 0; + let mut x377: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x376, &mut x377, x375, x328, x360); + let mut x378: u32 = 0; + let mut x379: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x378, &mut x379, x377, ((x329 as u32) + (x313 as u32)), ((x361 as u32) + x333)); + let mut x380: u32 = 0; + let mut x381: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x380, &mut x381, 0x0, x364, (arg1[6])); + let mut x382: u32 = 0; + let mut x383: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x382, &mut x383, x381, x366, (0x0 as u32)); + let mut x384: u32 = 0; + let mut x385: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x384, &mut x385, x383, x368, (0x0 as u32)); + let mut x386: u32 = 0; + let mut x387: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x386, &mut x387, x385, x370, (0x0 as u32)); + let mut x388: u32 = 0; + let mut x389: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x388, &mut x389, x387, x372, (0x0 as u32)); + let mut x390: u32 = 0; + let mut x391: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x390, &mut x391, x389, x374, (0x0 as u32)); + let mut x392: u32 = 0; + let mut x393: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x392, &mut x393, x391, x376, (0x0 as u32)); + let mut x394: u32 = 0; + let mut x395: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x394, &mut x395, x393, x378, (0x0 as u32)); + let mut x396: u32 = 0; + let mut x397: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x396, &mut x397, x380, 0x72350975); + let mut x398: u32 = 0; + let mut x399: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x398, &mut x399, x396, 0xfffffffe); + let mut x400: u32 = 0; + let mut x401: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x400, &mut x401, x396, 0xffffffff); + let mut x402: u32 = 0; + let mut x403: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x402, &mut x403, x396, 0xffffffff); + let mut x404: u32 = 0; + let mut x405: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x404, &mut x405, x396, 0xffffffff); + let mut x406: u32 = 0; + let mut x407: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x406, &mut x407, x396, 0x7203df6b); + let mut x408: u32 = 0; + let mut x409: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x408, &mut x409, x396, 0x21c6052b); + let mut x410: u32 = 0; + let mut x411: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x410, &mut x411, x396, 0x53bbf409); + let mut x412: u32 = 0; + let mut x413: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x412, &mut x413, x396, 0x39d54123); + let mut x414: u32 = 0; + let mut x415: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x414, &mut x415, 0x0, x413, x410); + let mut x416: u32 = 0; + let mut x417: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x416, &mut x417, x415, x411, x408); + let mut x418: u32 = 0; + let mut x419: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x418, &mut x419, x417, x409, x406); + let mut x420: u32 = 0; + let mut x421: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x420, &mut x421, x419, x407, x404); + let mut x422: u32 = 0; + let mut x423: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x422, &mut x423, x421, x405, x402); + let mut x424: u32 = 0; + let mut x425: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x424, &mut x425, x423, x403, x400); + let mut x426: u32 = 0; + let mut x427: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x426, &mut x427, x425, x401, x398); + let mut x428: u32 = 0; + let mut x429: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x428, &mut x429, 0x0, x380, x412); + let mut x430: u32 = 0; + let mut x431: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x430, &mut x431, x429, x382, x414); + let mut x432: u32 = 0; + let mut x433: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x432, &mut x433, x431, x384, x416); + let mut x434: u32 = 0; + let mut x435: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x434, &mut x435, x433, x386, x418); + let mut x436: u32 = 0; + let mut x437: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x436, &mut x437, x435, x388, x420); + let mut x438: u32 = 0; + let mut x439: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x438, &mut x439, x437, x390, x422); + let mut x440: u32 = 0; + let mut x441: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x440, &mut x441, x439, x392, x424); + let mut x442: u32 = 0; + let mut x443: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x442, &mut x443, x441, x394, x426); + let mut x444: u32 = 0; + let mut x445: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x444, &mut x445, x443, ((x395 as u32) + (x379 as u32)), ((x427 as u32) + x399)); + let mut x446: u32 = 0; + let mut x447: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x446, &mut x447, 0x0, x430, (arg1[7])); + let mut x448: u32 = 0; + let mut x449: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x448, &mut x449, x447, x432, (0x0 as u32)); + let mut x450: u32 = 0; + let mut x451: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x450, &mut x451, x449, x434, (0x0 as u32)); + let mut x452: u32 = 0; + let mut x453: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x452, &mut x453, x451, x436, (0x0 as u32)); + let mut x454: u32 = 0; + let mut x455: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x454, &mut x455, x453, x438, (0x0 as u32)); + let mut x456: u32 = 0; + let mut x457: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x456, &mut x457, x455, x440, (0x0 as u32)); + let mut x458: u32 = 0; + let mut x459: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x458, &mut x459, x457, x442, (0x0 as u32)); + let mut x460: u32 = 0; + let mut x461: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x460, &mut x461, x459, x444, (0x0 as u32)); + let mut x462: u32 = 0; + let mut x463: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x462, &mut x463, x446, 0x72350975); + let mut x464: u32 = 0; + let mut x465: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x464, &mut x465, x462, 0xfffffffe); + let mut x466: u32 = 0; + let mut x467: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x466, &mut x467, x462, 0xffffffff); + let mut x468: u32 = 0; + let mut x469: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x468, &mut x469, x462, 0xffffffff); + let mut x470: u32 = 0; + let mut x471: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x470, &mut x471, x462, 0xffffffff); + let mut x472: u32 = 0; + let mut x473: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x472, &mut x473, x462, 0x7203df6b); + let mut x474: u32 = 0; + let mut x475: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x474, &mut x475, x462, 0x21c6052b); + let mut x476: u32 = 0; + let mut x477: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x476, &mut x477, x462, 0x53bbf409); + let mut x478: u32 = 0; + let mut x479: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x478, &mut x479, x462, 0x39d54123); + let mut x480: u32 = 0; + let mut x481: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x480, &mut x481, 0x0, x479, x476); + let mut x482: u32 = 0; + let mut x483: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x482, &mut x483, x481, x477, x474); + let mut x484: u32 = 0; + let mut x485: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x484, &mut x485, x483, x475, x472); + let mut x486: u32 = 0; + let mut x487: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x486, &mut x487, x485, x473, x470); + let mut x488: u32 = 0; + let mut x489: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x488, &mut x489, x487, x471, x468); + let mut x490: u32 = 0; + let mut x491: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x490, &mut x491, x489, x469, x466); + let mut x492: u32 = 0; + let mut x493: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x492, &mut x493, x491, x467, x464); + let mut x494: u32 = 0; + let mut x495: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x494, &mut x495, 0x0, x446, x478); + let mut x496: u32 = 0; + let mut x497: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x496, &mut x497, x495, x448, x480); + let mut x498: u32 = 0; + let mut x499: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x498, &mut x499, x497, x450, x482); + let mut x500: u32 = 0; + let mut x501: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x500, &mut x501, x499, x452, x484); + let mut x502: u32 = 0; + let mut x503: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x502, &mut x503, x501, x454, x486); + let mut x504: u32 = 0; + let mut x505: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x504, &mut x505, x503, x456, x488); + let mut x506: u32 = 0; + let mut x507: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x506, &mut x507, x505, x458, x490); + let mut x508: u32 = 0; + let mut x509: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x508, &mut x509, x507, x460, x492); + let mut x510: u32 = 0; + let mut x511: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x510, &mut x511, x509, ((x461 as u32) + (x445 as u32)), ((x493 as u32) + x465)); + let mut x512: u32 = 0; + let mut x513: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x512, &mut x513, 0x0, x496, 0x39d54123); + let mut x514: u32 = 0; + let mut x515: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x514, &mut x515, x513, x498, 0x53bbf409); + let mut x516: u32 = 0; + let mut x517: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x516, &mut x517, x515, x500, 0x21c6052b); + let mut x518: u32 = 0; + let mut x519: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x518, &mut x519, x517, x502, 0x7203df6b); + let mut x520: u32 = 0; + let mut x521: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x520, &mut x521, x519, x504, 0xffffffff); + let mut x522: u32 = 0; + let mut x523: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x522, &mut x523, x521, x506, 0xffffffff); + let mut x524: u32 = 0; + let mut x525: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x524, &mut x525, x523, x508, 0xffffffff); + let mut x526: u32 = 0; + let mut x527: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x526, &mut x527, x525, x510, 0xfffffffe); + let mut x528: u32 = 0; + let mut x529: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x528, &mut x529, x527, (x511 as u32), (0x0 as u32)); + let mut x530: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x530, x529, x512, x496); + let mut x531: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x531, x529, x514, x498); + let mut x532: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x532, x529, x516, x500); + let mut x533: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x533, x529, x518, x502); + let mut x534: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x534, x529, x520, x504); + let mut x535: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x535, x529, x522, x506); + let mut x536: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x536, x529, x524, x508); + let mut x537: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x537, x529, x526, x510); + out1[0] = x530; + out1[1] = x531; + out1[2] = x532; + out1[3] = x533; + out1[4] = x534; + out1[5] = x535; + out1[6] = x536; + out1[7] = x537; +} + +/// The function fiat_sm2_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_sm2_scalar_to_montgomery(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_scalar_mulx_u32(&mut x9, &mut x10, x8, 0x1eb5e412); + let mut x11: u32 = 0; + let mut x12: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x11, &mut x12, x8, 0xa22b3d3b); + let mut x13: u32 = 0; + let mut x14: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x13, &mut x14, x8, 0x620fc84c); + let mut x15: u32 = 0; + let mut x16: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x15, &mut x16, x8, 0x3affe0d4); + let mut x17: u32 = 0; + let mut x18: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x17, &mut x18, x8, 0x3464504a); + let mut x19: u32 = 0; + let mut x20: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x19, &mut x20, x8, 0xde6fa2fa); + let mut x21: u32 = 0; + let mut x22: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x21, &mut x22, x8, 0x901192af); + let mut x23: u32 = 0; + let mut x24: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x23, &mut x24, x8, 0x7c114f20); + let mut x25: u32 = 0; + let mut x26: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x25, &mut x26, 0x0, x24, x21); + let mut x27: u32 = 0; + let mut x28: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x27, &mut x28, x26, x22, x19); + let mut x29: u32 = 0; + let mut x30: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x29, &mut x30, x28, x20, x17); + let mut x31: u32 = 0; + let mut x32: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x31, &mut x32, x30, x18, x15); + let mut x33: u32 = 0; + let mut x34: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x33, &mut x34, x32, x16, x13); + let mut x35: u32 = 0; + let mut x36: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x35, &mut x36, x34, x14, x11); + let mut x37: u32 = 0; + let mut x38: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x37, &mut x38, x36, x12, x9); + let mut x39: u32 = 0; + let mut x40: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x39, &mut x40, x23, 0x72350975); + let mut x41: u32 = 0; + let mut x42: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x41, &mut x42, x39, 0xfffffffe); + let mut x43: u32 = 0; + let mut x44: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x43, &mut x44, x39, 0xffffffff); + let mut x45: u32 = 0; + let mut x46: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x45, &mut x46, x39, 0xffffffff); + let mut x47: u32 = 0; + let mut x48: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x47, &mut x48, x39, 0xffffffff); + let mut x49: u32 = 0; + let mut x50: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x49, &mut x50, x39, 0x7203df6b); + let mut x51: u32 = 0; + let mut x52: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x51, &mut x52, x39, 0x21c6052b); + let mut x53: u32 = 0; + let mut x54: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x53, &mut x54, x39, 0x53bbf409); + let mut x55: u32 = 0; + let mut x56: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x55, &mut x56, x39, 0x39d54123); + let mut x57: u32 = 0; + let mut x58: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x57, &mut x58, 0x0, x56, x53); + let mut x59: u32 = 0; + let mut x60: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x54, x51); + let mut x61: u32 = 0; + let mut x62: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x52, x49); + let mut x63: u32 = 0; + let mut x64: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x50, x47); + let mut x65: u32 = 0; + let mut x66: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x48, x45); + let mut x67: u32 = 0; + let mut x68: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x67, &mut x68, x66, x46, x43); + let mut x69: u32 = 0; + let mut x70: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x69, &mut x70, x68, x44, x41); + let mut x71: u32 = 0; + let mut x72: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x71, &mut x72, 0x0, x23, x55); + let mut x73: u32 = 0; + let mut x74: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x73, &mut x74, x72, x25, x57); + let mut x75: u32 = 0; + let mut x76: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x75, &mut x76, x74, x27, x59); + let mut x77: u32 = 0; + let mut x78: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x77, &mut x78, x76, x29, x61); + let mut x79: u32 = 0; + let mut x80: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x79, &mut x80, x78, x31, x63); + let mut x81: u32 = 0; + let mut x82: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x81, &mut x82, x80, x33, x65); + let mut x83: u32 = 0; + let mut x84: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x83, &mut x84, x82, x35, x67); + let mut x85: u32 = 0; + let mut x86: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x85, &mut x86, x84, x37, x69); + let mut x87: u32 = 0; + let mut x88: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x89, &mut x90, x1, 0x1eb5e412); + let mut x91: u32 = 0; + let mut x92: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x91, &mut x92, x1, 0xa22b3d3b); + let mut x93: u32 = 0; + let mut x94: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x93, &mut x94, x1, 0x620fc84c); + let mut x95: u32 = 0; + let mut x96: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x95, &mut x96, x1, 0x3affe0d4); + let mut x97: u32 = 0; + let mut x98: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x97, &mut x98, x1, 0x3464504a); + let mut x99: u32 = 0; + let mut x100: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x99, &mut x100, x1, 0xde6fa2fa); + let mut x101: u32 = 0; + let mut x102: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x101, &mut x102, x1, 0x901192af); + let mut x103: u32 = 0; + let mut x104: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x103, &mut x104, x1, 0x7c114f20); + let mut x105: u32 = 0; + let mut x106: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x105, &mut x106, 0x0, x104, x101); + let mut x107: u32 = 0; + let mut x108: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x107, &mut x108, x106, x102, x99); + let mut x109: u32 = 0; + let mut x110: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x109, &mut x110, x108, x100, x97); + let mut x111: u32 = 0; + let mut x112: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x111, &mut x112, x110, x98, x95); + let mut x113: u32 = 0; + let mut x114: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x113, &mut x114, x112, x96, x93); + let mut x115: u32 = 0; + let mut x116: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x115, &mut x116, x114, x94, x91); + let mut x117: u32 = 0; + let mut x118: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x117, &mut x118, x116, x92, x89); + let mut x119: u32 = 0; + let mut x120: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x119, &mut x120, 0x0, x73, x103); + let mut x121: u32 = 0; + let mut x122: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x121, &mut x122, x120, x75, x105); + let mut x123: u32 = 0; + let mut x124: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x123, &mut x124, x122, x77, x107); + let mut x125: u32 = 0; + let mut x126: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x125, &mut x126, x124, x79, x109); + let mut x127: u32 = 0; + let mut x128: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x127, &mut x128, x126, x81, x111); + let mut x129: u32 = 0; + let mut x130: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x129, &mut x130, x128, x83, x113); + let mut x131: u32 = 0; + let mut x132: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x131, &mut x132, x130, x85, x115); + let mut x133: u32 = 0; + let mut x134: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x133, &mut x134, x132, x87, x117); + let mut x135: u32 = 0; + let mut x136: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x135, &mut x136, x119, 0x72350975); + let mut x137: u32 = 0; + let mut x138: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x137, &mut x138, x135, 0xfffffffe); + let mut x139: u32 = 0; + let mut x140: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x139, &mut x140, x135, 0xffffffff); + let mut x141: u32 = 0; + let mut x142: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x141, &mut x142, x135, 0xffffffff); + let mut x143: u32 = 0; + let mut x144: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x143, &mut x144, x135, 0xffffffff); + let mut x145: u32 = 0; + let mut x146: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x145, &mut x146, x135, 0x7203df6b); + let mut x147: u32 = 0; + let mut x148: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x147, &mut x148, x135, 0x21c6052b); + let mut x149: u32 = 0; + let mut x150: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x149, &mut x150, x135, 0x53bbf409); + let mut x151: u32 = 0; + let mut x152: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x151, &mut x152, x135, 0x39d54123); + let mut x153: u32 = 0; + let mut x154: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x153, &mut x154, 0x0, x152, x149); + let mut x155: u32 = 0; + let mut x156: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x155, &mut x156, x154, x150, x147); + let mut x157: u32 = 0; + let mut x158: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x157, &mut x158, x156, x148, x145); + let mut x159: u32 = 0; + let mut x160: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x159, &mut x160, x158, x146, x143); + let mut x161: u32 = 0; + let mut x162: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x161, &mut x162, x160, x144, x141); + let mut x163: u32 = 0; + let mut x164: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x163, &mut x164, x162, x142, x139); + let mut x165: u32 = 0; + let mut x166: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x165, &mut x166, x164, x140, x137); + let mut x167: u32 = 0; + let mut x168: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x167, &mut x168, 0x0, x119, x151); + let mut x169: u32 = 0; + let mut x170: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x169, &mut x170, x168, x121, x153); + let mut x171: u32 = 0; + let mut x172: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x171, &mut x172, x170, x123, x155); + let mut x173: u32 = 0; + let mut x174: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x173, &mut x174, x172, x125, x157); + let mut x175: u32 = 0; + let mut x176: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x175, &mut x176, x174, x127, x159); + let mut x177: u32 = 0; + let mut x178: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x177, &mut x178, x176, x129, x161); + let mut x179: u32 = 0; + let mut x180: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x179, &mut x180, x178, x131, x163); + let mut x181: u32 = 0; + let mut x182: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x181, &mut x182, x180, x133, x165); + let mut x183: u32 = 0; + let mut x184: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x185, &mut x186, x2, 0x1eb5e412); + let mut x187: u32 = 0; + let mut x188: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x187, &mut x188, x2, 0xa22b3d3b); + let mut x189: u32 = 0; + let mut x190: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x189, &mut x190, x2, 0x620fc84c); + let mut x191: u32 = 0; + let mut x192: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x191, &mut x192, x2, 0x3affe0d4); + let mut x193: u32 = 0; + let mut x194: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x193, &mut x194, x2, 0x3464504a); + let mut x195: u32 = 0; + let mut x196: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x195, &mut x196, x2, 0xde6fa2fa); + let mut x197: u32 = 0; + let mut x198: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x197, &mut x198, x2, 0x901192af); + let mut x199: u32 = 0; + let mut x200: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x199, &mut x200, x2, 0x7c114f20); + let mut x201: u32 = 0; + let mut x202: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x201, &mut x202, 0x0, x200, x197); + let mut x203: u32 = 0; + let mut x204: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x203, &mut x204, x202, x198, x195); + let mut x205: u32 = 0; + let mut x206: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x205, &mut x206, x204, x196, x193); + let mut x207: u32 = 0; + let mut x208: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x207, &mut x208, x206, x194, x191); + let mut x209: u32 = 0; + let mut x210: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x209, &mut x210, x208, x192, x189); + let mut x211: u32 = 0; + let mut x212: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x211, &mut x212, x210, x190, x187); + let mut x213: u32 = 0; + let mut x214: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x213, &mut x214, x212, x188, x185); + let mut x215: u32 = 0; + let mut x216: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x215, &mut x216, 0x0, x169, x199); + let mut x217: u32 = 0; + let mut x218: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x217, &mut x218, x216, x171, x201); + let mut x219: u32 = 0; + let mut x220: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x219, &mut x220, x218, x173, x203); + let mut x221: u32 = 0; + let mut x222: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x221, &mut x222, x220, x175, x205); + let mut x223: u32 = 0; + let mut x224: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x223, &mut x224, x222, x177, x207); + let mut x225: u32 = 0; + let mut x226: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x225, &mut x226, x224, x179, x209); + let mut x227: u32 = 0; + let mut x228: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x227, &mut x228, x226, x181, x211); + let mut x229: u32 = 0; + let mut x230: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x229, &mut x230, x228, x183, x213); + let mut x231: u32 = 0; + let mut x232: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x231, &mut x232, x215, 0x72350975); + let mut x233: u32 = 0; + let mut x234: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x233, &mut x234, x231, 0xfffffffe); + let mut x235: u32 = 0; + let mut x236: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x235, &mut x236, x231, 0xffffffff); + let mut x237: u32 = 0; + let mut x238: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x237, &mut x238, x231, 0xffffffff); + let mut x239: u32 = 0; + let mut x240: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x239, &mut x240, x231, 0xffffffff); + let mut x241: u32 = 0; + let mut x242: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x241, &mut x242, x231, 0x7203df6b); + let mut x243: u32 = 0; + let mut x244: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x243, &mut x244, x231, 0x21c6052b); + let mut x245: u32 = 0; + let mut x246: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x245, &mut x246, x231, 0x53bbf409); + let mut x247: u32 = 0; + let mut x248: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x247, &mut x248, x231, 0x39d54123); + let mut x249: u32 = 0; + let mut x250: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x249, &mut x250, 0x0, x248, x245); + let mut x251: u32 = 0; + let mut x252: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x251, &mut x252, x250, x246, x243); + let mut x253: u32 = 0; + let mut x254: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x253, &mut x254, x252, x244, x241); + let mut x255: u32 = 0; + let mut x256: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x255, &mut x256, x254, x242, x239); + let mut x257: u32 = 0; + let mut x258: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x257, &mut x258, x256, x240, x237); + let mut x259: u32 = 0; + let mut x260: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x259, &mut x260, x258, x238, x235); + let mut x261: u32 = 0; + let mut x262: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x261, &mut x262, x260, x236, x233); + let mut x263: u32 = 0; + let mut x264: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x263, &mut x264, 0x0, x215, x247); + let mut x265: u32 = 0; + let mut x266: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x265, &mut x266, x264, x217, x249); + let mut x267: u32 = 0; + let mut x268: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x267, &mut x268, x266, x219, x251); + let mut x269: u32 = 0; + let mut x270: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x269, &mut x270, x268, x221, x253); + let mut x271: u32 = 0; + let mut x272: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x271, &mut x272, x270, x223, x255); + let mut x273: u32 = 0; + let mut x274: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x273, &mut x274, x272, x225, x257); + let mut x275: u32 = 0; + let mut x276: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x275, &mut x276, x274, x227, x259); + let mut x277: u32 = 0; + let mut x278: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x277, &mut x278, x276, x229, x261); + let mut x279: u32 = 0; + let mut x280: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x281, &mut x282, x3, 0x1eb5e412); + let mut x283: u32 = 0; + let mut x284: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x283, &mut x284, x3, 0xa22b3d3b); + let mut x285: u32 = 0; + let mut x286: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x285, &mut x286, x3, 0x620fc84c); + let mut x287: u32 = 0; + let mut x288: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x287, &mut x288, x3, 0x3affe0d4); + let mut x289: u32 = 0; + let mut x290: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x289, &mut x290, x3, 0x3464504a); + let mut x291: u32 = 0; + let mut x292: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x291, &mut x292, x3, 0xde6fa2fa); + let mut x293: u32 = 0; + let mut x294: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x293, &mut x294, x3, 0x901192af); + let mut x295: u32 = 0; + let mut x296: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x295, &mut x296, x3, 0x7c114f20); + let mut x297: u32 = 0; + let mut x298: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x297, &mut x298, 0x0, x296, x293); + let mut x299: u32 = 0; + let mut x300: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x299, &mut x300, x298, x294, x291); + let mut x301: u32 = 0; + let mut x302: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x301, &mut x302, x300, x292, x289); + let mut x303: u32 = 0; + let mut x304: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x303, &mut x304, x302, x290, x287); + let mut x305: u32 = 0; + let mut x306: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x305, &mut x306, x304, x288, x285); + let mut x307: u32 = 0; + let mut x308: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x307, &mut x308, x306, x286, x283); + let mut x309: u32 = 0; + let mut x310: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x309, &mut x310, x308, x284, x281); + let mut x311: u32 = 0; + let mut x312: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x311, &mut x312, 0x0, x265, x295); + let mut x313: u32 = 0; + let mut x314: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x313, &mut x314, x312, x267, x297); + let mut x315: u32 = 0; + let mut x316: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x315, &mut x316, x314, x269, x299); + let mut x317: u32 = 0; + let mut x318: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x317, &mut x318, x316, x271, x301); + let mut x319: u32 = 0; + let mut x320: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x319, &mut x320, x318, x273, x303); + let mut x321: u32 = 0; + let mut x322: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x321, &mut x322, x320, x275, x305); + let mut x323: u32 = 0; + let mut x324: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x323, &mut x324, x322, x277, x307); + let mut x325: u32 = 0; + let mut x326: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x325, &mut x326, x324, x279, x309); + let mut x327: u32 = 0; + let mut x328: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x327, &mut x328, x311, 0x72350975); + let mut x329: u32 = 0; + let mut x330: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x329, &mut x330, x327, 0xfffffffe); + let mut x331: u32 = 0; + let mut x332: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x331, &mut x332, x327, 0xffffffff); + let mut x333: u32 = 0; + let mut x334: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x333, &mut x334, x327, 0xffffffff); + let mut x335: u32 = 0; + let mut x336: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x335, &mut x336, x327, 0xffffffff); + let mut x337: u32 = 0; + let mut x338: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x337, &mut x338, x327, 0x7203df6b); + let mut x339: u32 = 0; + let mut x340: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x339, &mut x340, x327, 0x21c6052b); + let mut x341: u32 = 0; + let mut x342: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x341, &mut x342, x327, 0x53bbf409); + let mut x343: u32 = 0; + let mut x344: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x343, &mut x344, x327, 0x39d54123); + let mut x345: u32 = 0; + let mut x346: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x345, &mut x346, 0x0, x344, x341); + let mut x347: u32 = 0; + let mut x348: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x347, &mut x348, x346, x342, x339); + let mut x349: u32 = 0; + let mut x350: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x349, &mut x350, x348, x340, x337); + let mut x351: u32 = 0; + let mut x352: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x351, &mut x352, x350, x338, x335); + let mut x353: u32 = 0; + let mut x354: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x353, &mut x354, x352, x336, x333); + let mut x355: u32 = 0; + let mut x356: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x355, &mut x356, x354, x334, x331); + let mut x357: u32 = 0; + let mut x358: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x357, &mut x358, x356, x332, x329); + let mut x359: u32 = 0; + let mut x360: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x359, &mut x360, 0x0, x311, x343); + let mut x361: u32 = 0; + let mut x362: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x361, &mut x362, x360, x313, x345); + let mut x363: u32 = 0; + let mut x364: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x363, &mut x364, x362, x315, x347); + let mut x365: u32 = 0; + let mut x366: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x365, &mut x366, x364, x317, x349); + let mut x367: u32 = 0; + let mut x368: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x367, &mut x368, x366, x319, x351); + let mut x369: u32 = 0; + let mut x370: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x369, &mut x370, x368, x321, x353); + let mut x371: u32 = 0; + let mut x372: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x371, &mut x372, x370, x323, x355); + let mut x373: u32 = 0; + let mut x374: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x373, &mut x374, x372, x325, x357); + let mut x375: u32 = 0; + let mut x376: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x377, &mut x378, x4, 0x1eb5e412); + let mut x379: u32 = 0; + let mut x380: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x379, &mut x380, x4, 0xa22b3d3b); + let mut x381: u32 = 0; + let mut x382: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x381, &mut x382, x4, 0x620fc84c); + let mut x383: u32 = 0; + let mut x384: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x383, &mut x384, x4, 0x3affe0d4); + let mut x385: u32 = 0; + let mut x386: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x385, &mut x386, x4, 0x3464504a); + let mut x387: u32 = 0; + let mut x388: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x387, &mut x388, x4, 0xde6fa2fa); + let mut x389: u32 = 0; + let mut x390: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x389, &mut x390, x4, 0x901192af); + let mut x391: u32 = 0; + let mut x392: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x391, &mut x392, x4, 0x7c114f20); + let mut x393: u32 = 0; + let mut x394: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x393, &mut x394, 0x0, x392, x389); + let mut x395: u32 = 0; + let mut x396: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x395, &mut x396, x394, x390, x387); + let mut x397: u32 = 0; + let mut x398: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x397, &mut x398, x396, x388, x385); + let mut x399: u32 = 0; + let mut x400: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x399, &mut x400, x398, x386, x383); + let mut x401: u32 = 0; + let mut x402: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x401, &mut x402, x400, x384, x381); + let mut x403: u32 = 0; + let mut x404: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x403, &mut x404, x402, x382, x379); + let mut x405: u32 = 0; + let mut x406: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x405, &mut x406, x404, x380, x377); + let mut x407: u32 = 0; + let mut x408: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x407, &mut x408, 0x0, x361, x391); + let mut x409: u32 = 0; + let mut x410: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x409, &mut x410, x408, x363, x393); + let mut x411: u32 = 0; + let mut x412: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x411, &mut x412, x410, x365, x395); + let mut x413: u32 = 0; + let mut x414: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x413, &mut x414, x412, x367, x397); + let mut x415: u32 = 0; + let mut x416: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x415, &mut x416, x414, x369, x399); + let mut x417: u32 = 0; + let mut x418: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x417, &mut x418, x416, x371, x401); + let mut x419: u32 = 0; + let mut x420: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x419, &mut x420, x418, x373, x403); + let mut x421: u32 = 0; + let mut x422: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x421, &mut x422, x420, x375, x405); + let mut x423: u32 = 0; + let mut x424: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x423, &mut x424, x407, 0x72350975); + let mut x425: u32 = 0; + let mut x426: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x425, &mut x426, x423, 0xfffffffe); + let mut x427: u32 = 0; + let mut x428: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x427, &mut x428, x423, 0xffffffff); + let mut x429: u32 = 0; + let mut x430: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x429, &mut x430, x423, 0xffffffff); + let mut x431: u32 = 0; + let mut x432: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x431, &mut x432, x423, 0xffffffff); + let mut x433: u32 = 0; + let mut x434: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x433, &mut x434, x423, 0x7203df6b); + let mut x435: u32 = 0; + let mut x436: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x435, &mut x436, x423, 0x21c6052b); + let mut x437: u32 = 0; + let mut x438: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x437, &mut x438, x423, 0x53bbf409); + let mut x439: u32 = 0; + let mut x440: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x439, &mut x440, x423, 0x39d54123); + let mut x441: u32 = 0; + let mut x442: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x441, &mut x442, 0x0, x440, x437); + let mut x443: u32 = 0; + let mut x444: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x443, &mut x444, x442, x438, x435); + let mut x445: u32 = 0; + let mut x446: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x445, &mut x446, x444, x436, x433); + let mut x447: u32 = 0; + let mut x448: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x447, &mut x448, x446, x434, x431); + let mut x449: u32 = 0; + let mut x450: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x449, &mut x450, x448, x432, x429); + let mut x451: u32 = 0; + let mut x452: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x451, &mut x452, x450, x430, x427); + let mut x453: u32 = 0; + let mut x454: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x453, &mut x454, x452, x428, x425); + let mut x455: u32 = 0; + let mut x456: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x455, &mut x456, 0x0, x407, x439); + let mut x457: u32 = 0; + let mut x458: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x457, &mut x458, x456, x409, x441); + let mut x459: u32 = 0; + let mut x460: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x459, &mut x460, x458, x411, x443); + let mut x461: u32 = 0; + let mut x462: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x461, &mut x462, x460, x413, x445); + let mut x463: u32 = 0; + let mut x464: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x463, &mut x464, x462, x415, x447); + let mut x465: u32 = 0; + let mut x466: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x465, &mut x466, x464, x417, x449); + let mut x467: u32 = 0; + let mut x468: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x467, &mut x468, x466, x419, x451); + let mut x469: u32 = 0; + let mut x470: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x469, &mut x470, x468, x421, x453); + let mut x471: u32 = 0; + let mut x472: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x473, &mut x474, x5, 0x1eb5e412); + let mut x475: u32 = 0; + let mut x476: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x475, &mut x476, x5, 0xa22b3d3b); + let mut x477: u32 = 0; + let mut x478: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x477, &mut x478, x5, 0x620fc84c); + let mut x479: u32 = 0; + let mut x480: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x479, &mut x480, x5, 0x3affe0d4); + let mut x481: u32 = 0; + let mut x482: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x481, &mut x482, x5, 0x3464504a); + let mut x483: u32 = 0; + let mut x484: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x483, &mut x484, x5, 0xde6fa2fa); + let mut x485: u32 = 0; + let mut x486: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x485, &mut x486, x5, 0x901192af); + let mut x487: u32 = 0; + let mut x488: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x487, &mut x488, x5, 0x7c114f20); + let mut x489: u32 = 0; + let mut x490: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x489, &mut x490, 0x0, x488, x485); + let mut x491: u32 = 0; + let mut x492: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x491, &mut x492, x490, x486, x483); + let mut x493: u32 = 0; + let mut x494: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x493, &mut x494, x492, x484, x481); + let mut x495: u32 = 0; + let mut x496: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x495, &mut x496, x494, x482, x479); + let mut x497: u32 = 0; + let mut x498: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x497, &mut x498, x496, x480, x477); + let mut x499: u32 = 0; + let mut x500: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x499, &mut x500, x498, x478, x475); + let mut x501: u32 = 0; + let mut x502: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x501, &mut x502, x500, x476, x473); + let mut x503: u32 = 0; + let mut x504: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x503, &mut x504, 0x0, x457, x487); + let mut x505: u32 = 0; + let mut x506: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x505, &mut x506, x504, x459, x489); + let mut x507: u32 = 0; + let mut x508: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x507, &mut x508, x506, x461, x491); + let mut x509: u32 = 0; + let mut x510: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x509, &mut x510, x508, x463, x493); + let mut x511: u32 = 0; + let mut x512: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x511, &mut x512, x510, x465, x495); + let mut x513: u32 = 0; + let mut x514: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x513, &mut x514, x512, x467, x497); + let mut x515: u32 = 0; + let mut x516: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x515, &mut x516, x514, x469, x499); + let mut x517: u32 = 0; + let mut x518: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x517, &mut x518, x516, x471, x501); + let mut x519: u32 = 0; + let mut x520: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x519, &mut x520, x503, 0x72350975); + let mut x521: u32 = 0; + let mut x522: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x521, &mut x522, x519, 0xfffffffe); + let mut x523: u32 = 0; + let mut x524: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x523, &mut x524, x519, 0xffffffff); + let mut x525: u32 = 0; + let mut x526: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x525, &mut x526, x519, 0xffffffff); + let mut x527: u32 = 0; + let mut x528: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x527, &mut x528, x519, 0xffffffff); + let mut x529: u32 = 0; + let mut x530: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x529, &mut x530, x519, 0x7203df6b); + let mut x531: u32 = 0; + let mut x532: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x531, &mut x532, x519, 0x21c6052b); + let mut x533: u32 = 0; + let mut x534: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x533, &mut x534, x519, 0x53bbf409); + let mut x535: u32 = 0; + let mut x536: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x535, &mut x536, x519, 0x39d54123); + let mut x537: u32 = 0; + let mut x538: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x537, &mut x538, 0x0, x536, x533); + let mut x539: u32 = 0; + let mut x540: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x539, &mut x540, x538, x534, x531); + let mut x541: u32 = 0; + let mut x542: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x541, &mut x542, x540, x532, x529); + let mut x543: u32 = 0; + let mut x544: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x543, &mut x544, x542, x530, x527); + let mut x545: u32 = 0; + let mut x546: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x545, &mut x546, x544, x528, x525); + let mut x547: u32 = 0; + let mut x548: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x547, &mut x548, x546, x526, x523); + let mut x549: u32 = 0; + let mut x550: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x549, &mut x550, x548, x524, x521); + let mut x551: u32 = 0; + let mut x552: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x551, &mut x552, 0x0, x503, x535); + let mut x553: u32 = 0; + let mut x554: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x553, &mut x554, x552, x505, x537); + let mut x555: u32 = 0; + let mut x556: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x555, &mut x556, x554, x507, x539); + let mut x557: u32 = 0; + let mut x558: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x557, &mut x558, x556, x509, x541); + let mut x559: u32 = 0; + let mut x560: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x559, &mut x560, x558, x511, x543); + let mut x561: u32 = 0; + let mut x562: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x561, &mut x562, x560, x513, x545); + let mut x563: u32 = 0; + let mut x564: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x563, &mut x564, x562, x515, x547); + let mut x565: u32 = 0; + let mut x566: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x565, &mut x566, x564, x517, x549); + let mut x567: u32 = 0; + let mut x568: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x569, &mut x570, x6, 0x1eb5e412); + let mut x571: u32 = 0; + let mut x572: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x571, &mut x572, x6, 0xa22b3d3b); + let mut x573: u32 = 0; + let mut x574: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x573, &mut x574, x6, 0x620fc84c); + let mut x575: u32 = 0; + let mut x576: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x575, &mut x576, x6, 0x3affe0d4); + let mut x577: u32 = 0; + let mut x578: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x577, &mut x578, x6, 0x3464504a); + let mut x579: u32 = 0; + let mut x580: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x579, &mut x580, x6, 0xde6fa2fa); + let mut x581: u32 = 0; + let mut x582: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x581, &mut x582, x6, 0x901192af); + let mut x583: u32 = 0; + let mut x584: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x583, &mut x584, x6, 0x7c114f20); + let mut x585: u32 = 0; + let mut x586: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x585, &mut x586, 0x0, x584, x581); + let mut x587: u32 = 0; + let mut x588: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x587, &mut x588, x586, x582, x579); + let mut x589: u32 = 0; + let mut x590: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x589, &mut x590, x588, x580, x577); + let mut x591: u32 = 0; + let mut x592: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x591, &mut x592, x590, x578, x575); + let mut x593: u32 = 0; + let mut x594: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x593, &mut x594, x592, x576, x573); + let mut x595: u32 = 0; + let mut x596: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x595, &mut x596, x594, x574, x571); + let mut x597: u32 = 0; + let mut x598: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x597, &mut x598, x596, x572, x569); + let mut x599: u32 = 0; + let mut x600: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x599, &mut x600, 0x0, x553, x583); + let mut x601: u32 = 0; + let mut x602: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x601, &mut x602, x600, x555, x585); + let mut x603: u32 = 0; + let mut x604: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x603, &mut x604, x602, x557, x587); + let mut x605: u32 = 0; + let mut x606: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x605, &mut x606, x604, x559, x589); + let mut x607: u32 = 0; + let mut x608: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x607, &mut x608, x606, x561, x591); + let mut x609: u32 = 0; + let mut x610: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x609, &mut x610, x608, x563, x593); + let mut x611: u32 = 0; + let mut x612: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x611, &mut x612, x610, x565, x595); + let mut x613: u32 = 0; + let mut x614: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x613, &mut x614, x612, x567, x597); + let mut x615: u32 = 0; + let mut x616: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x615, &mut x616, x599, 0x72350975); + let mut x617: u32 = 0; + let mut x618: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x617, &mut x618, x615, 0xfffffffe); + let mut x619: u32 = 0; + let mut x620: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x619, &mut x620, x615, 0xffffffff); + let mut x621: u32 = 0; + let mut x622: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x621, &mut x622, x615, 0xffffffff); + let mut x623: u32 = 0; + let mut x624: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x623, &mut x624, x615, 0xffffffff); + let mut x625: u32 = 0; + let mut x626: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x625, &mut x626, x615, 0x7203df6b); + let mut x627: u32 = 0; + let mut x628: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x627, &mut x628, x615, 0x21c6052b); + let mut x629: u32 = 0; + let mut x630: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x629, &mut x630, x615, 0x53bbf409); + let mut x631: u32 = 0; + let mut x632: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x631, &mut x632, x615, 0x39d54123); + let mut x633: u32 = 0; + let mut x634: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x633, &mut x634, 0x0, x632, x629); + let mut x635: u32 = 0; + let mut x636: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x635, &mut x636, x634, x630, x627); + let mut x637: u32 = 0; + let mut x638: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x637, &mut x638, x636, x628, x625); + let mut x639: u32 = 0; + let mut x640: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x639, &mut x640, x638, x626, x623); + let mut x641: u32 = 0; + let mut x642: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x641, &mut x642, x640, x624, x621); + let mut x643: u32 = 0; + let mut x644: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x643, &mut x644, x642, x622, x619); + let mut x645: u32 = 0; + let mut x646: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x645, &mut x646, x644, x620, x617); + let mut x647: u32 = 0; + let mut x648: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x647, &mut x648, 0x0, x599, x631); + let mut x649: u32 = 0; + let mut x650: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x649, &mut x650, x648, x601, x633); + let mut x651: u32 = 0; + let mut x652: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x651, &mut x652, x650, x603, x635); + let mut x653: u32 = 0; + let mut x654: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x653, &mut x654, x652, x605, x637); + let mut x655: u32 = 0; + let mut x656: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x655, &mut x656, x654, x607, x639); + let mut x657: u32 = 0; + let mut x658: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x657, &mut x658, x656, x609, x641); + let mut x659: u32 = 0; + let mut x660: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x659, &mut x660, x658, x611, x643); + let mut x661: u32 = 0; + let mut x662: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x661, &mut x662, x660, x613, x645); + let mut x663: u32 = 0; + let mut x664: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u32(&mut x665, &mut x666, x7, 0x1eb5e412); + let mut x667: u32 = 0; + let mut x668: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x667, &mut x668, x7, 0xa22b3d3b); + let mut x669: u32 = 0; + let mut x670: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x669, &mut x670, x7, 0x620fc84c); + let mut x671: u32 = 0; + let mut x672: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x671, &mut x672, x7, 0x3affe0d4); + let mut x673: u32 = 0; + let mut x674: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x673, &mut x674, x7, 0x3464504a); + let mut x675: u32 = 0; + let mut x676: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x675, &mut x676, x7, 0xde6fa2fa); + let mut x677: u32 = 0; + let mut x678: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x677, &mut x678, x7, 0x901192af); + let mut x679: u32 = 0; + let mut x680: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x679, &mut x680, x7, 0x7c114f20); + let mut x681: u32 = 0; + let mut x682: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x681, &mut x682, 0x0, x680, x677); + let mut x683: u32 = 0; + let mut x684: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x683, &mut x684, x682, x678, x675); + let mut x685: u32 = 0; + let mut x686: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x685, &mut x686, x684, x676, x673); + let mut x687: u32 = 0; + let mut x688: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x687, &mut x688, x686, x674, x671); + let mut x689: u32 = 0; + let mut x690: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x689, &mut x690, x688, x672, x669); + let mut x691: u32 = 0; + let mut x692: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x691, &mut x692, x690, x670, x667); + let mut x693: u32 = 0; + let mut x694: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x693, &mut x694, x692, x668, x665); + let mut x695: u32 = 0; + let mut x696: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x695, &mut x696, 0x0, x649, x679); + let mut x697: u32 = 0; + let mut x698: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x697, &mut x698, x696, x651, x681); + let mut x699: u32 = 0; + let mut x700: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x699, &mut x700, x698, x653, x683); + let mut x701: u32 = 0; + let mut x702: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x701, &mut x702, x700, x655, x685); + let mut x703: u32 = 0; + let mut x704: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x703, &mut x704, x702, x657, x687); + let mut x705: u32 = 0; + let mut x706: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x705, &mut x706, x704, x659, x689); + let mut x707: u32 = 0; + let mut x708: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x707, &mut x708, x706, x661, x691); + let mut x709: u32 = 0; + let mut x710: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x709, &mut x710, x708, x663, x693); + let mut x711: u32 = 0; + let mut x712: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x711, &mut x712, x695, 0x72350975); + let mut x713: u32 = 0; + let mut x714: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x713, &mut x714, x711, 0xfffffffe); + let mut x715: u32 = 0; + let mut x716: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x715, &mut x716, x711, 0xffffffff); + let mut x717: u32 = 0; + let mut x718: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x717, &mut x718, x711, 0xffffffff); + let mut x719: u32 = 0; + let mut x720: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x719, &mut x720, x711, 0xffffffff); + let mut x721: u32 = 0; + let mut x722: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x721, &mut x722, x711, 0x7203df6b); + let mut x723: u32 = 0; + let mut x724: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x723, &mut x724, x711, 0x21c6052b); + let mut x725: u32 = 0; + let mut x726: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x725, &mut x726, x711, 0x53bbf409); + let mut x727: u32 = 0; + let mut x728: u32 = 0; + fiat_sm2_scalar_mulx_u32(&mut x727, &mut x728, x711, 0x39d54123); + let mut x729: u32 = 0; + let mut x730: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x729, &mut x730, 0x0, x728, x725); + let mut x731: u32 = 0; + let mut x732: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x731, &mut x732, x730, x726, x723); + let mut x733: u32 = 0; + let mut x734: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x733, &mut x734, x732, x724, x721); + let mut x735: u32 = 0; + let mut x736: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x735, &mut x736, x734, x722, x719); + let mut x737: u32 = 0; + let mut x738: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x737, &mut x738, x736, x720, x717); + let mut x739: u32 = 0; + let mut x740: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x739, &mut x740, x738, x718, x715); + let mut x741: u32 = 0; + let mut x742: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x741, &mut x742, x740, x716, x713); + let mut x743: u32 = 0; + let mut x744: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x743, &mut x744, 0x0, x695, x727); + let mut x745: u32 = 0; + let mut x746: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x745, &mut x746, x744, x697, x729); + let mut x747: u32 = 0; + let mut x748: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x747, &mut x748, x746, x699, x731); + let mut x749: u32 = 0; + let mut x750: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x749, &mut x750, x748, x701, x733); + let mut x751: u32 = 0; + let mut x752: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x751, &mut x752, x750, x703, x735); + let mut x753: u32 = 0; + let mut x754: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x753, &mut x754, x752, x705, x737); + let mut x755: u32 = 0; + let mut x756: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x755, &mut x756, x754, x707, x739); + let mut x757: u32 = 0; + let mut x758: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x757, &mut x758, x756, x709, x741); + let mut x759: u32 = 0; + let mut x760: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x761, &mut x762, 0x0, x745, 0x39d54123); + let mut x763: u32 = 0; + let mut x764: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x763, &mut x764, x762, x747, 0x53bbf409); + let mut x765: u32 = 0; + let mut x766: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x765, &mut x766, x764, x749, 0x21c6052b); + let mut x767: u32 = 0; + let mut x768: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x767, &mut x768, x766, x751, 0x7203df6b); + let mut x769: u32 = 0; + let mut x770: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x769, &mut x770, x768, x753, 0xffffffff); + let mut x771: u32 = 0; + let mut x772: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x771, &mut x772, x770, x755, 0xffffffff); + let mut x773: u32 = 0; + let mut x774: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x773, &mut x774, x772, x757, 0xffffffff); + let mut x775: u32 = 0; + let mut x776: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x775, &mut x776, x774, x759, 0xfffffffe); + let mut x777: u32 = 0; + let mut x778: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x777, &mut x778, x776, (x760 as u32), (0x0 as u32)); + let mut x779: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x779, x778, x761, x745); + let mut x780: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x780, x778, x763, x747); + let mut x781: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x781, x778, x765, x749); + let mut x782: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x782, x778, x767, x751); + let mut x783: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x783, x778, x769, x753); + let mut x784: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x784, x778, x771, x755); + let mut x785: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x785, x778, x773, x757); + let mut x786: u32 = 0; + fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_scalar_selectznz(out1: &mut [u32; 8], arg1: fiat_sm2_scalar_u1, arg2: &[u32; 8], arg3: &[u32; 8]) { + let mut x1: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x4, arg1, (arg2[3]), (arg3[3])); + let mut x5: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x5, arg1, (arg2[4]), (arg3[4])); + let mut x6: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x6, arg1, (arg2[5]), (arg3[5])); + let mut x7: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x7, arg1, (arg2[6]), (arg3[6])); + let mut x8: u32 = 0; + fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_scalar_set_one(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element) { + out1[0] = 0xc62abedd; + out1[1] = 0xac440bf6; + out1[2] = 0xde39fad4; + out1[3] = 0x8dfc2094; + out1[4] = (0x0 as u32); + out1[5] = (0x0 as u32); + out1[6] = (0x0 as u32); + out1[7] = (0x1 as u32); +} + +/// The function fiat_sm2_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_sm2_scalar_msat(out1: &mut [u32; 9]) { + out1[0] = 0x39d54123; + out1[1] = 0x53bbf409; + out1[2] = 0x21c6052b; + out1[3] = 0x7203df6b; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffffe; + out1[8] = (0x0 as u32); +} + +/// The function fiat_sm2_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_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u32)); + let x3: fiat_sm2_scalar_u1 = (((x1 >> 31) as fiat_sm2_scalar_u1) & (((arg3[0]) & (0x1 as u32)) as fiat_sm2_scalar_u1)); + let mut x4: u32 = 0; + let mut x5: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u32)); + let mut x6: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x6, x3, arg1, x4); + let mut x7: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x12, x3, (arg2[5]), (arg3[5])); + let mut x13: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x13, x3, (arg2[6]), (arg3[6])); + let mut x14: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x14, x3, (arg2[7]), (arg3[7])); + let mut x15: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x15, x3, (arg2[8]), (arg3[8])); + let mut x16: u32 = 0; + let mut x17: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x16, &mut x17, 0x0, (0x1 as u32), (!(arg2[0]))); + let mut x18: u32 = 0; + let mut x19: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x18, &mut x19, x17, (0x0 as u32), (!(arg2[1]))); + let mut x20: u32 = 0; + let mut x21: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x20, &mut x21, x19, (0x0 as u32), (!(arg2[2]))); + let mut x22: u32 = 0; + let mut x23: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x22, &mut x23, x21, (0x0 as u32), (!(arg2[3]))); + let mut x24: u32 = 0; + let mut x25: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x24, &mut x25, x23, (0x0 as u32), (!(arg2[4]))); + let mut x26: u32 = 0; + let mut x27: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x26, &mut x27, x25, (0x0 as u32), (!(arg2[5]))); + let mut x28: u32 = 0; + let mut x29: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x28, &mut x29, x27, (0x0 as u32), (!(arg2[6]))); + let mut x30: u32 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x30, &mut x31, x29, (0x0 as u32), (!(arg2[7]))); + let mut x32: u32 = 0; + let mut x33: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x32, &mut x33, x31, (0x0 as u32), (!(arg2[8]))); + let mut x34: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x34, x3, (arg3[0]), x16); + let mut x35: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x35, x3, (arg3[1]), x18); + let mut x36: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x36, x3, (arg3[2]), x20); + let mut x37: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x37, x3, (arg3[3]), x22); + let mut x38: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x38, x3, (arg3[4]), x24); + let mut x39: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x39, x3, (arg3[5]), x26); + let mut x40: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x40, x3, (arg3[6]), x28); + let mut x41: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x41, x3, (arg3[7]), x30); + let mut x42: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x42, x3, (arg3[8]), x32); + let mut x43: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x43, x3, (arg4[0]), (arg5[0])); + let mut x44: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x44, x3, (arg4[1]), (arg5[1])); + let mut x45: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x45, x3, (arg4[2]), (arg5[2])); + let mut x46: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x46, x3, (arg4[3]), (arg5[3])); + let mut x47: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x47, x3, (arg4[4]), (arg5[4])); + let mut x48: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x48, x3, (arg4[5]), (arg5[5])); + let mut x49: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x49, x3, (arg4[6]), (arg5[6])); + let mut x50: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x50, x3, (arg4[7]), (arg5[7])); + let mut x51: u32 = 0; + let mut x52: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x51, &mut x52, 0x0, x43, x43); + let mut x53: u32 = 0; + let mut x54: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x53, &mut x54, x52, x44, x44); + let mut x55: u32 = 0; + let mut x56: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x55, &mut x56, x54, x45, x45); + let mut x57: u32 = 0; + let mut x58: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x57, &mut x58, x56, x46, x46); + let mut x59: u32 = 0; + let mut x60: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x59, &mut x60, x58, x47, x47); + let mut x61: u32 = 0; + let mut x62: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x61, &mut x62, x60, x48, x48); + let mut x63: u32 = 0; + let mut x64: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x63, &mut x64, x62, x49, x49); + let mut x65: u32 = 0; + let mut x66: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x65, &mut x66, x64, x50, x50); + let mut x67: u32 = 0; + let mut x68: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x67, &mut x68, 0x0, x51, 0x39d54123); + let mut x69: u32 = 0; + let mut x70: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x69, &mut x70, x68, x53, 0x53bbf409); + let mut x71: u32 = 0; + let mut x72: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x71, &mut x72, x70, x55, 0x21c6052b); + let mut x73: u32 = 0; + let mut x74: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x73, &mut x74, x72, x57, 0x7203df6b); + let mut x75: u32 = 0; + let mut x76: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x75, &mut x76, x74, x59, 0xffffffff); + let mut x77: u32 = 0; + let mut x78: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x77, &mut x78, x76, x61, 0xffffffff); + let mut x79: u32 = 0; + let mut x80: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x79, &mut x80, x78, x63, 0xffffffff); + let mut x81: u32 = 0; + let mut x82: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x81, &mut x82, x80, x65, 0xfffffffe); + let mut x83: u32 = 0; + let mut x84: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x93, &mut x94, 0x0, (0x0 as u32), x92); + let mut x95: u32 = 0; + let mut x96: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x95, &mut x96, x94, (0x0 as u32), x91); + let mut x97: u32 = 0; + let mut x98: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x97, &mut x98, x96, (0x0 as u32), x90); + let mut x99: u32 = 0; + let mut x100: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x99, &mut x100, x98, (0x0 as u32), x89); + let mut x101: u32 = 0; + let mut x102: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x101, &mut x102, x100, (0x0 as u32), x88); + let mut x103: u32 = 0; + let mut x104: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x103, &mut x104, x102, (0x0 as u32), x87); + let mut x105: u32 = 0; + let mut x106: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x105, &mut x106, x104, (0x0 as u32), x86); + let mut x107: u32 = 0; + let mut x108: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x107, &mut x108, x106, (0x0 as u32), x85); + let mut x109: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x109, x108, (0x0 as u32), 0xffffffff); + let mut x110: u32 = 0; + let mut x111: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x110, &mut x111, 0x0, x93, (x109 & 0x39d54123)); + let mut x112: u32 = 0; + let mut x113: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x112, &mut x113, x111, x95, (x109 & 0x53bbf409)); + let mut x114: u32 = 0; + let mut x115: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x114, &mut x115, x113, x97, (x109 & 0x21c6052b)); + let mut x116: u32 = 0; + let mut x117: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x116, &mut x117, x115, x99, (x109 & 0x7203df6b)); + let mut x118: u32 = 0; + let mut x119: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x118, &mut x119, x117, x101, x109); + let mut x120: u32 = 0; + let mut x121: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x120, &mut x121, x119, x103, x109); + let mut x122: u32 = 0; + let mut x123: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x122, &mut x123, x121, x105, x109); + let mut x124: u32 = 0; + let mut x125: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x124, &mut x125, x123, x107, (x109 & 0xfffffffe)); + let mut x126: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x126, x3, (arg5[0]), x110); + let mut x127: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x127, x3, (arg5[1]), x112); + let mut x128: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x128, x3, (arg5[2]), x114); + let mut x129: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x129, x3, (arg5[3]), x116); + let mut x130: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x130, x3, (arg5[4]), x118); + let mut x131: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x131, x3, (arg5[5]), x120); + let mut x132: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x132, x3, (arg5[6]), x122); + let mut x133: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x133, x3, (arg5[7]), x124); + let x134: fiat_sm2_scalar_u1 = ((x34 & (0x1 as u32)) as fiat_sm2_scalar_u1); + let mut x135: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x135, x134, (0x0 as u32), x7); + let mut x136: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x136, x134, (0x0 as u32), x8); + let mut x137: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x137, x134, (0x0 as u32), x9); + let mut x138: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x138, x134, (0x0 as u32), x10); + let mut x139: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x139, x134, (0x0 as u32), x11); + let mut x140: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x140, x134, (0x0 as u32), x12); + let mut x141: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x141, x134, (0x0 as u32), x13); + let mut x142: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x142, x134, (0x0 as u32), x14); + let mut x143: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x143, x134, (0x0 as u32), x15); + let mut x144: u32 = 0; + let mut x145: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x144, &mut x145, 0x0, x34, x135); + let mut x146: u32 = 0; + let mut x147: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x146, &mut x147, x145, x35, x136); + let mut x148: u32 = 0; + let mut x149: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x148, &mut x149, x147, x36, x137); + let mut x150: u32 = 0; + let mut x151: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x150, &mut x151, x149, x37, x138); + let mut x152: u32 = 0; + let mut x153: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x152, &mut x153, x151, x38, x139); + let mut x154: u32 = 0; + let mut x155: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x154, &mut x155, x153, x39, x140); + let mut x156: u32 = 0; + let mut x157: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x156, &mut x157, x155, x40, x141); + let mut x158: u32 = 0; + let mut x159: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x158, &mut x159, x157, x41, x142); + let mut x160: u32 = 0; + let mut x161: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x160, &mut x161, x159, x42, x143); + let mut x162: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x162, x134, (0x0 as u32), x43); + let mut x163: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x163, x134, (0x0 as u32), x44); + let mut x164: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x164, x134, (0x0 as u32), x45); + let mut x165: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x165, x134, (0x0 as u32), x46); + let mut x166: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x166, x134, (0x0 as u32), x47); + let mut x167: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x167, x134, (0x0 as u32), x48); + let mut x168: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x168, x134, (0x0 as u32), x49); + let mut x169: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x169, x134, (0x0 as u32), x50); + let mut x170: u32 = 0; + let mut x171: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x170, &mut x171, 0x0, x126, x162); + let mut x172: u32 = 0; + let mut x173: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x172, &mut x173, x171, x127, x163); + let mut x174: u32 = 0; + let mut x175: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x174, &mut x175, x173, x128, x164); + let mut x176: u32 = 0; + let mut x177: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x176, &mut x177, x175, x129, x165); + let mut x178: u32 = 0; + let mut x179: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x178, &mut x179, x177, x130, x166); + let mut x180: u32 = 0; + let mut x181: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x180, &mut x181, x179, x131, x167); + let mut x182: u32 = 0; + let mut x183: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x182, &mut x183, x181, x132, x168); + let mut x184: u32 = 0; + let mut x185: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u32(&mut x184, &mut x185, x183, x133, x169); + let mut x186: u32 = 0; + let mut x187: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x186, &mut x187, 0x0, x170, 0x39d54123); + let mut x188: u32 = 0; + let mut x189: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x188, &mut x189, x187, x172, 0x53bbf409); + let mut x190: u32 = 0; + let mut x191: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x190, &mut x191, x189, x174, 0x21c6052b); + let mut x192: u32 = 0; + let mut x193: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x192, &mut x193, x191, x176, 0x7203df6b); + let mut x194: u32 = 0; + let mut x195: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x194, &mut x195, x193, x178, 0xffffffff); + let mut x196: u32 = 0; + let mut x197: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x196, &mut x197, x195, x180, 0xffffffff); + let mut x198: u32 = 0; + let mut x199: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x198, &mut x199, x197, x182, 0xffffffff); + let mut x200: u32 = 0; + let mut x201: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x200, &mut x201, x199, x184, 0xfffffffe); + let mut x202: u32 = 0; + let mut x203: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u32(&mut x202, &mut x203, x201, (x185 as u32), (0x0 as u32)); + let mut x204: u32 = 0; + let mut x205: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_cmovznz_u32(&mut x215, x84, x67, x51); + let mut x216: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x216, x84, x69, x53); + let mut x217: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x217, x84, x71, x55); + let mut x218: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x218, x84, x73, x57); + let mut x219: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x219, x84, x75, x59); + let mut x220: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x220, x84, x77, x61); + let mut x221: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x221, x84, x79, x63); + let mut x222: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x222, x84, x81, x65); + let mut x223: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x223, x203, x186, x170); + let mut x224: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x224, x203, x188, x172); + let mut x225: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x225, x203, x190, x174); + let mut x226: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x226, x203, x192, x176); + let mut x227: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x227, x203, x194, x178); + let mut x228: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x228, x203, x196, x180); + let mut x229: u32 = 0; + fiat_sm2_scalar_cmovznz_u32(&mut x229, x203, x198, x182); + let mut x230: u32 = 0; + fiat_sm2_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_sm2_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_sm2_scalar_divstep_precomp(out1: &mut [u32; 8]) { + out1[0] = 0xb351756d; + out1[1] = 0x1aa32707; + out1[2] = 0x1e2a62fa; + out1[3] = 0xabdd67; + out1[4] = 0xd4009a81; + out1[5] = 0x49280d7d; + out1[6] = 0xe6bb86e8; + out1[7] = 0xd730336e; +} diff --git a/fiat-rust/src/sm2_scalar_64.rs b/fiat-rust/src/sm2_scalar_64.rs new file mode 100644 index 00000000000..5c1017f1921 --- /dev/null +++ b/fiat-rust/src/sm2_scalar_64.rs @@ -0,0 +1,2033 @@ +//! Autogenerated: 'src/ExtractionOCaml/word_by_word_montgomery' --lang Rust --inline sm2_scalar 64 '2^256 - 2^224 - 188730267045675049073202170516080344797' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp +//! curve description: sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") +//! +//! 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)] + +/** fiat_sm2_scalar_u1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_scalar_u1 = u8; +/** fiat_sm2_scalar_i1 represents values of 1 bits, stored in one byte. */ +pub type fiat_sm2_scalar_i1 = i8; +/** fiat_sm2_scalar_u2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_scalar_u2 = u8; +/** fiat_sm2_scalar_i2 represents values of 2 bits, stored in one byte. */ +pub type fiat_sm2_scalar_i2 = i8; + +/** The type fiat_sm2_scalar_montgomery_domain_field_element is a field element in the Montgomery domain. */ +/** Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_scalar_montgomery_domain_field_element(pub [u64; 4]); + +impl core::ops::Index for fiat_sm2_scalar_montgomery_domain_field_element { + type Output = u64; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_scalar_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + +/** The type fiat_sm2_scalar_non_montgomery_domain_field_element is a field element NOT in the Montgomery domain. */ +/** Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]] */ +#[derive(Clone, Copy)] +pub struct fiat_sm2_scalar_non_montgomery_domain_field_element(pub [u64; 4]); + +impl core::ops::Index for fiat_sm2_scalar_non_montgomery_domain_field_element { + type Output = u64; + #[inline] + fn index(&self, index: usize) -> &Self::Output { + &self.0[index] + } +} + +impl core::ops::IndexMut for fiat_sm2_scalar_non_montgomery_domain_field_element { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + &mut self.0[index] + } +} + + +/// The function fiat_sm2_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_sm2_scalar_addcarryx_u64(out1: &mut u64, out2: &mut fiat_sm2_scalar_u1, arg1: fiat_sm2_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_sm2_scalar_u1 = ((x1 >> 64) as fiat_sm2_scalar_u1); + *out1 = x2; + *out2 = x3; +} + +/// The function fiat_sm2_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_sm2_scalar_subborrowx_u64(out1: &mut u64, out2: &mut fiat_sm2_scalar_u1, arg1: fiat_sm2_scalar_u1, arg2: u64, arg3: u64) { + let x1: i128 = (((arg2 as i128) - (arg1 as i128)) - (arg3 as i128)); + let x2: fiat_sm2_scalar_i1 = ((x1 >> 64) as fiat_sm2_scalar_i1); + let x3: u64 = ((x1 & (0xffffffffffffffff as i128)) as u64); + *out1 = x3; + *out2 = (((0x0 as fiat_sm2_scalar_i2) - (x2 as fiat_sm2_scalar_i2)) as fiat_sm2_scalar_u1); +} + +/// The function fiat_sm2_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_sm2_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_sm2_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_sm2_scalar_cmovznz_u64(out1: &mut u64, arg1: fiat_sm2_scalar_u1, arg2: u64, arg3: u64) { + let x1: fiat_sm2_scalar_u1 = (!(!arg1)); + let x2: u64 = ((((((0x0 as fiat_sm2_scalar_i2) - (x1 as fiat_sm2_scalar_i2)) as fiat_sm2_scalar_i1) as i128) & (0xffffffffffffffff as i128)) as u64); + let x3: u64 = ((x2 & arg3) | ((!x2) & arg2)); + *out1 = x3; +} + +/// The function fiat_sm2_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_sm2_scalar_mul(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element, arg2: &fiat_sm2_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_sm2_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg2[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg2[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg2[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg2[0])); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x20, &mut x21, x11, 0x327f9e8872350975); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x22, &mut x23, x20, 0xfffffffeffffffff); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x24, &mut x25, x20, 0xffffffffffffffff); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x26, &mut x27, x20, 0x7203df6b21c6052b); + let mut x28: u64 = 0; + let mut x29: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x28, &mut x29, x20, 0x53bbf40939d54123); + let mut x30: u64 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x30, &mut x31, 0x0, x29, x26); + let mut x32: u64 = 0; + let mut x33: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x27, x24); + let mut x34: u64 = 0; + let mut x35: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x37, &mut x38, 0x0, x11, x28); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x13, x30); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x15, x32); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x17, x34); + let mut x45: u64 = 0; + let mut x46: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x19, x36); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg2[3])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x49, &mut x50, x1, (arg2[2])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x51, &mut x52, x1, (arg2[1])); + let mut x53: u64 = 0; + let mut x54: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x53, &mut x54, x1, (arg2[0])); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u64 = 0; + let mut x60: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x45, x59); + let mut x70: u64 = 0; + let mut x71: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x70, &mut x71, x69, (x46 as u64), x61); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x72, &mut x73, x62, 0x327f9e8872350975); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x74, &mut x75, x72, 0xfffffffeffffffff); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x76, &mut x77, x72, 0xffffffffffffffff); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x78, &mut x79, x72, 0x7203df6b21c6052b); + let mut x80: u64 = 0; + let mut x81: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x80, &mut x81, x72, 0x53bbf40939d54123); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x82, &mut x83, 0x0, x81, x78); + let mut x84: u64 = 0; + let mut x85: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x79, x76); + let mut x86: u64 = 0; + let mut x87: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x62, x80); + let mut x91: u64 = 0; + let mut x92: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x64, x82); + let mut x93: u64 = 0; + let mut x94: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x66, x84); + let mut x95: u64 = 0; + let mut x96: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x68, x86); + let mut x97: u64 = 0; + let mut x98: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x100, &mut x101, x2, (arg2[3])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x102, &mut x103, x2, (arg2[2])); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x104, &mut x105, x2, (arg2[1])); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x106, &mut x107, x2, (arg2[0])); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x107, x104); + let mut x110: u64 = 0; + let mut x111: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x105, x102); + let mut x112: u64 = 0; + let mut x113: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x97, x112); + let mut x123: u64 = 0; + let mut x124: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x99, x114); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x125, &mut x126, x115, 0x327f9e8872350975); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x127, &mut x128, x125, 0xfffffffeffffffff); + let mut x129: u64 = 0; + let mut x130: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x129, &mut x130, x125, 0xffffffffffffffff); + let mut x131: u64 = 0; + let mut x132: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x131, &mut x132, x125, 0x7203df6b21c6052b); + let mut x133: u64 = 0; + let mut x134: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x133, &mut x134, x125, 0x53bbf40939d54123); + let mut x135: u64 = 0; + let mut x136: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x135, &mut x136, 0x0, x134, x131); + let mut x137: u64 = 0; + let mut x138: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x132, x129); + let mut x139: u64 = 0; + let mut x140: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x142, &mut x143, 0x0, x115, x133); + let mut x144: u64 = 0; + let mut x145: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x117, x135); + let mut x146: u64 = 0; + let mut x147: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x119, x137); + let mut x148: u64 = 0; + let mut x149: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x121, x139); + let mut x150: u64 = 0; + let mut x151: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x153, &mut x154, x3, (arg2[3])); + let mut x155: u64 = 0; + let mut x156: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x155, &mut x156, x3, (arg2[2])); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x157, &mut x158, x3, (arg2[1])); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x159, &mut x160, x3, (arg2[0])); + let mut x161: u64 = 0; + let mut x162: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x160, x157); + let mut x163: u64 = 0; + let mut x164: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x158, x155); + let mut x165: u64 = 0; + let mut x166: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x148, x163); + let mut x174: u64 = 0; + let mut x175: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x150, x165); + let mut x176: u64 = 0; + let mut x177: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x176, &mut x177, x175, x152, x167); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x178, &mut x179, x168, 0x327f9e8872350975); + let mut x180: u64 = 0; + let mut x181: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x180, &mut x181, x178, 0xfffffffeffffffff); + let mut x182: u64 = 0; + let mut x183: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x182, &mut x183, x178, 0xffffffffffffffff); + let mut x184: u64 = 0; + let mut x185: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x184, &mut x185, x178, 0x7203df6b21c6052b); + let mut x186: u64 = 0; + let mut x187: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x186, &mut x187, x178, 0x53bbf40939d54123); + let mut x188: u64 = 0; + let mut x189: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u64 = 0; + let mut x191: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x190, &mut x191, x189, x185, x182); + let mut x192: u64 = 0; + let mut x193: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x195, &mut x196, 0x0, x168, x186); + let mut x197: u64 = 0; + let mut x198: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x197, &mut x198, x196, x170, x188); + let mut x199: u64 = 0; + let mut x200: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x172, x190); + let mut x201: u64 = 0; + let mut x202: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x174, x192); + let mut x203: u64 = 0; + let mut x204: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x206, &mut x207, 0x0, x197, 0x53bbf40939d54123); + let mut x208: u64 = 0; + let mut x209: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x208, &mut x209, x207, x199, 0x7203df6b21c6052b); + let mut x210: u64 = 0; + let mut x211: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x210, &mut x211, x209, x201, 0xffffffffffffffff); + let mut x212: u64 = 0; + let mut x213: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x212, &mut x213, x211, x203, 0xfffffffeffffffff); + let mut x214: u64 = 0; + let mut x215: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x214, &mut x215, x213, x205, (0x0 as u64)); + let mut x216: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x216, x215, x206, x197); + let mut x217: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x217, x215, x208, x199); + let mut x218: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x218, x215, x210, x201); + let mut x219: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function fiat_sm2_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_sm2_scalar_square(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_scalar_mulx_u64(&mut x5, &mut x6, x4, (arg1[3])); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x7, &mut x8, x4, (arg1[2])); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x9, &mut x10, x4, (arg1[1])); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x11, &mut x12, x4, (arg1[0])); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x20, &mut x21, x11, 0x327f9e8872350975); + let mut x22: u64 = 0; + let mut x23: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x22, &mut x23, x20, 0xfffffffeffffffff); + let mut x24: u64 = 0; + let mut x25: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x24, &mut x25, x20, 0xffffffffffffffff); + let mut x26: u64 = 0; + let mut x27: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x26, &mut x27, x20, 0x7203df6b21c6052b); + let mut x28: u64 = 0; + let mut x29: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x28, &mut x29, x20, 0x53bbf40939d54123); + let mut x30: u64 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x30, &mut x31, 0x0, x29, x26); + let mut x32: u64 = 0; + let mut x33: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x32, &mut x33, x31, x27, x24); + let mut x34: u64 = 0; + let mut x35: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x37, &mut x38, 0x0, x11, x28); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x13, x30); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x15, x32); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x43, &mut x44, x42, x17, x34); + let mut x45: u64 = 0; + let mut x46: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x45, &mut x46, x44, x19, x36); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x47, &mut x48, x1, (arg1[3])); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x49, &mut x50, x1, (arg1[2])); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x51, &mut x52, x1, (arg1[1])); + let mut x53: u64 = 0; + let mut x54: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x53, &mut x54, x1, (arg1[0])); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x55, &mut x56, 0x0, x54, x51); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x52, x49); + let mut x59: u64 = 0; + let mut x60: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x39, x53); + let mut x64: u64 = 0; + let mut x65: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x41, x55); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x43, x57); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x45, x59); + let mut x70: u64 = 0; + let mut x71: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x70, &mut x71, x69, (x46 as u64), x61); + let mut x72: u64 = 0; + let mut x73: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x72, &mut x73, x62, 0x327f9e8872350975); + let mut x74: u64 = 0; + let mut x75: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x74, &mut x75, x72, 0xfffffffeffffffff); + let mut x76: u64 = 0; + let mut x77: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x76, &mut x77, x72, 0xffffffffffffffff); + let mut x78: u64 = 0; + let mut x79: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x78, &mut x79, x72, 0x7203df6b21c6052b); + let mut x80: u64 = 0; + let mut x81: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x80, &mut x81, x72, 0x53bbf40939d54123); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x82, &mut x83, 0x0, x81, x78); + let mut x84: u64 = 0; + let mut x85: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x79, x76); + let mut x86: u64 = 0; + let mut x87: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x89, &mut x90, 0x0, x62, x80); + let mut x91: u64 = 0; + let mut x92: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x91, &mut x92, x90, x64, x82); + let mut x93: u64 = 0; + let mut x94: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x93, &mut x94, x92, x66, x84); + let mut x95: u64 = 0; + let mut x96: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x95, &mut x96, x94, x68, x86); + let mut x97: u64 = 0; + let mut x98: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x100, &mut x101, x2, (arg1[3])); + let mut x102: u64 = 0; + let mut x103: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x102, &mut x103, x2, (arg1[2])); + let mut x104: u64 = 0; + let mut x105: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x104, &mut x105, x2, (arg1[1])); + let mut x106: u64 = 0; + let mut x107: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x106, &mut x107, x2, (arg1[0])); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x107, x104); + let mut x110: u64 = 0; + let mut x111: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x105, x102); + let mut x112: u64 = 0; + let mut x113: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x115, &mut x116, 0x0, x91, x106); + let mut x117: u64 = 0; + let mut x118: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x117, &mut x118, x116, x93, x108); + let mut x119: u64 = 0; + let mut x120: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x119, &mut x120, x118, x95, x110); + let mut x121: u64 = 0; + let mut x122: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x121, &mut x122, x120, x97, x112); + let mut x123: u64 = 0; + let mut x124: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x123, &mut x124, x122, x99, x114); + let mut x125: u64 = 0; + let mut x126: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x125, &mut x126, x115, 0x327f9e8872350975); + let mut x127: u64 = 0; + let mut x128: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x127, &mut x128, x125, 0xfffffffeffffffff); + let mut x129: u64 = 0; + let mut x130: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x129, &mut x130, x125, 0xffffffffffffffff); + let mut x131: u64 = 0; + let mut x132: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x131, &mut x132, x125, 0x7203df6b21c6052b); + let mut x133: u64 = 0; + let mut x134: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x133, &mut x134, x125, 0x53bbf40939d54123); + let mut x135: u64 = 0; + let mut x136: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x135, &mut x136, 0x0, x134, x131); + let mut x137: u64 = 0; + let mut x138: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x132, x129); + let mut x139: u64 = 0; + let mut x140: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x142, &mut x143, 0x0, x115, x133); + let mut x144: u64 = 0; + let mut x145: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x144, &mut x145, x143, x117, x135); + let mut x146: u64 = 0; + let mut x147: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x146, &mut x147, x145, x119, x137); + let mut x148: u64 = 0; + let mut x149: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x148, &mut x149, x147, x121, x139); + let mut x150: u64 = 0; + let mut x151: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x153, &mut x154, x3, (arg1[3])); + let mut x155: u64 = 0; + let mut x156: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x155, &mut x156, x3, (arg1[2])); + let mut x157: u64 = 0; + let mut x158: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x157, &mut x158, x3, (arg1[1])); + let mut x159: u64 = 0; + let mut x160: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x159, &mut x160, x3, (arg1[0])); + let mut x161: u64 = 0; + let mut x162: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x161, &mut x162, 0x0, x160, x157); + let mut x163: u64 = 0; + let mut x164: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x163, &mut x164, x162, x158, x155); + let mut x165: u64 = 0; + let mut x166: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x168, &mut x169, 0x0, x144, x159); + let mut x170: u64 = 0; + let mut x171: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x170, &mut x171, x169, x146, x161); + let mut x172: u64 = 0; + let mut x173: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x172, &mut x173, x171, x148, x163); + let mut x174: u64 = 0; + let mut x175: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x174, &mut x175, x173, x150, x165); + let mut x176: u64 = 0; + let mut x177: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x176, &mut x177, x175, x152, x167); + let mut x178: u64 = 0; + let mut x179: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x178, &mut x179, x168, 0x327f9e8872350975); + let mut x180: u64 = 0; + let mut x181: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x180, &mut x181, x178, 0xfffffffeffffffff); + let mut x182: u64 = 0; + let mut x183: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x182, &mut x183, x178, 0xffffffffffffffff); + let mut x184: u64 = 0; + let mut x185: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x184, &mut x185, x178, 0x7203df6b21c6052b); + let mut x186: u64 = 0; + let mut x187: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x186, &mut x187, x178, 0x53bbf40939d54123); + let mut x188: u64 = 0; + let mut x189: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x188, &mut x189, 0x0, x187, x184); + let mut x190: u64 = 0; + let mut x191: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x190, &mut x191, x189, x185, x182); + let mut x192: u64 = 0; + let mut x193: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x195, &mut x196, 0x0, x168, x186); + let mut x197: u64 = 0; + let mut x198: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x197, &mut x198, x196, x170, x188); + let mut x199: u64 = 0; + let mut x200: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x199, &mut x200, x198, x172, x190); + let mut x201: u64 = 0; + let mut x202: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x201, &mut x202, x200, x174, x192); + let mut x203: u64 = 0; + let mut x204: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x206, &mut x207, 0x0, x197, 0x53bbf40939d54123); + let mut x208: u64 = 0; + let mut x209: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x208, &mut x209, x207, x199, 0x7203df6b21c6052b); + let mut x210: u64 = 0; + let mut x211: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x210, &mut x211, x209, x201, 0xffffffffffffffff); + let mut x212: u64 = 0; + let mut x213: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x212, &mut x213, x211, x203, 0xfffffffeffffffff); + let mut x214: u64 = 0; + let mut x215: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x214, &mut x215, x213, x205, (0x0 as u64)); + let mut x216: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x216, x215, x206, x197); + let mut x217: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x217, x215, x208, x199); + let mut x218: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x218, x215, x210, x201); + let mut x219: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x219, x215, x212, x203); + out1[0] = x216; + out1[1] = x217; + out1[2] = x218; + out1[3] = x219; +} + +/// The function fiat_sm2_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_sm2_scalar_add(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element, arg2: &fiat_sm2_scalar_montgomery_domain_field_element) { + let mut x1: u64 = 0; + let mut x2: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + let mut x10: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x9, &mut x10, 0x0, x1, 0x53bbf40939d54123); + let mut x11: u64 = 0; + let mut x12: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x11, &mut x12, x10, x3, 0x7203df6b21c6052b); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x13, &mut x14, x12, x5, 0xffffffffffffffff); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x15, &mut x16, x14, x7, 0xfffffffeffffffff); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x17, &mut x18, x16, (x8 as u64), (0x0 as u64)); + let mut x19: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x19, x18, x9, x1); + let mut x20: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x20, x18, x11, x3); + let mut x21: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x21, x18, x13, x5); + let mut x22: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x22, x18, x15, x7); + out1[0] = x19; + out1[1] = x20; + out1[2] = x21; + out1[3] = x22; +} + +/// The function fiat_sm2_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_sm2_scalar_sub(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element, arg2: &fiat_sm2_scalar_montgomery_domain_field_element) { + let mut x1: u64 = 0; + let mut x2: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (arg1[0]), (arg2[0])); + let mut x3: u64 = 0; + let mut x4: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (arg1[1]), (arg2[1])); + let mut x5: u64 = 0; + let mut x6: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (arg1[2]), (arg2[2])); + let mut x7: u64 = 0; + let mut x8: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (arg1[3]), (arg2[3])); + let mut x9: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0x53bbf40939d54123)); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0x7203df6b21c6052b)); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, x9); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0xfffffffeffffffff)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_sm2_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_sm2_scalar_opp(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element) { + let mut x1: u64 = 0; + let mut x2: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x1, &mut x2, 0x0, (0x0 as u64), (arg1[0])); + let mut x3: u64 = 0; + let mut x4: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x3, &mut x4, x2, (0x0 as u64), (arg1[1])); + let mut x5: u64 = 0; + let mut x6: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x5, &mut x6, x4, (0x0 as u64), (arg1[2])); + let mut x7: u64 = 0; + let mut x8: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x7, &mut x8, x6, (0x0 as u64), (arg1[3])); + let mut x9: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x9, x8, (0x0 as u64), 0xffffffffffffffff); + let mut x10: u64 = 0; + let mut x11: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x10, &mut x11, 0x0, x1, (x9 & 0x53bbf40939d54123)); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x12, &mut x13, x11, x3, (x9 & 0x7203df6b21c6052b)); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x5, x9); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, (x9 & 0xfffffffeffffffff)); + out1[0] = x10; + out1[1] = x12; + out1[2] = x14; + out1[3] = x16; +} + +/// The function fiat_sm2_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_sm2_scalar_from_montgomery(out1: &mut fiat_sm2_scalar_non_montgomery_domain_field_element, arg1: &fiat_sm2_scalar_montgomery_domain_field_element) { + let x1: u64 = (arg1[0]); + let mut x2: u64 = 0; + let mut x3: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x2, &mut x3, x1, 0x327f9e8872350975); + let mut x4: u64 = 0; + let mut x5: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x4, &mut x5, x2, 0xfffffffeffffffff); + let mut x6: u64 = 0; + let mut x7: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x6, &mut x7, x2, 0xffffffffffffffff); + let mut x8: u64 = 0; + let mut x9: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x8, &mut x9, x2, 0x7203df6b21c6052b); + let mut x10: u64 = 0; + let mut x11: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x10, &mut x11, x2, 0x53bbf40939d54123); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, x11, x8); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x14, &mut x15, x13, x9, x6); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x16, &mut x17, x15, x7, x4); + let mut x18: u64 = 0; + let mut x19: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x18, &mut x19, 0x0, x1, x10); + let mut x20: u64 = 0; + let mut x21: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), x12); + let mut x22: u64 = 0; + let mut x23: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x22, &mut x23, x21, (0x0 as u64), x14); + let mut x24: u64 = 0; + let mut x25: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x24, &mut x25, x23, (0x0 as u64), x16); + let mut x26: u64 = 0; + let mut x27: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x26, &mut x27, 0x0, x20, (arg1[1])); + let mut x28: u64 = 0; + let mut x29: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x28, &mut x29, x27, x22, (0x0 as u64)); + let mut x30: u64 = 0; + let mut x31: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x30, &mut x31, x29, x24, (0x0 as u64)); + let mut x32: u64 = 0; + let mut x33: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x32, &mut x33, x26, 0x327f9e8872350975); + let mut x34: u64 = 0; + let mut x35: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x34, &mut x35, x32, 0xfffffffeffffffff); + let mut x36: u64 = 0; + let mut x37: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x36, &mut x37, x32, 0xffffffffffffffff); + let mut x38: u64 = 0; + let mut x39: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x38, &mut x39, x32, 0x7203df6b21c6052b); + let mut x40: u64 = 0; + let mut x41: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x40, &mut x41, x32, 0x53bbf40939d54123); + let mut x42: u64 = 0; + let mut x43: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x42, &mut x43, 0x0, x41, x38); + let mut x44: u64 = 0; + let mut x45: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x44, &mut x45, x43, x39, x36); + let mut x46: u64 = 0; + let mut x47: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x46, &mut x47, x45, x37, x34); + let mut x48: u64 = 0; + let mut x49: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x48, &mut x49, 0x0, x26, x40); + let mut x50: u64 = 0; + let mut x51: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x50, &mut x51, x49, x28, x42); + let mut x52: u64 = 0; + let mut x53: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x52, &mut x53, x51, x30, x44); + let mut x54: u64 = 0; + let mut x55: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x56, &mut x57, 0x0, x50, (arg1[2])); + let mut x58: u64 = 0; + let mut x59: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x58, &mut x59, x57, x52, (0x0 as u64)); + let mut x60: u64 = 0; + let mut x61: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x60, &mut x61, x59, x54, (0x0 as u64)); + let mut x62: u64 = 0; + let mut x63: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x62, &mut x63, x56, 0x327f9e8872350975); + let mut x64: u64 = 0; + let mut x65: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x64, &mut x65, x62, 0xfffffffeffffffff); + let mut x66: u64 = 0; + let mut x67: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x66, &mut x67, x62, 0xffffffffffffffff); + let mut x68: u64 = 0; + let mut x69: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x68, &mut x69, x62, 0x7203df6b21c6052b); + let mut x70: u64 = 0; + let mut x71: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x70, &mut x71, x62, 0x53bbf40939d54123); + let mut x72: u64 = 0; + let mut x73: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x72, &mut x73, 0x0, x71, x68); + let mut x74: u64 = 0; + let mut x75: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x74, &mut x75, x73, x69, x66); + let mut x76: u64 = 0; + let mut x77: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x76, &mut x77, x75, x67, x64); + let mut x78: u64 = 0; + let mut x79: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x78, &mut x79, 0x0, x56, x70); + let mut x80: u64 = 0; + let mut x81: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x80, &mut x81, x79, x58, x72); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x60, x74); + let mut x84: u64 = 0; + let mut x85: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x86, &mut x87, 0x0, x80, (arg1[3])); + let mut x88: u64 = 0; + let mut x89: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x82, (0x0 as u64)); + let mut x90: u64 = 0; + let mut x91: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x90, &mut x91, x89, x84, (0x0 as u64)); + let mut x92: u64 = 0; + let mut x93: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x92, &mut x93, x86, 0x327f9e8872350975); + let mut x94: u64 = 0; + let mut x95: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x94, &mut x95, x92, 0xfffffffeffffffff); + let mut x96: u64 = 0; + let mut x97: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x96, &mut x97, x92, 0xffffffffffffffff); + let mut x98: u64 = 0; + let mut x99: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x98, &mut x99, x92, 0x7203df6b21c6052b); + let mut x100: u64 = 0; + let mut x101: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x100, &mut x101, x92, 0x53bbf40939d54123); + let mut x102: u64 = 0; + let mut x103: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x102, &mut x103, 0x0, x101, x98); + let mut x104: u64 = 0; + let mut x105: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x104, &mut x105, x103, x99, x96); + let mut x106: u64 = 0; + let mut x107: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x106, &mut x107, x105, x97, x94); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x108, &mut x109, 0x0, x86, x100); + let mut x110: u64 = 0; + let mut x111: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x110, &mut x111, x109, x88, x102); + let mut x112: u64 = 0; + let mut x113: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x112, &mut x113, x111, x90, x104); + let mut x114: u64 = 0; + let mut x115: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x117, &mut x118, 0x0, x110, 0x53bbf40939d54123); + let mut x119: u64 = 0; + let mut x120: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x119, &mut x120, x118, x112, 0x7203df6b21c6052b); + let mut x121: u64 = 0; + let mut x122: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x121, &mut x122, x120, x114, 0xffffffffffffffff); + let mut x123: u64 = 0; + let mut x124: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x123, &mut x124, x122, x116, 0xfffffffeffffffff); + let mut x125: u64 = 0; + let mut x126: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x125, &mut x126, x124, (0x0 as u64), (0x0 as u64)); + let mut x127: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x127, x126, x117, x110); + let mut x128: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x128, x126, x119, x112); + let mut x129: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x129, x126, x121, x114); + let mut x130: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x130, x126, x123, x116); + out1[0] = x127; + out1[1] = x128; + out1[2] = x129; + out1[3] = x130; +} + +/// The function fiat_sm2_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_sm2_scalar_to_montgomery(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element, arg1: &fiat_sm2_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_sm2_scalar_mulx_u64(&mut x5, &mut x6, x4, 0x1eb5e412a22b3d3b); + let mut x7: u64 = 0; + let mut x8: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x7, &mut x8, x4, 0x620fc84c3affe0d4); + let mut x9: u64 = 0; + let mut x10: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x9, &mut x10, x4, 0x3464504ade6fa2fa); + let mut x11: u64 = 0; + let mut x12: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x11, &mut x12, x4, 0x901192af7c114f20); + let mut x13: u64 = 0; + let mut x14: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x13, &mut x14, 0x0, x12, x9); + let mut x15: u64 = 0; + let mut x16: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x15, &mut x16, x14, x10, x7); + let mut x17: u64 = 0; + let mut x18: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x17, &mut x18, x16, x8, x5); + let mut x19: u64 = 0; + let mut x20: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x19, &mut x20, x11, 0x327f9e8872350975); + let mut x21: u64 = 0; + let mut x22: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x21, &mut x22, x19, 0xfffffffeffffffff); + let mut x23: u64 = 0; + let mut x24: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x23, &mut x24, x19, 0xffffffffffffffff); + let mut x25: u64 = 0; + let mut x26: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x25, &mut x26, x19, 0x7203df6b21c6052b); + let mut x27: u64 = 0; + let mut x28: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x27, &mut x28, x19, 0x53bbf40939d54123); + let mut x29: u64 = 0; + let mut x30: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x29, &mut x30, 0x0, x28, x25); + let mut x31: u64 = 0; + let mut x32: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x31, &mut x32, x30, x26, x23); + let mut x33: u64 = 0; + let mut x34: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x24, x21); + let mut x35: u64 = 0; + let mut x36: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x35, &mut x36, 0x0, x11, x27); + let mut x37: u64 = 0; + let mut x38: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x13, x29); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x39, &mut x40, x38, x15, x31); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x41, &mut x42, x40, x17, x33); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x45, &mut x46, x1, 0x1eb5e412a22b3d3b); + let mut x47: u64 = 0; + let mut x48: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x47, &mut x48, x1, 0x620fc84c3affe0d4); + let mut x49: u64 = 0; + let mut x50: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x49, &mut x50, x1, 0x3464504ade6fa2fa); + let mut x51: u64 = 0; + let mut x52: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x51, &mut x52, x1, 0x901192af7c114f20); + let mut x53: u64 = 0; + let mut x54: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x53, &mut x54, 0x0, x52, x49); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x55, &mut x56, x54, x50, x47); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x57, &mut x58, x56, x48, x45); + let mut x59: u64 = 0; + let mut x60: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x59, &mut x60, 0x0, x37, x51); + let mut x61: u64 = 0; + let mut x62: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x61, &mut x62, x60, x39, x53); + let mut x63: u64 = 0; + let mut x64: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x63, &mut x64, x62, x41, x55); + let mut x65: u64 = 0; + let mut x66: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x65, &mut x66, x64, x43, x57); + let mut x67: u64 = 0; + let mut x68: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x67, &mut x68, x59, 0x327f9e8872350975); + let mut x69: u64 = 0; + let mut x70: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x69, &mut x70, x67, 0xfffffffeffffffff); + let mut x71: u64 = 0; + let mut x72: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x71, &mut x72, x67, 0xffffffffffffffff); + let mut x73: u64 = 0; + let mut x74: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x73, &mut x74, x67, 0x7203df6b21c6052b); + let mut x75: u64 = 0; + let mut x76: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x75, &mut x76, x67, 0x53bbf40939d54123); + let mut x77: u64 = 0; + let mut x78: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x77, &mut x78, 0x0, x76, x73); + let mut x79: u64 = 0; + let mut x80: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x79, &mut x80, x78, x74, x71); + let mut x81: u64 = 0; + let mut x82: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x81, &mut x82, x80, x72, x69); + let mut x83: u64 = 0; + let mut x84: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x83, &mut x84, 0x0, x59, x75); + let mut x85: u64 = 0; + let mut x86: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x85, &mut x86, x84, x61, x77); + let mut x87: u64 = 0; + let mut x88: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x87, &mut x88, x86, x63, x79); + let mut x89: u64 = 0; + let mut x90: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x89, &mut x90, x88, x65, x81); + let mut x91: u64 = 0; + let mut x92: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x93, &mut x94, x2, 0x1eb5e412a22b3d3b); + let mut x95: u64 = 0; + let mut x96: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x95, &mut x96, x2, 0x620fc84c3affe0d4); + let mut x97: u64 = 0; + let mut x98: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x97, &mut x98, x2, 0x3464504ade6fa2fa); + let mut x99: u64 = 0; + let mut x100: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x99, &mut x100, x2, 0x901192af7c114f20); + let mut x101: u64 = 0; + let mut x102: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x101, &mut x102, 0x0, x100, x97); + let mut x103: u64 = 0; + let mut x104: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x103, &mut x104, x102, x98, x95); + let mut x105: u64 = 0; + let mut x106: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x105, &mut x106, x104, x96, x93); + let mut x107: u64 = 0; + let mut x108: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x107, &mut x108, 0x0, x85, x99); + let mut x109: u64 = 0; + let mut x110: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x109, &mut x110, x108, x87, x101); + let mut x111: u64 = 0; + let mut x112: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x111, &mut x112, x110, x89, x103); + let mut x113: u64 = 0; + let mut x114: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x113, &mut x114, x112, x91, x105); + let mut x115: u64 = 0; + let mut x116: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x115, &mut x116, x107, 0x327f9e8872350975); + let mut x117: u64 = 0; + let mut x118: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x117, &mut x118, x115, 0xfffffffeffffffff); + let mut x119: u64 = 0; + let mut x120: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x119, &mut x120, x115, 0xffffffffffffffff); + let mut x121: u64 = 0; + let mut x122: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x121, &mut x122, x115, 0x7203df6b21c6052b); + let mut x123: u64 = 0; + let mut x124: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x123, &mut x124, x115, 0x53bbf40939d54123); + let mut x125: u64 = 0; + let mut x126: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x125, &mut x126, 0x0, x124, x121); + let mut x127: u64 = 0; + let mut x128: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x127, &mut x128, x126, x122, x119); + let mut x129: u64 = 0; + let mut x130: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x129, &mut x130, x128, x120, x117); + let mut x131: u64 = 0; + let mut x132: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x131, &mut x132, 0x0, x107, x123); + let mut x133: u64 = 0; + let mut x134: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x133, &mut x134, x132, x109, x125); + let mut x135: u64 = 0; + let mut x136: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x135, &mut x136, x134, x111, x127); + let mut x137: u64 = 0; + let mut x138: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x137, &mut x138, x136, x113, x129); + let mut x139: u64 = 0; + let mut x140: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_mulx_u64(&mut x141, &mut x142, x3, 0x1eb5e412a22b3d3b); + let mut x143: u64 = 0; + let mut x144: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x143, &mut x144, x3, 0x620fc84c3affe0d4); + let mut x145: u64 = 0; + let mut x146: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x145, &mut x146, x3, 0x3464504ade6fa2fa); + let mut x147: u64 = 0; + let mut x148: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x147, &mut x148, x3, 0x901192af7c114f20); + let mut x149: u64 = 0; + let mut x150: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x149, &mut x150, 0x0, x148, x145); + let mut x151: u64 = 0; + let mut x152: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x151, &mut x152, x150, x146, x143); + let mut x153: u64 = 0; + let mut x154: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x153, &mut x154, x152, x144, x141); + let mut x155: u64 = 0; + let mut x156: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x155, &mut x156, 0x0, x133, x147); + let mut x157: u64 = 0; + let mut x158: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x157, &mut x158, x156, x135, x149); + let mut x159: u64 = 0; + let mut x160: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x159, &mut x160, x158, x137, x151); + let mut x161: u64 = 0; + let mut x162: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x161, &mut x162, x160, x139, x153); + let mut x163: u64 = 0; + let mut x164: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x163, &mut x164, x155, 0x327f9e8872350975); + let mut x165: u64 = 0; + let mut x166: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x165, &mut x166, x163, 0xfffffffeffffffff); + let mut x167: u64 = 0; + let mut x168: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x167, &mut x168, x163, 0xffffffffffffffff); + let mut x169: u64 = 0; + let mut x170: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x169, &mut x170, x163, 0x7203df6b21c6052b); + let mut x171: u64 = 0; + let mut x172: u64 = 0; + fiat_sm2_scalar_mulx_u64(&mut x171, &mut x172, x163, 0x53bbf40939d54123); + let mut x173: u64 = 0; + let mut x174: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x173, &mut x174, 0x0, x172, x169); + let mut x175: u64 = 0; + let mut x176: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x175, &mut x176, x174, x170, x167); + let mut x177: u64 = 0; + let mut x178: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x177, &mut x178, x176, x168, x165); + let mut x179: u64 = 0; + let mut x180: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x179, &mut x180, 0x0, x155, x171); + let mut x181: u64 = 0; + let mut x182: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x181, &mut x182, x180, x157, x173); + let mut x183: u64 = 0; + let mut x184: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x183, &mut x184, x182, x159, x175); + let mut x185: u64 = 0; + let mut x186: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x185, &mut x186, x184, x161, x177); + let mut x187: u64 = 0; + let mut x188: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x189, &mut x190, 0x0, x181, 0x53bbf40939d54123); + let mut x191: u64 = 0; + let mut x192: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x191, &mut x192, x190, x183, 0x7203df6b21c6052b); + let mut x193: u64 = 0; + let mut x194: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x193, &mut x194, x192, x185, 0xffffffffffffffff); + let mut x195: u64 = 0; + let mut x196: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x195, &mut x196, x194, x187, 0xfffffffeffffffff); + let mut x197: u64 = 0; + let mut x198: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x197, &mut x198, x196, (x188 as u64), (0x0 as u64)); + let mut x199: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x199, x198, x189, x181); + let mut x200: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x200, x198, x191, x183); + let mut x201: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x201, x198, x193, x185); + let mut x202: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x202, x198, x195, x187); + out1[0] = x199; + out1[1] = x200; + out1[2] = x201; + out1[3] = x202; +} + +/// The function fiat_sm2_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_sm2_scalar_nonzero(out1: &mut u64, arg1: &[u64; 4]) { + let x1: u64 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | (arg1[3])))); + *out1 = x1; +} + +/// The function fiat_sm2_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_sm2_scalar_selectznz(out1: &mut [u64; 4], arg1: fiat_sm2_scalar_u1, arg2: &[u64; 4], arg3: &[u64; 4]) { + let mut x1: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x1, arg1, (arg2[0]), (arg3[0])); + let mut x2: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x2, arg1, (arg2[1]), (arg3[1])); + let mut x3: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x3, arg1, (arg2[2]), (arg3[2])); + let mut x4: u64 = 0; + fiat_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_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_sm2_scalar_set_one(out1: &mut fiat_sm2_scalar_montgomery_domain_field_element) { + out1[0] = 0xac440bf6c62abedd; + out1[1] = 0x8dfc2094de39fad4; + out1[2] = (0x0 as u64); + out1[3] = 0x100000000; +} + +/// The function fiat_sm2_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_sm2_scalar_msat(out1: &mut [u64; 5]) { + out1[0] = 0x53bbf40939d54123; + out1[1] = 0x7203df6b21c6052b; + out1[2] = 0xffffffffffffffff; + out1[3] = 0xfffffffeffffffff; + out1[4] = (0x0 as u64); +} + +/// The function fiat_sm2_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_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x1, &mut x2, 0x0, (!arg1), (0x1 as u64)); + let x3: fiat_sm2_scalar_u1 = (((x1 >> 63) as fiat_sm2_scalar_u1) & (((arg3[0]) & (0x1 as u64)) as fiat_sm2_scalar_u1)); + let mut x4: u64 = 0; + let mut x5: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x4, &mut x5, 0x0, (!arg1), (0x1 as u64)); + let mut x6: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x6, x3, arg1, x4); + let mut x7: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x7, x3, (arg2[0]), (arg3[0])); + let mut x8: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x8, x3, (arg2[1]), (arg3[1])); + let mut x9: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x9, x3, (arg2[2]), (arg3[2])); + let mut x10: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x10, x3, (arg2[3]), (arg3[3])); + let mut x11: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x11, x3, (arg2[4]), (arg3[4])); + let mut x12: u64 = 0; + let mut x13: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x12, &mut x13, 0x0, (0x1 as u64), (!(arg2[0]))); + let mut x14: u64 = 0; + let mut x15: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x14, &mut x15, x13, (0x0 as u64), (!(arg2[1]))); + let mut x16: u64 = 0; + let mut x17: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x16, &mut x17, x15, (0x0 as u64), (!(arg2[2]))); + let mut x18: u64 = 0; + let mut x19: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x18, &mut x19, x17, (0x0 as u64), (!(arg2[3]))); + let mut x20: u64 = 0; + let mut x21: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x20, &mut x21, x19, (0x0 as u64), (!(arg2[4]))); + let mut x22: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x22, x3, (arg3[0]), x12); + let mut x23: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x23, x3, (arg3[1]), x14); + let mut x24: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x24, x3, (arg3[2]), x16); + let mut x25: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x25, x3, (arg3[3]), x18); + let mut x26: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x26, x3, (arg3[4]), x20); + let mut x27: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x27, x3, (arg4[0]), (arg5[0])); + let mut x28: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x28, x3, (arg4[1]), (arg5[1])); + let mut x29: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x29, x3, (arg4[2]), (arg5[2])); + let mut x30: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x30, x3, (arg4[3]), (arg5[3])); + let mut x31: u64 = 0; + let mut x32: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x31, &mut x32, 0x0, x27, x27); + let mut x33: u64 = 0; + let mut x34: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x33, &mut x34, x32, x28, x28); + let mut x35: u64 = 0; + let mut x36: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x35, &mut x36, x34, x29, x29); + let mut x37: u64 = 0; + let mut x38: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x37, &mut x38, x36, x30, x30); + let mut x39: u64 = 0; + let mut x40: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x39, &mut x40, 0x0, x31, 0x53bbf40939d54123); + let mut x41: u64 = 0; + let mut x42: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x41, &mut x42, x40, x33, 0x7203df6b21c6052b); + let mut x43: u64 = 0; + let mut x44: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x43, &mut x44, x42, x35, 0xffffffffffffffff); + let mut x45: u64 = 0; + let mut x46: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x45, &mut x46, x44, x37, 0xfffffffeffffffff); + let mut x47: u64 = 0; + let mut x48: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x53, &mut x54, 0x0, (0x0 as u64), x52); + let mut x55: u64 = 0; + let mut x56: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x55, &mut x56, x54, (0x0 as u64), x51); + let mut x57: u64 = 0; + let mut x58: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x57, &mut x58, x56, (0x0 as u64), x50); + let mut x59: u64 = 0; + let mut x60: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x59, &mut x60, x58, (0x0 as u64), x49); + let mut x61: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x61, x60, (0x0 as u64), 0xffffffffffffffff); + let mut x62: u64 = 0; + let mut x63: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x62, &mut x63, 0x0, x53, (x61 & 0x53bbf40939d54123)); + let mut x64: u64 = 0; + let mut x65: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x64, &mut x65, x63, x55, (x61 & 0x7203df6b21c6052b)); + let mut x66: u64 = 0; + let mut x67: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x66, &mut x67, x65, x57, x61); + let mut x68: u64 = 0; + let mut x69: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x68, &mut x69, x67, x59, (x61 & 0xfffffffeffffffff)); + let mut x70: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x70, x3, (arg5[0]), x62); + let mut x71: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x71, x3, (arg5[1]), x64); + let mut x72: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x72, x3, (arg5[2]), x66); + let mut x73: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x73, x3, (arg5[3]), x68); + let x74: fiat_sm2_scalar_u1 = ((x22 & (0x1 as u64)) as fiat_sm2_scalar_u1); + let mut x75: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x75, x74, (0x0 as u64), x7); + let mut x76: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x76, x74, (0x0 as u64), x8); + let mut x77: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x77, x74, (0x0 as u64), x9); + let mut x78: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x78, x74, (0x0 as u64), x10); + let mut x79: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x79, x74, (0x0 as u64), x11); + let mut x80: u64 = 0; + let mut x81: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x80, &mut x81, 0x0, x22, x75); + let mut x82: u64 = 0; + let mut x83: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x82, &mut x83, x81, x23, x76); + let mut x84: u64 = 0; + let mut x85: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x84, &mut x85, x83, x24, x77); + let mut x86: u64 = 0; + let mut x87: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x86, &mut x87, x85, x25, x78); + let mut x88: u64 = 0; + let mut x89: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x88, &mut x89, x87, x26, x79); + let mut x90: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x90, x74, (0x0 as u64), x27); + let mut x91: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x91, x74, (0x0 as u64), x28); + let mut x92: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x92, x74, (0x0 as u64), x29); + let mut x93: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x93, x74, (0x0 as u64), x30); + let mut x94: u64 = 0; + let mut x95: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x94, &mut x95, 0x0, x70, x90); + let mut x96: u64 = 0; + let mut x97: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x96, &mut x97, x95, x71, x91); + let mut x98: u64 = 0; + let mut x99: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x98, &mut x99, x97, x72, x92); + let mut x100: u64 = 0; + let mut x101: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_addcarryx_u64(&mut x100, &mut x101, x99, x73, x93); + let mut x102: u64 = 0; + let mut x103: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x102, &mut x103, 0x0, x94, 0x53bbf40939d54123); + let mut x104: u64 = 0; + let mut x105: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x104, &mut x105, x103, x96, 0x7203df6b21c6052b); + let mut x106: u64 = 0; + let mut x107: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x106, &mut x107, x105, x98, 0xffffffffffffffff); + let mut x108: u64 = 0; + let mut x109: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x108, &mut x109, x107, x100, 0xfffffffeffffffff); + let mut x110: u64 = 0; + let mut x111: fiat_sm2_scalar_u1 = 0; + fiat_sm2_scalar_subborrowx_u64(&mut x110, &mut x111, x109, (x101 as u64), (0x0 as u64)); + let mut x112: u64 = 0; + let mut x113: fiat_sm2_scalar_u1 = 0; + fiat_sm2_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_sm2_scalar_cmovznz_u64(&mut x119, x48, x39, x31); + let mut x120: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x120, x48, x41, x33); + let mut x121: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x121, x48, x43, x35); + let mut x122: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x122, x48, x45, x37); + let mut x123: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x123, x111, x102, x94); + let mut x124: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x124, x111, x104, x96); + let mut x125: u64 = 0; + fiat_sm2_scalar_cmovznz_u64(&mut x125, x111, x106, x98); + let mut x126: u64 = 0; + fiat_sm2_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_sm2_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_sm2_scalar_divstep_precomp(out1: &mut [u64; 4]) { + out1[0] = 0x1aa32707b351756d; + out1[1] = 0xabdd671e2a62fa; + out1[2] = 0x49280d7dd4009a81; + out1[3] = 0xd730336ee6bb86e8; +} diff --git a/fiat-zig/src/sm2_32.zig b/fiat-zig/src/sm2_32.zig new file mode 100644 index 00000000000..ffe5959f8f8 --- /dev/null +++ b/fiat-zig/src/sm2_32.zig @@ -0,0 +1,5208 @@ +// 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 sm2 '' 32 '2^256 - 2^224 - 2^96 + 2^64 - 1' 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): sm2 +// 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") +// +// 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 { + @setEvalBranchQuota(10000); + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + const T = std.meta.Int(source.signedness, dest.bits); + return @bitCast(@as(T, @truncate(target))); + } + } + return 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, 0xfffffffe); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x23, 0xffffffff); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x23, 0xffffffff); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x23, 0xffffffff); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x23, 0xffffffff); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x23, 0xffffffff); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x23, 0xffffffff); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, 0x0, x53, x50); + const x56 = (cast(u32, x55) + x51); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, 0x0, x49, x46); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x47, x44); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x45, x42); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x43, x40); + const x65 = (cast(u32, x64) + x41); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, 0x0, x23, x52); + var x68: u32 = undefined; + var x69: u1 = undefined; + addcarryxU32(&x68, &x69, x67, x25, x54); + var x70: u32 = undefined; + var x71: u1 = undefined; + addcarryxU32(&x70, &x71, x69, x27, x56); + var x72: u32 = undefined; + var x73: u1 = undefined; + addcarryxU32(&x72, &x73, x71, x29, x48); + var x74: u32 = undefined; + var x75: u1 = undefined; + addcarryxU32(&x74, &x75, x73, x31, x57); + var x76: u32 = undefined; + var x77: u1 = undefined; + addcarryxU32(&x76, &x77, x75, x33, x59); + var x78: u32 = undefined; + var x79: u1 = undefined; + addcarryxU32(&x78, &x79, x77, x35, x61); + var x80: u32 = undefined; + var x81: u1 = undefined; + addcarryxU32(&x80, &x81, x79, x37, x63); + var x82: u32 = undefined; + var x83: u1 = undefined; + addcarryxU32(&x82, &x83, x81, x39, x65); + var x84: u32 = undefined; + var x85: u32 = undefined; + mulxU32(&x84, &x85, x1, (arg2[7])); + var x86: u32 = undefined; + var x87: u32 = undefined; + mulxU32(&x86, &x87, x1, (arg2[6])); + var x88: u32 = undefined; + var x89: u32 = undefined; + mulxU32(&x88, &x89, x1, (arg2[5])); + var x90: u32 = undefined; + var x91: u32 = undefined; + mulxU32(&x90, &x91, x1, (arg2[4])); + var x92: u32 = undefined; + var x93: u32 = undefined; + mulxU32(&x92, &x93, x1, (arg2[3])); + var x94: u32 = undefined; + var x95: u32 = undefined; + mulxU32(&x94, &x95, x1, (arg2[2])); + var x96: u32 = undefined; + var x97: u32 = undefined; + mulxU32(&x96, &x97, x1, (arg2[1])); + var x98: u32 = undefined; + var x99: u32 = undefined; + mulxU32(&x98, &x99, x1, (arg2[0])); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, 0x0, x99, x96); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, x97, x94); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, x103, x95, x92); + var x106: u32 = undefined; + var x107: u1 = undefined; + addcarryxU32(&x106, &x107, x105, x93, x90); + var x108: u32 = undefined; + var x109: u1 = undefined; + addcarryxU32(&x108, &x109, x107, x91, x88); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, x109, x89, x86); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x87, x84); + const x114 = (cast(u32, x113) + x85); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, 0x0, x68, x98); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x70, x100); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x72, x102); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x74, x104); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x76, x106); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x78, x108); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x80, x110); + var x129: u32 = undefined; + var x130: u1 = undefined; + addcarryxU32(&x129, &x130, x128, x82, x112); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, x130, cast(u32, x83), x114); + var x133: u32 = undefined; + var x134: u32 = undefined; + mulxU32(&x133, &x134, x115, 0xfffffffe); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x115, 0xffffffff); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x115, 0xffffffff); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x115, 0xffffffff); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x115, 0xffffffff); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x115, 0xffffffff); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x115, 0xffffffff); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, 0x0, x146, x143); + const x149 = (cast(u32, x148) + x144); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, 0x0, x142, x139); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x140, x137); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x138, x135); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x136, x133); + const x158 = (cast(u32, x157) + x134); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, 0x0, x115, x145); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x117, x147); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x119, x149); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x121, x141); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x123, x150); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x125, x152); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x127, x154); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x129, x156); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x131, x158); + const x177 = (cast(u32, x176) + cast(u32, x132)); + var x178: u32 = undefined; + var x179: u32 = undefined; + mulxU32(&x178, &x179, x2, (arg2[7])); + var x180: u32 = undefined; + var x181: u32 = undefined; + mulxU32(&x180, &x181, x2, (arg2[6])); + var x182: u32 = undefined; + var x183: u32 = undefined; + mulxU32(&x182, &x183, x2, (arg2[5])); + var x184: u32 = undefined; + var x185: u32 = undefined; + mulxU32(&x184, &x185, x2, (arg2[4])); + var x186: u32 = undefined; + var x187: u32 = undefined; + mulxU32(&x186, &x187, x2, (arg2[3])); + var x188: u32 = undefined; + var x189: u32 = undefined; + mulxU32(&x188, &x189, x2, (arg2[2])); + var x190: u32 = undefined; + var x191: u32 = undefined; + mulxU32(&x190, &x191, x2, (arg2[1])); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x2, (arg2[0])); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, 0x0, x193, x190); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x191, x188); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x189, x186); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x187, x184); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x185, x182); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x183, x180); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, x181, x178); + const x208 = (cast(u32, x207) + x179); + var x209: u32 = undefined; + var x210: u1 = undefined; + addcarryxU32(&x209, &x210, 0x0, x161, x192); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, x210, 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: u32 = undefined; + mulxU32(&x227, &x228, x209, 0xfffffffe); + var x229: u32 = undefined; + var x230: u32 = undefined; + mulxU32(&x229, &x230, x209, 0xffffffff); + var x231: u32 = undefined; + var x232: u32 = undefined; + mulxU32(&x231, &x232, x209, 0xffffffff); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x209, 0xffffffff); + var x235: u32 = undefined; + var x236: u32 = undefined; + mulxU32(&x235, &x236, x209, 0xffffffff); + var x237: u32 = undefined; + var x238: u32 = undefined; + mulxU32(&x237, &x238, x209, 0xffffffff); + var x239: u32 = undefined; + var x240: u32 = undefined; + mulxU32(&x239, &x240, x209, 0xffffffff); + var x241: u32 = undefined; + var x242: u1 = undefined; + addcarryxU32(&x241, &x242, 0x0, x240, x237); + const x243 = (cast(u32, x242) + x238); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, 0x0, x236, x233); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x234, x231); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x232, x229); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x230, x227); + const x252 = (cast(u32, x251) + x228); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, 0x0, x209, x239); + var x255: u32 = undefined; + var x256: u1 = undefined; + addcarryxU32(&x255, &x256, x254, x211, x241); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, x256, x213, x243); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x215, x235); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x217, x244); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x219, x246); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x221, x248); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x223, x250); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x225, x252); + const x271 = (cast(u32, x270) + cast(u32, x226)); + var x272: u32 = undefined; + var x273: u32 = undefined; + mulxU32(&x272, &x273, x3, (arg2[7])); + var x274: u32 = undefined; + var x275: u32 = undefined; + mulxU32(&x274, &x275, x3, (arg2[6])); + var x276: u32 = undefined; + var x277: u32 = undefined; + mulxU32(&x276, &x277, x3, (arg2[5])); + var x278: u32 = undefined; + var x279: u32 = undefined; + mulxU32(&x278, &x279, x3, (arg2[4])); + var x280: u32 = undefined; + var x281: u32 = undefined; + mulxU32(&x280, &x281, x3, (arg2[3])); + var x282: u32 = undefined; + var x283: u32 = undefined; + mulxU32(&x282, &x283, x3, (arg2[2])); + var x284: u32 = undefined; + var x285: u32 = undefined; + mulxU32(&x284, &x285, x3, (arg2[1])); + var x286: u32 = undefined; + var x287: u32 = undefined; + mulxU32(&x286, &x287, x3, (arg2[0])); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, 0x0, x287, x284); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x285, x282); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x283, x280); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x281, x278); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, x295, x279, x276); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, x297, x277, x274); + var x300: u32 = undefined; + var x301: u1 = undefined; + addcarryxU32(&x300, &x301, x299, x275, x272); + const x302 = (cast(u32, x301) + x273); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, 0x0, x255, x286); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x257, x288); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x259, x290); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, x308, x261, x292); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, x310, x263, x294); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x265, x296); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x267, x298); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x269, x300); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x271, x302); + var x321: u32 = undefined; + var x322: u32 = undefined; + mulxU32(&x321, &x322, x303, 0xfffffffe); + var x323: u32 = undefined; + var x324: u32 = undefined; + mulxU32(&x323, &x324, x303, 0xffffffff); + var x325: u32 = undefined; + var x326: u32 = undefined; + mulxU32(&x325, &x326, x303, 0xffffffff); + var x327: u32 = undefined; + var x328: u32 = undefined; + mulxU32(&x327, &x328, x303, 0xffffffff); + var x329: u32 = undefined; + var x330: u32 = undefined; + mulxU32(&x329, &x330, x303, 0xffffffff); + var x331: u32 = undefined; + var x332: u32 = undefined; + mulxU32(&x331, &x332, x303, 0xffffffff); + var x333: u32 = undefined; + var x334: u32 = undefined; + mulxU32(&x333, &x334, x303, 0xffffffff); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, 0x0, x334, x331); + const x337 = (cast(u32, x336) + x332); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, 0x0, x330, x327); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x328, x325); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, x326, x323); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, x343, x324, x321); + const x346 = (cast(u32, x345) + x322); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, 0x0, x303, x333); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x305, x335); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, x307, x337); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x309, x329); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x311, x338); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, x313, x340); + var x359: u32 = undefined; + var x360: u1 = undefined; + addcarryxU32(&x359, &x360, x358, x315, x342); + var x361: u32 = undefined; + var x362: u1 = undefined; + addcarryxU32(&x361, &x362, x360, x317, x344); + var x363: u32 = undefined; + var x364: u1 = undefined; + addcarryxU32(&x363, &x364, x362, x319, x346); + const x365 = (cast(u32, x364) + cast(u32, x320)); + var x366: u32 = undefined; + var x367: u32 = undefined; + mulxU32(&x366, &x367, x4, (arg2[7])); + var x368: u32 = undefined; + var x369: u32 = undefined; + mulxU32(&x368, &x369, x4, (arg2[6])); + var x370: u32 = undefined; + var x371: u32 = undefined; + mulxU32(&x370, &x371, x4, (arg2[5])); + var x372: u32 = undefined; + var x373: u32 = undefined; + mulxU32(&x372, &x373, x4, (arg2[4])); + var x374: u32 = undefined; + var x375: u32 = undefined; + mulxU32(&x374, &x375, x4, (arg2[3])); + var x376: u32 = undefined; + var x377: u32 = undefined; + mulxU32(&x376, &x377, x4, (arg2[2])); + var x378: u32 = undefined; + var x379: u32 = undefined; + mulxU32(&x378, &x379, x4, (arg2[1])); + var x380: u32 = undefined; + var x381: u32 = undefined; + mulxU32(&x380, &x381, x4, (arg2[0])); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, 0x0, x381, x378); + var x384: u32 = undefined; + var x385: u1 = undefined; + addcarryxU32(&x384, &x385, x383, x379, x376); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, x385, x377, x374); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x375, x372); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x373, x370); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x371, x368); + var x394: u32 = undefined; + var x395: u1 = undefined; + addcarryxU32(&x394, &x395, x393, x369, x366); + const x396 = (cast(u32, x395) + x367); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, 0x0, x349, x380); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x351, x382); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, 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: u32 = undefined; + mulxU32(&x415, &x416, x397, 0xfffffffe); + var x417: u32 = undefined; + var x418: u32 = undefined; + mulxU32(&x417, &x418, x397, 0xffffffff); + var x419: u32 = undefined; + var x420: u32 = undefined; + mulxU32(&x419, &x420, x397, 0xffffffff); + var x421: u32 = undefined; + var x422: u32 = undefined; + mulxU32(&x421, &x422, x397, 0xffffffff); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x397, 0xffffffff); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x397, 0xffffffff); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x397, 0xffffffff); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, 0x0, x428, x425); + const x431 = (cast(u32, x430) + x426); + var x432: u32 = undefined; + var x433: u1 = undefined; + addcarryxU32(&x432, &x433, 0x0, x424, x421); + var x434: u32 = undefined; + var x435: u1 = undefined; + addcarryxU32(&x434, &x435, x433, x422, x419); + var x436: u32 = undefined; + var x437: u1 = undefined; + addcarryxU32(&x436, &x437, x435, x420, x417); + var x438: u32 = undefined; + var x439: u1 = undefined; + addcarryxU32(&x438, &x439, x437, x418, x415); + const x440 = (cast(u32, x439) + x416); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, 0x0, x397, x427); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x399, x429); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, x444, x401, x431); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x403, x423); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x405, x432); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x407, x434); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x409, x436); + var x455: u32 = undefined; + var x456: u1 = undefined; + addcarryxU32(&x455, &x456, x454, x411, x438); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, x456, x413, x440); + const x459 = (cast(u32, x458) + cast(u32, x414)); + var x460: u32 = undefined; + var x461: u32 = undefined; + mulxU32(&x460, &x461, x5, (arg2[7])); + var x462: u32 = undefined; + var x463: u32 = undefined; + mulxU32(&x462, &x463, x5, (arg2[6])); + var x464: u32 = undefined; + var x465: u32 = undefined; + mulxU32(&x464, &x465, x5, (arg2[5])); + var x466: u32 = undefined; + var x467: u32 = undefined; + mulxU32(&x466, &x467, x5, (arg2[4])); + var x468: u32 = undefined; + var x469: u32 = undefined; + mulxU32(&x468, &x469, x5, (arg2[3])); + var x470: u32 = undefined; + var x471: u32 = undefined; + mulxU32(&x470, &x471, x5, (arg2[2])); + var x472: u32 = undefined; + var x473: u32 = undefined; + mulxU32(&x472, &x473, x5, (arg2[1])); + var x474: u32 = undefined; + var x475: u32 = undefined; + mulxU32(&x474, &x475, x5, (arg2[0])); + var x476: u32 = undefined; + var x477: u1 = undefined; + addcarryxU32(&x476, &x477, 0x0, x475, x472); + var x478: u32 = undefined; + var x479: u1 = undefined; + addcarryxU32(&x478, &x479, x477, x473, x470); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, x479, x471, x468); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x469, x466); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x467, x464); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x465, x462); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x463, x460); + const x490 = (cast(u32, x489) + x461); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, 0x0, x443, x474); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x445, x476); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, x447, x478); + var x497: u32 = undefined; + var x498: u1 = undefined; + addcarryxU32(&x497, &x498, x496, x449, x480); + var x499: u32 = undefined; + var x500: u1 = undefined; + addcarryxU32(&x499, &x500, x498, x451, x482); + var x501: u32 = undefined; + var x502: u1 = undefined; + addcarryxU32(&x501, &x502, x500, x453, x484); + var x503: u32 = undefined; + var x504: u1 = undefined; + addcarryxU32(&x503, &x504, x502, x455, x486); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, x504, x457, x488); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x459, x490); + var x509: u32 = undefined; + var x510: u32 = undefined; + mulxU32(&x509, &x510, x491, 0xfffffffe); + var x511: u32 = undefined; + var x512: u32 = undefined; + mulxU32(&x511, &x512, x491, 0xffffffff); + var x513: u32 = undefined; + var x514: u32 = undefined; + mulxU32(&x513, &x514, x491, 0xffffffff); + var x515: u32 = undefined; + var x516: u32 = undefined; + mulxU32(&x515, &x516, x491, 0xffffffff); + var x517: u32 = undefined; + var x518: u32 = undefined; + mulxU32(&x517, &x518, x491, 0xffffffff); + var x519: u32 = undefined; + var x520: u32 = undefined; + mulxU32(&x519, &x520, x491, 0xffffffff); + var x521: u32 = undefined; + var x522: u32 = undefined; + mulxU32(&x521, &x522, x491, 0xffffffff); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, 0x0, x522, x519); + const x525 = (cast(u32, x524) + x520); + var x526: u32 = undefined; + var x527: u1 = undefined; + addcarryxU32(&x526, &x527, 0x0, x518, x515); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, x527, x516, x513); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x514, x511); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x512, x509); + const x534 = (cast(u32, x533) + x510); + var x535: u32 = undefined; + var x536: u1 = undefined; + addcarryxU32(&x535, &x536, 0x0, x491, x521); + var x537: u32 = undefined; + var x538: u1 = undefined; + addcarryxU32(&x537, &x538, x536, x493, x523); + var x539: u32 = undefined; + var x540: u1 = undefined; + addcarryxU32(&x539, &x540, x538, x495, x525); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, x540, x497, x517); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x499, x526); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x501, x528); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x503, x530); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x505, x532); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x507, x534); + const x553 = (cast(u32, x552) + cast(u32, x508)); + var x554: u32 = undefined; + var x555: u32 = undefined; + mulxU32(&x554, &x555, x6, (arg2[7])); + var x556: u32 = undefined; + var x557: u32 = undefined; + mulxU32(&x556, &x557, x6, (arg2[6])); + var x558: u32 = undefined; + var x559: u32 = undefined; + mulxU32(&x558, &x559, x6, (arg2[5])); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x6, (arg2[4])); + var x562: u32 = undefined; + var x563: u32 = undefined; + mulxU32(&x562, &x563, x6, (arg2[3])); + var x564: u32 = undefined; + var x565: u32 = undefined; + mulxU32(&x564, &x565, x6, (arg2[2])); + var x566: u32 = undefined; + var x567: u32 = undefined; + mulxU32(&x566, &x567, x6, (arg2[1])); + var x568: u32 = undefined; + var x569: u32 = undefined; + mulxU32(&x568, &x569, x6, (arg2[0])); + var x570: u32 = undefined; + var x571: u1 = undefined; + addcarryxU32(&x570, &x571, 0x0, x569, x566); + var x572: u32 = undefined; + var x573: u1 = undefined; + addcarryxU32(&x572, &x573, x571, x567, x564); + var x574: u32 = undefined; + var x575: u1 = undefined; + addcarryxU32(&x574, &x575, x573, x565, x562); + var x576: u32 = undefined; + var x577: u1 = undefined; + addcarryxU32(&x576, &x577, x575, x563, x560); + var x578: u32 = undefined; + var x579: u1 = undefined; + addcarryxU32(&x578, &x579, x577, x561, x558); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, x579, x559, x556); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x557, x554); + const x584 = (cast(u32, x583) + x555); + var x585: u32 = undefined; + var x586: u1 = undefined; + addcarryxU32(&x585, &x586, 0x0, x537, x568); + var x587: u32 = undefined; + var x588: u1 = undefined; + addcarryxU32(&x587, &x588, x586, x539, x570); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, x588, x541, x572); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, 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: u32 = undefined; + mulxU32(&x603, &x604, x585, 0xfffffffe); + var x605: u32 = undefined; + var x606: u32 = undefined; + mulxU32(&x605, &x606, x585, 0xffffffff); + var x607: u32 = undefined; + var x608: u32 = undefined; + mulxU32(&x607, &x608, x585, 0xffffffff); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x585, 0xffffffff); + var x611: u32 = undefined; + var x612: u32 = undefined; + mulxU32(&x611, &x612, x585, 0xffffffff); + var x613: u32 = undefined; + var x614: u32 = undefined; + mulxU32(&x613, &x614, x585, 0xffffffff); + var x615: u32 = undefined; + var x616: u32 = undefined; + mulxU32(&x615, &x616, x585, 0xffffffff); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, 0x0, x616, x613); + const x619 = (cast(u32, x618) + x614); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, 0x0, x612, x609); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x610, x607); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x608, x605); + var x626: u32 = undefined; + var x627: u1 = undefined; + addcarryxU32(&x626, &x627, x625, x606, x603); + const x628 = (cast(u32, x627) + x604); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, 0x0, x585, x615); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x587, x617); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x589, x619); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x591, x611); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x593, x620); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x595, x622); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x597, x624); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x599, x626); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x601, x628); + const x647 = (cast(u32, x646) + cast(u32, x602)); + var x648: u32 = undefined; + var x649: u32 = undefined; + mulxU32(&x648, &x649, x7, (arg2[7])); + var x650: u32 = undefined; + var x651: u32 = undefined; + mulxU32(&x650, &x651, x7, (arg2[6])); + var x652: u32 = undefined; + var x653: u32 = undefined; + mulxU32(&x652, &x653, x7, (arg2[5])); + var x654: u32 = undefined; + var x655: u32 = undefined; + mulxU32(&x654, &x655, x7, (arg2[4])); + var x656: u32 = undefined; + var x657: u32 = undefined; + mulxU32(&x656, &x657, x7, (arg2[3])); + var x658: u32 = undefined; + var x659: u32 = undefined; + mulxU32(&x658, &x659, x7, (arg2[2])); + var x660: u32 = undefined; + var x661: u32 = undefined; + mulxU32(&x660, &x661, x7, (arg2[1])); + var x662: u32 = undefined; + var x663: u32 = undefined; + mulxU32(&x662, &x663, x7, (arg2[0])); + var x664: u32 = undefined; + var x665: u1 = undefined; + addcarryxU32(&x664, &x665, 0x0, x663, x660); + var x666: u32 = undefined; + var x667: u1 = undefined; + addcarryxU32(&x666, &x667, x665, x661, x658); + var x668: u32 = undefined; + var x669: u1 = undefined; + addcarryxU32(&x668, &x669, x667, x659, x656); + var x670: u32 = undefined; + var x671: u1 = undefined; + addcarryxU32(&x670, &x671, x669, x657, x654); + var x672: u32 = undefined; + var x673: u1 = undefined; + addcarryxU32(&x672, &x673, x671, x655, x652); + var x674: u32 = undefined; + var x675: u1 = undefined; + addcarryxU32(&x674, &x675, x673, x653, x650); + var x676: u32 = undefined; + var x677: u1 = undefined; + addcarryxU32(&x676, &x677, x675, x651, x648); + const x678 = (cast(u32, x677) + x649); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, 0x0, x631, x662); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x633, x664); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x635, x666); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, x684, x637, x668); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x639, x670); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x641, x672); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x643, x674); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x645, x676); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, x694, x647, x678); + var x697: u32 = undefined; + var x698: u32 = undefined; + mulxU32(&x697, &x698, x679, 0xfffffffe); + var x699: u32 = undefined; + var x700: u32 = undefined; + mulxU32(&x699, &x700, x679, 0xffffffff); + var x701: u32 = undefined; + var x702: u32 = undefined; + mulxU32(&x701, &x702, x679, 0xffffffff); + var x703: u32 = undefined; + var x704: u32 = undefined; + mulxU32(&x703, &x704, x679, 0xffffffff); + var x705: u32 = undefined; + var x706: u32 = undefined; + mulxU32(&x705, &x706, x679, 0xffffffff); + var x707: u32 = undefined; + var x708: u32 = undefined; + mulxU32(&x707, &x708, x679, 0xffffffff); + var x709: u32 = undefined; + var x710: u32 = undefined; + mulxU32(&x709, &x710, x679, 0xffffffff); + var x711: u32 = undefined; + var x712: u1 = undefined; + addcarryxU32(&x711, &x712, 0x0, x710, x707); + const x713 = (cast(u32, x712) + x708); + var x714: u32 = undefined; + var x715: u1 = undefined; + addcarryxU32(&x714, &x715, 0x0, x706, x703); + var x716: u32 = undefined; + var x717: u1 = undefined; + addcarryxU32(&x716, &x717, x715, x704, x701); + var x718: u32 = undefined; + var x719: u1 = undefined; + addcarryxU32(&x718, &x719, x717, x702, x699); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, x719, x700, x697); + const x722 = (cast(u32, x721) + x698); + var x723: u32 = undefined; + var x724: u1 = undefined; + addcarryxU32(&x723, &x724, 0x0, x679, x709); + var x725: u32 = undefined; + var x726: u1 = undefined; + addcarryxU32(&x725, &x726, x724, x681, x711); + var x727: u32 = undefined; + var x728: u1 = undefined; + addcarryxU32(&x727, &x728, x726, x683, x713); + var x729: u32 = undefined; + var x730: u1 = undefined; + addcarryxU32(&x729, &x730, x728, x685, x705); + var x731: u32 = undefined; + var x732: u1 = undefined; + addcarryxU32(&x731, &x732, x730, x687, x714); + var x733: u32 = undefined; + var x734: u1 = undefined; + addcarryxU32(&x733, &x734, x732, x689, x716); + var x735: u32 = undefined; + var x736: u1 = undefined; + addcarryxU32(&x735, &x736, x734, x691, x718); + var x737: u32 = undefined; + var x738: u1 = undefined; + addcarryxU32(&x737, &x738, x736, x693, x720); + var x739: u32 = undefined; + var x740: u1 = undefined; + addcarryxU32(&x739, &x740, x738, x695, x722); + const x741 = (cast(u32, x740) + cast(u32, x696)); + var x742: u32 = undefined; + var x743: u1 = undefined; + subborrowxU32(&x742, &x743, 0x0, x725, 0xffffffff); + var x744: u32 = undefined; + var x745: u1 = undefined; + subborrowxU32(&x744, &x745, x743, x727, 0xffffffff); + var x746: u32 = undefined; + var x747: u1 = undefined; + subborrowxU32(&x746, &x747, x745, x729, cast(u32, 0x0)); + var x748: u32 = undefined; + var x749: u1 = undefined; + subborrowxU32(&x748, &x749, x747, x731, 0xffffffff); + var x750: u32 = undefined; + var x751: u1 = undefined; + subborrowxU32(&x750, &x751, x749, x733, 0xffffffff); + var x752: u32 = undefined; + var x753: u1 = undefined; + subborrowxU32(&x752, &x753, x751, x735, 0xffffffff); + var x754: u32 = undefined; + var x755: u1 = undefined; + subborrowxU32(&x754, &x755, x753, x737, 0xffffffff); + var x756: u32 = undefined; + var x757: u1 = undefined; + subborrowxU32(&x756, &x757, x755, x739, 0xfffffffe); + var x758: u32 = undefined; + var x759: u1 = undefined; + subborrowxU32(&x758, &x759, x757, x741, cast(u32, 0x0)); + var x760: u32 = undefined; + cmovznzU32(&x760, x759, x742, x725); + var x761: u32 = undefined; + cmovznzU32(&x761, x759, x744, x727); + var x762: u32 = undefined; + cmovznzU32(&x762, x759, x746, x729); + var x763: u32 = undefined; + cmovznzU32(&x763, x759, x748, x731); + var x764: u32 = undefined; + cmovznzU32(&x764, x759, x750, x733); + var x765: u32 = undefined; + cmovznzU32(&x765, x759, x752, x735); + var x766: u32 = undefined; + cmovznzU32(&x766, x759, x754, x737); + var x767: u32 = undefined; + cmovznzU32(&x767, x759, x756, x739); + out1[0] = x760; + out1[1] = x761; + out1[2] = x762; + out1[3] = x763; + out1[4] = x764; + out1[5] = x765; + out1[6] = x766; + out1[7] = x767; +} + +/// 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, 0xfffffffe); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x23, 0xffffffff); + var x44: u32 = undefined; + var x45: u32 = undefined; + mulxU32(&x44, &x45, x23, 0xffffffff); + var x46: u32 = undefined; + var x47: u32 = undefined; + mulxU32(&x46, &x47, x23, 0xffffffff); + var x48: u32 = undefined; + var x49: u32 = undefined; + mulxU32(&x48, &x49, x23, 0xffffffff); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x23, 0xffffffff); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x23, 0xffffffff); + var x54: u32 = undefined; + var x55: u1 = undefined; + addcarryxU32(&x54, &x55, 0x0, x53, x50); + const x56 = (cast(u32, x55) + x51); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, 0x0, x49, x46); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, x58, x47, x44); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x45, x42); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x43, x40); + const x65 = (cast(u32, x64) + x41); + var x66: u32 = undefined; + var x67: u1 = undefined; + addcarryxU32(&x66, &x67, 0x0, x23, x52); + var x68: u32 = undefined; + var x69: u1 = undefined; + addcarryxU32(&x68, &x69, x67, x25, x54); + var x70: u32 = undefined; + var x71: u1 = undefined; + addcarryxU32(&x70, &x71, x69, x27, x56); + var x72: u32 = undefined; + var x73: u1 = undefined; + addcarryxU32(&x72, &x73, x71, x29, x48); + var x74: u32 = undefined; + var x75: u1 = undefined; + addcarryxU32(&x74, &x75, x73, x31, x57); + var x76: u32 = undefined; + var x77: u1 = undefined; + addcarryxU32(&x76, &x77, x75, x33, x59); + var x78: u32 = undefined; + var x79: u1 = undefined; + addcarryxU32(&x78, &x79, x77, x35, x61); + var x80: u32 = undefined; + var x81: u1 = undefined; + addcarryxU32(&x80, &x81, x79, x37, x63); + var x82: u32 = undefined; + var x83: u1 = undefined; + addcarryxU32(&x82, &x83, x81, x39, x65); + var x84: u32 = undefined; + var x85: u32 = undefined; + mulxU32(&x84, &x85, x1, (arg1[7])); + var x86: u32 = undefined; + var x87: u32 = undefined; + mulxU32(&x86, &x87, x1, (arg1[6])); + var x88: u32 = undefined; + var x89: u32 = undefined; + mulxU32(&x88, &x89, x1, (arg1[5])); + var x90: u32 = undefined; + var x91: u32 = undefined; + mulxU32(&x90, &x91, x1, (arg1[4])); + var x92: u32 = undefined; + var x93: u32 = undefined; + mulxU32(&x92, &x93, x1, (arg1[3])); + var x94: u32 = undefined; + var x95: u32 = undefined; + mulxU32(&x94, &x95, x1, (arg1[2])); + var x96: u32 = undefined; + var x97: u32 = undefined; + mulxU32(&x96, &x97, x1, (arg1[1])); + var x98: u32 = undefined; + var x99: u32 = undefined; + mulxU32(&x98, &x99, x1, (arg1[0])); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, 0x0, x99, x96); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, x97, x94); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, x103, x95, x92); + var x106: u32 = undefined; + var x107: u1 = undefined; + addcarryxU32(&x106, &x107, x105, x93, x90); + var x108: u32 = undefined; + var x109: u1 = undefined; + addcarryxU32(&x108, &x109, x107, x91, x88); + var x110: u32 = undefined; + var x111: u1 = undefined; + addcarryxU32(&x110, &x111, x109, x89, x86); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x87, x84); + const x114 = (cast(u32, x113) + x85); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, 0x0, x68, x98); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x70, x100); + var x119: u32 = undefined; + var x120: u1 = undefined; + addcarryxU32(&x119, &x120, x118, x72, x102); + var x121: u32 = undefined; + var x122: u1 = undefined; + addcarryxU32(&x121, &x122, x120, x74, x104); + var x123: u32 = undefined; + var x124: u1 = undefined; + addcarryxU32(&x123, &x124, x122, x76, x106); + var x125: u32 = undefined; + var x126: u1 = undefined; + addcarryxU32(&x125, &x126, x124, x78, x108); + var x127: u32 = undefined; + var x128: u1 = undefined; + addcarryxU32(&x127, &x128, x126, x80, x110); + var x129: u32 = undefined; + var x130: u1 = undefined; + addcarryxU32(&x129, &x130, x128, x82, x112); + var x131: u32 = undefined; + var x132: u1 = undefined; + addcarryxU32(&x131, &x132, x130, cast(u32, x83), x114); + var x133: u32 = undefined; + var x134: u32 = undefined; + mulxU32(&x133, &x134, x115, 0xfffffffe); + var x135: u32 = undefined; + var x136: u32 = undefined; + mulxU32(&x135, &x136, x115, 0xffffffff); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x115, 0xffffffff); + var x139: u32 = undefined; + var x140: u32 = undefined; + mulxU32(&x139, &x140, x115, 0xffffffff); + var x141: u32 = undefined; + var x142: u32 = undefined; + mulxU32(&x141, &x142, x115, 0xffffffff); + var x143: u32 = undefined; + var x144: u32 = undefined; + mulxU32(&x143, &x144, x115, 0xffffffff); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x115, 0xffffffff); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, 0x0, x146, x143); + const x149 = (cast(u32, x148) + x144); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, 0x0, x142, x139); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x140, x137); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x138, x135); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, x136, x133); + const x158 = (cast(u32, x157) + x134); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, 0x0, x115, x145); + var x161: u32 = undefined; + var x162: u1 = undefined; + addcarryxU32(&x161, &x162, x160, x117, x147); + var x163: u32 = undefined; + var x164: u1 = undefined; + addcarryxU32(&x163, &x164, x162, x119, x149); + var x165: u32 = undefined; + var x166: u1 = undefined; + addcarryxU32(&x165, &x166, x164, x121, x141); + var x167: u32 = undefined; + var x168: u1 = undefined; + addcarryxU32(&x167, &x168, x166, x123, x150); + var x169: u32 = undefined; + var x170: u1 = undefined; + addcarryxU32(&x169, &x170, x168, x125, x152); + var x171: u32 = undefined; + var x172: u1 = undefined; + addcarryxU32(&x171, &x172, x170, x127, x154); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, x172, x129, x156); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, x131, x158); + const x177 = (cast(u32, x176) + cast(u32, x132)); + var x178: u32 = undefined; + var x179: u32 = undefined; + mulxU32(&x178, &x179, x2, (arg1[7])); + var x180: u32 = undefined; + var x181: u32 = undefined; + mulxU32(&x180, &x181, x2, (arg1[6])); + var x182: u32 = undefined; + var x183: u32 = undefined; + mulxU32(&x182, &x183, x2, (arg1[5])); + var x184: u32 = undefined; + var x185: u32 = undefined; + mulxU32(&x184, &x185, x2, (arg1[4])); + var x186: u32 = undefined; + var x187: u32 = undefined; + mulxU32(&x186, &x187, x2, (arg1[3])); + var x188: u32 = undefined; + var x189: u32 = undefined; + mulxU32(&x188, &x189, x2, (arg1[2])); + var x190: u32 = undefined; + var x191: u32 = undefined; + mulxU32(&x190, &x191, x2, (arg1[1])); + var x192: u32 = undefined; + var x193: u32 = undefined; + mulxU32(&x192, &x193, x2, (arg1[0])); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, 0x0, x193, x190); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x191, x188); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, x197, x189, x186); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x187, x184); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x185, x182); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x183, x180); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, x181, x178); + const x208 = (cast(u32, x207) + x179); + var x209: u32 = undefined; + var x210: u1 = undefined; + addcarryxU32(&x209, &x210, 0x0, x161, x192); + var x211: u32 = undefined; + var x212: u1 = undefined; + addcarryxU32(&x211, &x212, x210, 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: u32 = undefined; + mulxU32(&x227, &x228, x209, 0xfffffffe); + var x229: u32 = undefined; + var x230: u32 = undefined; + mulxU32(&x229, &x230, x209, 0xffffffff); + var x231: u32 = undefined; + var x232: u32 = undefined; + mulxU32(&x231, &x232, x209, 0xffffffff); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x209, 0xffffffff); + var x235: u32 = undefined; + var x236: u32 = undefined; + mulxU32(&x235, &x236, x209, 0xffffffff); + var x237: u32 = undefined; + var x238: u32 = undefined; + mulxU32(&x237, &x238, x209, 0xffffffff); + var x239: u32 = undefined; + var x240: u32 = undefined; + mulxU32(&x239, &x240, x209, 0xffffffff); + var x241: u32 = undefined; + var x242: u1 = undefined; + addcarryxU32(&x241, &x242, 0x0, x240, x237); + const x243 = (cast(u32, x242) + x238); + var x244: u32 = undefined; + var x245: u1 = undefined; + addcarryxU32(&x244, &x245, 0x0, x236, x233); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, x245, x234, x231); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, x247, x232, x229); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x230, x227); + const x252 = (cast(u32, x251) + x228); + var x253: u32 = undefined; + var x254: u1 = undefined; + addcarryxU32(&x253, &x254, 0x0, x209, x239); + var x255: u32 = undefined; + var x256: u1 = undefined; + addcarryxU32(&x255, &x256, x254, x211, x241); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, x256, x213, x243); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, x215, x235); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x217, x244); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, x219, x246); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, x221, x248); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, x223, x250); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, x225, x252); + const x271 = (cast(u32, x270) + cast(u32, x226)); + var x272: u32 = undefined; + var x273: u32 = undefined; + mulxU32(&x272, &x273, x3, (arg1[7])); + var x274: u32 = undefined; + var x275: u32 = undefined; + mulxU32(&x274, &x275, x3, (arg1[6])); + var x276: u32 = undefined; + var x277: u32 = undefined; + mulxU32(&x276, &x277, x3, (arg1[5])); + var x278: u32 = undefined; + var x279: u32 = undefined; + mulxU32(&x278, &x279, x3, (arg1[4])); + var x280: u32 = undefined; + var x281: u32 = undefined; + mulxU32(&x280, &x281, x3, (arg1[3])); + var x282: u32 = undefined; + var x283: u32 = undefined; + mulxU32(&x282, &x283, x3, (arg1[2])); + var x284: u32 = undefined; + var x285: u32 = undefined; + mulxU32(&x284, &x285, x3, (arg1[1])); + var x286: u32 = undefined; + var x287: u32 = undefined; + mulxU32(&x286, &x287, x3, (arg1[0])); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, 0x0, x287, x284); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x285, x282); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x283, x280); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x281, x278); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, x295, x279, x276); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, x297, x277, x274); + var x300: u32 = undefined; + var x301: u1 = undefined; + addcarryxU32(&x300, &x301, x299, x275, x272); + const x302 = (cast(u32, x301) + x273); + var x303: u32 = undefined; + var x304: u1 = undefined; + addcarryxU32(&x303, &x304, 0x0, x255, x286); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x257, x288); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x259, x290); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, x308, x261, x292); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, x310, x263, x294); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x265, x296); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x267, x298); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x269, x300); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x271, x302); + var x321: u32 = undefined; + var x322: u32 = undefined; + mulxU32(&x321, &x322, x303, 0xfffffffe); + var x323: u32 = undefined; + var x324: u32 = undefined; + mulxU32(&x323, &x324, x303, 0xffffffff); + var x325: u32 = undefined; + var x326: u32 = undefined; + mulxU32(&x325, &x326, x303, 0xffffffff); + var x327: u32 = undefined; + var x328: u32 = undefined; + mulxU32(&x327, &x328, x303, 0xffffffff); + var x329: u32 = undefined; + var x330: u32 = undefined; + mulxU32(&x329, &x330, x303, 0xffffffff); + var x331: u32 = undefined; + var x332: u32 = undefined; + mulxU32(&x331, &x332, x303, 0xffffffff); + var x333: u32 = undefined; + var x334: u32 = undefined; + mulxU32(&x333, &x334, x303, 0xffffffff); + var x335: u32 = undefined; + var x336: u1 = undefined; + addcarryxU32(&x335, &x336, 0x0, x334, x331); + const x337 = (cast(u32, x336) + x332); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, 0x0, x330, x327); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x328, x325); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, x326, x323); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, x343, x324, x321); + const x346 = (cast(u32, x345) + x322); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, 0x0, x303, x333); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, x305, x335); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, x307, x337); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, x309, x329); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, x354, x311, x338); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, x313, x340); + var x359: u32 = undefined; + var x360: u1 = undefined; + addcarryxU32(&x359, &x360, x358, x315, x342); + var x361: u32 = undefined; + var x362: u1 = undefined; + addcarryxU32(&x361, &x362, x360, x317, x344); + var x363: u32 = undefined; + var x364: u1 = undefined; + addcarryxU32(&x363, &x364, x362, x319, x346); + const x365 = (cast(u32, x364) + cast(u32, x320)); + var x366: u32 = undefined; + var x367: u32 = undefined; + mulxU32(&x366, &x367, x4, (arg1[7])); + var x368: u32 = undefined; + var x369: u32 = undefined; + mulxU32(&x368, &x369, x4, (arg1[6])); + var x370: u32 = undefined; + var x371: u32 = undefined; + mulxU32(&x370, &x371, x4, (arg1[5])); + var x372: u32 = undefined; + var x373: u32 = undefined; + mulxU32(&x372, &x373, x4, (arg1[4])); + var x374: u32 = undefined; + var x375: u32 = undefined; + mulxU32(&x374, &x375, x4, (arg1[3])); + var x376: u32 = undefined; + var x377: u32 = undefined; + mulxU32(&x376, &x377, x4, (arg1[2])); + var x378: u32 = undefined; + var x379: u32 = undefined; + mulxU32(&x378, &x379, x4, (arg1[1])); + var x380: u32 = undefined; + var x381: u32 = undefined; + mulxU32(&x380, &x381, x4, (arg1[0])); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, 0x0, x381, x378); + var x384: u32 = undefined; + var x385: u1 = undefined; + addcarryxU32(&x384, &x385, x383, x379, x376); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, x385, x377, x374); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, x375, x372); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, x389, x373, x370); + var x392: u32 = undefined; + var x393: u1 = undefined; + addcarryxU32(&x392, &x393, x391, x371, x368); + var x394: u32 = undefined; + var x395: u1 = undefined; + addcarryxU32(&x394, &x395, x393, x369, x366); + const x396 = (cast(u32, x395) + x367); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, 0x0, x349, x380); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x351, x382); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, 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: u32 = undefined; + mulxU32(&x415, &x416, x397, 0xfffffffe); + var x417: u32 = undefined; + var x418: u32 = undefined; + mulxU32(&x417, &x418, x397, 0xffffffff); + var x419: u32 = undefined; + var x420: u32 = undefined; + mulxU32(&x419, &x420, x397, 0xffffffff); + var x421: u32 = undefined; + var x422: u32 = undefined; + mulxU32(&x421, &x422, x397, 0xffffffff); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x397, 0xffffffff); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x397, 0xffffffff); + var x427: u32 = undefined; + var x428: u32 = undefined; + mulxU32(&x427, &x428, x397, 0xffffffff); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, 0x0, x428, x425); + const x431 = (cast(u32, x430) + x426); + var x432: u32 = undefined; + var x433: u1 = undefined; + addcarryxU32(&x432, &x433, 0x0, x424, x421); + var x434: u32 = undefined; + var x435: u1 = undefined; + addcarryxU32(&x434, &x435, x433, x422, x419); + var x436: u32 = undefined; + var x437: u1 = undefined; + addcarryxU32(&x436, &x437, x435, x420, x417); + var x438: u32 = undefined; + var x439: u1 = undefined; + addcarryxU32(&x438, &x439, x437, x418, x415); + const x440 = (cast(u32, x439) + x416); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, 0x0, x397, x427); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x399, x429); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, x444, x401, x431); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x403, x423); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x405, x432); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x407, x434); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x409, x436); + var x455: u32 = undefined; + var x456: u1 = undefined; + addcarryxU32(&x455, &x456, x454, x411, x438); + var x457: u32 = undefined; + var x458: u1 = undefined; + addcarryxU32(&x457, &x458, x456, x413, x440); + const x459 = (cast(u32, x458) + cast(u32, x414)); + var x460: u32 = undefined; + var x461: u32 = undefined; + mulxU32(&x460, &x461, x5, (arg1[7])); + var x462: u32 = undefined; + var x463: u32 = undefined; + mulxU32(&x462, &x463, x5, (arg1[6])); + var x464: u32 = undefined; + var x465: u32 = undefined; + mulxU32(&x464, &x465, x5, (arg1[5])); + var x466: u32 = undefined; + var x467: u32 = undefined; + mulxU32(&x466, &x467, x5, (arg1[4])); + var x468: u32 = undefined; + var x469: u32 = undefined; + mulxU32(&x468, &x469, x5, (arg1[3])); + var x470: u32 = undefined; + var x471: u32 = undefined; + mulxU32(&x470, &x471, x5, (arg1[2])); + var x472: u32 = undefined; + var x473: u32 = undefined; + mulxU32(&x472, &x473, x5, (arg1[1])); + var x474: u32 = undefined; + var x475: u32 = undefined; + mulxU32(&x474, &x475, x5, (arg1[0])); + var x476: u32 = undefined; + var x477: u1 = undefined; + addcarryxU32(&x476, &x477, 0x0, x475, x472); + var x478: u32 = undefined; + var x479: u1 = undefined; + addcarryxU32(&x478, &x479, x477, x473, x470); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, x479, x471, x468); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x469, x466); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x467, x464); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x465, x462); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x463, x460); + const x490 = (cast(u32, x489) + x461); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, 0x0, x443, x474); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x445, x476); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, x447, x478); + var x497: u32 = undefined; + var x498: u1 = undefined; + addcarryxU32(&x497, &x498, x496, x449, x480); + var x499: u32 = undefined; + var x500: u1 = undefined; + addcarryxU32(&x499, &x500, x498, x451, x482); + var x501: u32 = undefined; + var x502: u1 = undefined; + addcarryxU32(&x501, &x502, x500, x453, x484); + var x503: u32 = undefined; + var x504: u1 = undefined; + addcarryxU32(&x503, &x504, x502, x455, x486); + var x505: u32 = undefined; + var x506: u1 = undefined; + addcarryxU32(&x505, &x506, x504, x457, x488); + var x507: u32 = undefined; + var x508: u1 = undefined; + addcarryxU32(&x507, &x508, x506, x459, x490); + var x509: u32 = undefined; + var x510: u32 = undefined; + mulxU32(&x509, &x510, x491, 0xfffffffe); + var x511: u32 = undefined; + var x512: u32 = undefined; + mulxU32(&x511, &x512, x491, 0xffffffff); + var x513: u32 = undefined; + var x514: u32 = undefined; + mulxU32(&x513, &x514, x491, 0xffffffff); + var x515: u32 = undefined; + var x516: u32 = undefined; + mulxU32(&x515, &x516, x491, 0xffffffff); + var x517: u32 = undefined; + var x518: u32 = undefined; + mulxU32(&x517, &x518, x491, 0xffffffff); + var x519: u32 = undefined; + var x520: u32 = undefined; + mulxU32(&x519, &x520, x491, 0xffffffff); + var x521: u32 = undefined; + var x522: u32 = undefined; + mulxU32(&x521, &x522, x491, 0xffffffff); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, 0x0, x522, x519); + const x525 = (cast(u32, x524) + x520); + var x526: u32 = undefined; + var x527: u1 = undefined; + addcarryxU32(&x526, &x527, 0x0, x518, x515); + var x528: u32 = undefined; + var x529: u1 = undefined; + addcarryxU32(&x528, &x529, x527, x516, x513); + var x530: u32 = undefined; + var x531: u1 = undefined; + addcarryxU32(&x530, &x531, x529, x514, x511); + var x532: u32 = undefined; + var x533: u1 = undefined; + addcarryxU32(&x532, &x533, x531, x512, x509); + const x534 = (cast(u32, x533) + x510); + var x535: u32 = undefined; + var x536: u1 = undefined; + addcarryxU32(&x535, &x536, 0x0, x491, x521); + var x537: u32 = undefined; + var x538: u1 = undefined; + addcarryxU32(&x537, &x538, x536, x493, x523); + var x539: u32 = undefined; + var x540: u1 = undefined; + addcarryxU32(&x539, &x540, x538, x495, x525); + var x541: u32 = undefined; + var x542: u1 = undefined; + addcarryxU32(&x541, &x542, x540, x497, x517); + var x543: u32 = undefined; + var x544: u1 = undefined; + addcarryxU32(&x543, &x544, x542, x499, x526); + var x545: u32 = undefined; + var x546: u1 = undefined; + addcarryxU32(&x545, &x546, x544, x501, x528); + var x547: u32 = undefined; + var x548: u1 = undefined; + addcarryxU32(&x547, &x548, x546, x503, x530); + var x549: u32 = undefined; + var x550: u1 = undefined; + addcarryxU32(&x549, &x550, x548, x505, x532); + var x551: u32 = undefined; + var x552: u1 = undefined; + addcarryxU32(&x551, &x552, x550, x507, x534); + const x553 = (cast(u32, x552) + cast(u32, x508)); + var x554: u32 = undefined; + var x555: u32 = undefined; + mulxU32(&x554, &x555, x6, (arg1[7])); + var x556: u32 = undefined; + var x557: u32 = undefined; + mulxU32(&x556, &x557, x6, (arg1[6])); + var x558: u32 = undefined; + var x559: u32 = undefined; + mulxU32(&x558, &x559, x6, (arg1[5])); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x6, (arg1[4])); + var x562: u32 = undefined; + var x563: u32 = undefined; + mulxU32(&x562, &x563, x6, (arg1[3])); + var x564: u32 = undefined; + var x565: u32 = undefined; + mulxU32(&x564, &x565, x6, (arg1[2])); + var x566: u32 = undefined; + var x567: u32 = undefined; + mulxU32(&x566, &x567, x6, (arg1[1])); + var x568: u32 = undefined; + var x569: u32 = undefined; + mulxU32(&x568, &x569, x6, (arg1[0])); + var x570: u32 = undefined; + var x571: u1 = undefined; + addcarryxU32(&x570, &x571, 0x0, x569, x566); + var x572: u32 = undefined; + var x573: u1 = undefined; + addcarryxU32(&x572, &x573, x571, x567, x564); + var x574: u32 = undefined; + var x575: u1 = undefined; + addcarryxU32(&x574, &x575, x573, x565, x562); + var x576: u32 = undefined; + var x577: u1 = undefined; + addcarryxU32(&x576, &x577, x575, x563, x560); + var x578: u32 = undefined; + var x579: u1 = undefined; + addcarryxU32(&x578, &x579, x577, x561, x558); + var x580: u32 = undefined; + var x581: u1 = undefined; + addcarryxU32(&x580, &x581, x579, x559, x556); + var x582: u32 = undefined; + var x583: u1 = undefined; + addcarryxU32(&x582, &x583, x581, x557, x554); + const x584 = (cast(u32, x583) + x555); + var x585: u32 = undefined; + var x586: u1 = undefined; + addcarryxU32(&x585, &x586, 0x0, x537, x568); + var x587: u32 = undefined; + var x588: u1 = undefined; + addcarryxU32(&x587, &x588, x586, x539, x570); + var x589: u32 = undefined; + var x590: u1 = undefined; + addcarryxU32(&x589, &x590, x588, x541, x572); + var x591: u32 = undefined; + var x592: u1 = undefined; + addcarryxU32(&x591, &x592, x590, 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: u32 = undefined; + mulxU32(&x603, &x604, x585, 0xfffffffe); + var x605: u32 = undefined; + var x606: u32 = undefined; + mulxU32(&x605, &x606, x585, 0xffffffff); + var x607: u32 = undefined; + var x608: u32 = undefined; + mulxU32(&x607, &x608, x585, 0xffffffff); + var x609: u32 = undefined; + var x610: u32 = undefined; + mulxU32(&x609, &x610, x585, 0xffffffff); + var x611: u32 = undefined; + var x612: u32 = undefined; + mulxU32(&x611, &x612, x585, 0xffffffff); + var x613: u32 = undefined; + var x614: u32 = undefined; + mulxU32(&x613, &x614, x585, 0xffffffff); + var x615: u32 = undefined; + var x616: u32 = undefined; + mulxU32(&x615, &x616, x585, 0xffffffff); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, 0x0, x616, x613); + const x619 = (cast(u32, x618) + x614); + var x620: u32 = undefined; + var x621: u1 = undefined; + addcarryxU32(&x620, &x621, 0x0, x612, x609); + var x622: u32 = undefined; + var x623: u1 = undefined; + addcarryxU32(&x622, &x623, x621, x610, x607); + var x624: u32 = undefined; + var x625: u1 = undefined; + addcarryxU32(&x624, &x625, x623, x608, x605); + var x626: u32 = undefined; + var x627: u1 = undefined; + addcarryxU32(&x626, &x627, x625, x606, x603); + const x628 = (cast(u32, x627) + x604); + var x629: u32 = undefined; + var x630: u1 = undefined; + addcarryxU32(&x629, &x630, 0x0, x585, x615); + var x631: u32 = undefined; + var x632: u1 = undefined; + addcarryxU32(&x631, &x632, x630, x587, x617); + var x633: u32 = undefined; + var x634: u1 = undefined; + addcarryxU32(&x633, &x634, x632, x589, x619); + var x635: u32 = undefined; + var x636: u1 = undefined; + addcarryxU32(&x635, &x636, x634, x591, x611); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, x636, x593, x620); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, x638, x595, x622); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x597, x624); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x599, x626); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x601, x628); + const x647 = (cast(u32, x646) + cast(u32, x602)); + var x648: u32 = undefined; + var x649: u32 = undefined; + mulxU32(&x648, &x649, x7, (arg1[7])); + var x650: u32 = undefined; + var x651: u32 = undefined; + mulxU32(&x650, &x651, x7, (arg1[6])); + var x652: u32 = undefined; + var x653: u32 = undefined; + mulxU32(&x652, &x653, x7, (arg1[5])); + var x654: u32 = undefined; + var x655: u32 = undefined; + mulxU32(&x654, &x655, x7, (arg1[4])); + var x656: u32 = undefined; + var x657: u32 = undefined; + mulxU32(&x656, &x657, x7, (arg1[3])); + var x658: u32 = undefined; + var x659: u32 = undefined; + mulxU32(&x658, &x659, x7, (arg1[2])); + var x660: u32 = undefined; + var x661: u32 = undefined; + mulxU32(&x660, &x661, x7, (arg1[1])); + var x662: u32 = undefined; + var x663: u32 = undefined; + mulxU32(&x662, &x663, x7, (arg1[0])); + var x664: u32 = undefined; + var x665: u1 = undefined; + addcarryxU32(&x664, &x665, 0x0, x663, x660); + var x666: u32 = undefined; + var x667: u1 = undefined; + addcarryxU32(&x666, &x667, x665, x661, x658); + var x668: u32 = undefined; + var x669: u1 = undefined; + addcarryxU32(&x668, &x669, x667, x659, x656); + var x670: u32 = undefined; + var x671: u1 = undefined; + addcarryxU32(&x670, &x671, x669, x657, x654); + var x672: u32 = undefined; + var x673: u1 = undefined; + addcarryxU32(&x672, &x673, x671, x655, x652); + var x674: u32 = undefined; + var x675: u1 = undefined; + addcarryxU32(&x674, &x675, x673, x653, x650); + var x676: u32 = undefined; + var x677: u1 = undefined; + addcarryxU32(&x676, &x677, x675, x651, x648); + const x678 = (cast(u32, x677) + x649); + var x679: u32 = undefined; + var x680: u1 = undefined; + addcarryxU32(&x679, &x680, 0x0, x631, x662); + var x681: u32 = undefined; + var x682: u1 = undefined; + addcarryxU32(&x681, &x682, x680, x633, x664); + var x683: u32 = undefined; + var x684: u1 = undefined; + addcarryxU32(&x683, &x684, x682, x635, x666); + var x685: u32 = undefined; + var x686: u1 = undefined; + addcarryxU32(&x685, &x686, x684, x637, x668); + var x687: u32 = undefined; + var x688: u1 = undefined; + addcarryxU32(&x687, &x688, x686, x639, x670); + var x689: u32 = undefined; + var x690: u1 = undefined; + addcarryxU32(&x689, &x690, x688, x641, x672); + var x691: u32 = undefined; + var x692: u1 = undefined; + addcarryxU32(&x691, &x692, x690, x643, x674); + var x693: u32 = undefined; + var x694: u1 = undefined; + addcarryxU32(&x693, &x694, x692, x645, x676); + var x695: u32 = undefined; + var x696: u1 = undefined; + addcarryxU32(&x695, &x696, x694, x647, x678); + var x697: u32 = undefined; + var x698: u32 = undefined; + mulxU32(&x697, &x698, x679, 0xfffffffe); + var x699: u32 = undefined; + var x700: u32 = undefined; + mulxU32(&x699, &x700, x679, 0xffffffff); + var x701: u32 = undefined; + var x702: u32 = undefined; + mulxU32(&x701, &x702, x679, 0xffffffff); + var x703: u32 = undefined; + var x704: u32 = undefined; + mulxU32(&x703, &x704, x679, 0xffffffff); + var x705: u32 = undefined; + var x706: u32 = undefined; + mulxU32(&x705, &x706, x679, 0xffffffff); + var x707: u32 = undefined; + var x708: u32 = undefined; + mulxU32(&x707, &x708, x679, 0xffffffff); + var x709: u32 = undefined; + var x710: u32 = undefined; + mulxU32(&x709, &x710, x679, 0xffffffff); + var x711: u32 = undefined; + var x712: u1 = undefined; + addcarryxU32(&x711, &x712, 0x0, x710, x707); + const x713 = (cast(u32, x712) + x708); + var x714: u32 = undefined; + var x715: u1 = undefined; + addcarryxU32(&x714, &x715, 0x0, x706, x703); + var x716: u32 = undefined; + var x717: u1 = undefined; + addcarryxU32(&x716, &x717, x715, x704, x701); + var x718: u32 = undefined; + var x719: u1 = undefined; + addcarryxU32(&x718, &x719, x717, x702, x699); + var x720: u32 = undefined; + var x721: u1 = undefined; + addcarryxU32(&x720, &x721, x719, x700, x697); + const x722 = (cast(u32, x721) + x698); + var x723: u32 = undefined; + var x724: u1 = undefined; + addcarryxU32(&x723, &x724, 0x0, x679, x709); + var x725: u32 = undefined; + var x726: u1 = undefined; + addcarryxU32(&x725, &x726, x724, x681, x711); + var x727: u32 = undefined; + var x728: u1 = undefined; + addcarryxU32(&x727, &x728, x726, x683, x713); + var x729: u32 = undefined; + var x730: u1 = undefined; + addcarryxU32(&x729, &x730, x728, x685, x705); + var x731: u32 = undefined; + var x732: u1 = undefined; + addcarryxU32(&x731, &x732, x730, x687, x714); + var x733: u32 = undefined; + var x734: u1 = undefined; + addcarryxU32(&x733, &x734, x732, x689, x716); + var x735: u32 = undefined; + var x736: u1 = undefined; + addcarryxU32(&x735, &x736, x734, x691, x718); + var x737: u32 = undefined; + var x738: u1 = undefined; + addcarryxU32(&x737, &x738, x736, x693, x720); + var x739: u32 = undefined; + var x740: u1 = undefined; + addcarryxU32(&x739, &x740, x738, x695, x722); + const x741 = (cast(u32, x740) + cast(u32, x696)); + var x742: u32 = undefined; + var x743: u1 = undefined; + subborrowxU32(&x742, &x743, 0x0, x725, 0xffffffff); + var x744: u32 = undefined; + var x745: u1 = undefined; + subborrowxU32(&x744, &x745, x743, x727, 0xffffffff); + var x746: u32 = undefined; + var x747: u1 = undefined; + subborrowxU32(&x746, &x747, x745, x729, cast(u32, 0x0)); + var x748: u32 = undefined; + var x749: u1 = undefined; + subborrowxU32(&x748, &x749, x747, x731, 0xffffffff); + var x750: u32 = undefined; + var x751: u1 = undefined; + subborrowxU32(&x750, &x751, x749, x733, 0xffffffff); + var x752: u32 = undefined; + var x753: u1 = undefined; + subborrowxU32(&x752, &x753, x751, x735, 0xffffffff); + var x754: u32 = undefined; + var x755: u1 = undefined; + subborrowxU32(&x754, &x755, x753, x737, 0xffffffff); + var x756: u32 = undefined; + var x757: u1 = undefined; + subborrowxU32(&x756, &x757, x755, x739, 0xfffffffe); + var x758: u32 = undefined; + var x759: u1 = undefined; + subborrowxU32(&x758, &x759, x757, x741, cast(u32, 0x0)); + var x760: u32 = undefined; + cmovznzU32(&x760, x759, x742, x725); + var x761: u32 = undefined; + cmovznzU32(&x761, x759, x744, x727); + var x762: u32 = undefined; + cmovznzU32(&x762, x759, x746, x729); + var x763: u32 = undefined; + cmovznzU32(&x763, x759, x748, x731); + var x764: u32 = undefined; + cmovznzU32(&x764, x759, x750, x733); + var x765: u32 = undefined; + cmovznzU32(&x765, x759, x752, x735); + var x766: u32 = undefined; + cmovznzU32(&x766, x759, x754, x737); + var x767: u32 = undefined; + cmovznzU32(&x767, x759, x756, x739); + out1[0] = x760; + out1[1] = x761; + out1[2] = x762; + out1[3] = x763; + out1[4] = x764; + out1[5] = x765; + out1[6] = x766; + out1[7] = x767; +} + +/// 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, 0xffffffff); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, x3, 0xffffffff); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, x5, cast(u32, 0x0)); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, x7, 0xffffffff); + 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, 0xffffffff); + var x31: u32 = undefined; + var x32: u1 = undefined; + subborrowxU32(&x31, &x32, x30, x15, 0xfffffffe); + 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); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, x17); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, cast(u32, 0x0)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, x17); + 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, x17); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, (x17 & 0xfffffffe)); + 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); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, x17); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, cast(u32, 0x0)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, x17); + 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, x17); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, (x17 & 0xfffffffe)); + 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, 0xfffffffe); + var x4: u32 = undefined; + var x5: u32 = undefined; + mulxU32(&x4, &x5, x1, 0xffffffff); + var x6: u32 = undefined; + var x7: u32 = undefined; + mulxU32(&x6, &x7, x1, 0xffffffff); + var x8: u32 = undefined; + var x9: u32 = undefined; + mulxU32(&x8, &x9, x1, 0xffffffff); + var x10: u32 = undefined; + var x11: u32 = undefined; + mulxU32(&x10, &x11, x1, 0xffffffff); + var x12: u32 = undefined; + var x13: u32 = undefined; + mulxU32(&x12, &x13, x1, 0xffffffff); + var x14: u32 = undefined; + var x15: u32 = undefined; + mulxU32(&x14, &x15, x1, 0xffffffff); + var x16: u32 = undefined; + var x17: u1 = undefined; + addcarryxU32(&x16, &x17, 0x0, x15, x12); + var x18: u32 = undefined; + var x19: u1 = undefined; + addcarryxU32(&x18, &x19, 0x0, x11, x8); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x9, x6); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x7, x4); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x5, x2); + var x26: u32 = undefined; + var x27: u1 = undefined; + addcarryxU32(&x26, &x27, 0x0, x1, x14); + var x28: u32 = undefined; + var x29: u1 = undefined; + addcarryxU32(&x28, &x29, x27, cast(u32, 0x0), x16); + var x30: u32 = undefined; + var x31: u1 = undefined; + addcarryxU32(&x30, &x31, x29, cast(u32, 0x0), (cast(u32, x17) + x13)); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, cast(u32, 0x0), x10); + var x34: u32 = undefined; + var x35: u1 = undefined; + addcarryxU32(&x34, &x35, x33, cast(u32, 0x0), 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, 0x0, x28, (arg1[1])); + var x44: u32 = undefined; + var x45: u1 = undefined; + addcarryxU32(&x44, &x45, x43, x30, cast(u32, 0x0)); + 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, (cast(u32, x41) + (cast(u32, x25) + x3)), cast(u32, 0x0)); + var x58: u32 = undefined; + var x59: u32 = undefined; + mulxU32(&x58, &x59, x42, 0xfffffffe); + var x60: u32 = undefined; + var x61: u32 = undefined; + mulxU32(&x60, &x61, x42, 0xffffffff); + var x62: u32 = undefined; + var x63: u32 = undefined; + mulxU32(&x62, &x63, x42, 0xffffffff); + var x64: u32 = undefined; + var x65: u32 = undefined; + mulxU32(&x64, &x65, x42, 0xffffffff); + var x66: u32 = undefined; + var x67: u32 = undefined; + mulxU32(&x66, &x67, x42, 0xffffffff); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x42, 0xffffffff); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x42, 0xffffffff); + var x72: u32 = undefined; + var x73: u1 = undefined; + addcarryxU32(&x72, &x73, 0x0, x71, x68); + var x74: u32 = undefined; + var x75: u1 = undefined; + addcarryxU32(&x74, &x75, 0x0, x67, x64); + var x76: u32 = undefined; + var x77: u1 = undefined; + addcarryxU32(&x76, &x77, x75, x65, x62); + var x78: u32 = undefined; + var x79: u1 = undefined; + addcarryxU32(&x78, &x79, x77, x63, x60); + var x80: u32 = undefined; + var x81: u1 = undefined; + addcarryxU32(&x80, &x81, x79, x61, x58); + var x82: u32 = undefined; + var x83: u1 = undefined; + addcarryxU32(&x82, &x83, 0x0, x42, x70); + var x84: u32 = undefined; + var x85: u1 = undefined; + addcarryxU32(&x84, &x85, x83, x44, x72); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, x85, x46, (cast(u32, x73) + x69)); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x48, x66); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x50, x74); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x52, x76); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x54, x78); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x56, x80); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, x97, cast(u32, x57), (cast(u32, x81) + x59)); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, 0x0, x84, (arg1[2])); + var x102: u32 = undefined; + var x103: u1 = undefined; + addcarryxU32(&x102, &x103, x101, x86, cast(u32, 0x0)); + var x104: u32 = undefined; + var x105: u1 = undefined; + addcarryxU32(&x104, &x105, x103, x88, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x116, &x117, x100, 0xfffffffe); + var x118: u32 = undefined; + var x119: u32 = undefined; + mulxU32(&x118, &x119, x100, 0xffffffff); + var x120: u32 = undefined; + var x121: u32 = undefined; + mulxU32(&x120, &x121, x100, 0xffffffff); + var x122: u32 = undefined; + var x123: u32 = undefined; + mulxU32(&x122, &x123, x100, 0xffffffff); + var x124: u32 = undefined; + var x125: u32 = undefined; + mulxU32(&x124, &x125, x100, 0xffffffff); + var x126: u32 = undefined; + var x127: u32 = undefined; + mulxU32(&x126, &x127, x100, 0xffffffff); + var x128: u32 = undefined; + var x129: u32 = undefined; + mulxU32(&x128, &x129, x100, 0xffffffff); + var x130: u32 = undefined; + var x131: u1 = undefined; + addcarryxU32(&x130, &x131, 0x0, x129, x126); + var x132: u32 = undefined; + var x133: u1 = undefined; + addcarryxU32(&x132, &x133, 0x0, x125, x122); + var x134: u32 = undefined; + var x135: u1 = undefined; + addcarryxU32(&x134, &x135, x133, x123, x120); + var x136: u32 = undefined; + var x137: u1 = undefined; + addcarryxU32(&x136, &x137, x135, x121, x118); + var x138: u32 = undefined; + var x139: u1 = undefined; + addcarryxU32(&x138, &x139, x137, x119, x116); + var x140: u32 = undefined; + var x141: u1 = undefined; + addcarryxU32(&x140, &x141, 0x0, x100, x128); + var x142: u32 = undefined; + var x143: u1 = undefined; + addcarryxU32(&x142, &x143, x141, x102, x130); + var x144: u32 = undefined; + var x145: u1 = undefined; + addcarryxU32(&x144, &x145, x143, x104, (cast(u32, x131) + x127)); + var x146: u32 = undefined; + var x147: u1 = undefined; + addcarryxU32(&x146, &x147, x145, x106, x124); + var x148: u32 = undefined; + var x149: u1 = undefined; + addcarryxU32(&x148, &x149, x147, x108, x132); + var x150: u32 = undefined; + var x151: u1 = undefined; + addcarryxU32(&x150, &x151, x149, x110, x134); + var x152: u32 = undefined; + var x153: u1 = undefined; + addcarryxU32(&x152, &x153, x151, x112, x136); + var x154: u32 = undefined; + var x155: u1 = undefined; + addcarryxU32(&x154, &x155, x153, x114, x138); + var x156: u32 = undefined; + var x157: u1 = undefined; + addcarryxU32(&x156, &x157, x155, (cast(u32, x115) + cast(u32, x99)), (cast(u32, x139) + x117)); + var x158: u32 = undefined; + var x159: u1 = undefined; + addcarryxU32(&x158, &x159, 0x0, x142, (arg1[3])); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x144, cast(u32, 0x0)); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x146, cast(u32, 0x0)); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, x163, x148, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x174, &x175, x158, 0xfffffffe); + var x176: u32 = undefined; + var x177: u32 = undefined; + mulxU32(&x176, &x177, x158, 0xffffffff); + var x178: u32 = undefined; + var x179: u32 = undefined; + mulxU32(&x178, &x179, x158, 0xffffffff); + var x180: u32 = undefined; + var x181: u32 = undefined; + mulxU32(&x180, &x181, x158, 0xffffffff); + var x182: u32 = undefined; + var x183: u32 = undefined; + mulxU32(&x182, &x183, x158, 0xffffffff); + var x184: u32 = undefined; + var x185: u32 = undefined; + mulxU32(&x184, &x185, x158, 0xffffffff); + var x186: u32 = undefined; + var x187: u32 = undefined; + mulxU32(&x186, &x187, x158, 0xffffffff); + var x188: u32 = undefined; + var x189: u1 = undefined; + addcarryxU32(&x188, &x189, 0x0, x187, x184); + var x190: u32 = undefined; + var x191: u1 = undefined; + addcarryxU32(&x190, &x191, 0x0, x183, x180); + var x192: u32 = undefined; + var x193: u1 = undefined; + addcarryxU32(&x192, &x193, x191, x181, x178); + var x194: u32 = undefined; + var x195: u1 = undefined; + addcarryxU32(&x194, &x195, x193, x179, x176); + var x196: u32 = undefined; + var x197: u1 = undefined; + addcarryxU32(&x196, &x197, x195, x177, x174); + var x198: u32 = undefined; + var x199: u1 = undefined; + addcarryxU32(&x198, &x199, 0x0, x158, x186); + var x200: u32 = undefined; + var x201: u1 = undefined; + addcarryxU32(&x200, &x201, x199, x160, x188); + var x202: u32 = undefined; + var x203: u1 = undefined; + addcarryxU32(&x202, &x203, x201, x162, (cast(u32, x189) + x185)); + var x204: u32 = undefined; + var x205: u1 = undefined; + addcarryxU32(&x204, &x205, x203, x164, x182); + var x206: u32 = undefined; + var x207: u1 = undefined; + addcarryxU32(&x206, &x207, x205, x166, x190); + var x208: u32 = undefined; + var x209: u1 = undefined; + addcarryxU32(&x208, &x209, x207, x168, x192); + var x210: u32 = undefined; + var x211: u1 = undefined; + addcarryxU32(&x210, &x211, x209, x170, x194); + var x212: u32 = undefined; + var x213: u1 = undefined; + addcarryxU32(&x212, &x213, x211, x172, x196); + var x214: u32 = undefined; + var x215: u1 = undefined; + addcarryxU32(&x214, &x215, x213, (cast(u32, x173) + cast(u32, x157)), (cast(u32, x197) + x175)); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, 0x0, x200, (arg1[4])); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x202, cast(u32, 0x0)); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x204, cast(u32, 0x0)); + var x222: u32 = undefined; + var x223: u1 = undefined; + addcarryxU32(&x222, &x223, x221, x206, cast(u32, 0x0)); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, x223, x208, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x232, &x233, x216, 0xfffffffe); + var x234: u32 = undefined; + var x235: u32 = undefined; + mulxU32(&x234, &x235, x216, 0xffffffff); + var x236: u32 = undefined; + var x237: u32 = undefined; + mulxU32(&x236, &x237, x216, 0xffffffff); + var x238: u32 = undefined; + var x239: u32 = undefined; + mulxU32(&x238, &x239, x216, 0xffffffff); + var x240: u32 = undefined; + var x241: u32 = undefined; + mulxU32(&x240, &x241, x216, 0xffffffff); + var x242: u32 = undefined; + var x243: u32 = undefined; + mulxU32(&x242, &x243, x216, 0xffffffff); + var x244: u32 = undefined; + var x245: u32 = undefined; + mulxU32(&x244, &x245, x216, 0xffffffff); + var x246: u32 = undefined; + var x247: u1 = undefined; + addcarryxU32(&x246, &x247, 0x0, x245, x242); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, 0x0, x241, x238); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x239, x236); + var x252: u32 = undefined; + var x253: u1 = undefined; + addcarryxU32(&x252, &x253, x251, x237, x234); + var x254: u32 = undefined; + var x255: u1 = undefined; + addcarryxU32(&x254, &x255, x253, x235, x232); + var x256: u32 = undefined; + var x257: u1 = undefined; + addcarryxU32(&x256, &x257, 0x0, x216, x244); + var x258: u32 = undefined; + var x259: u1 = undefined; + addcarryxU32(&x258, &x259, x257, x218, x246); + var x260: u32 = undefined; + var x261: u1 = undefined; + addcarryxU32(&x260, &x261, x259, x220, (cast(u32, x247) + x243)); + var x262: u32 = undefined; + var x263: u1 = undefined; + addcarryxU32(&x262, &x263, x261, x222, x240); + var x264: u32 = undefined; + var x265: u1 = undefined; + addcarryxU32(&x264, &x265, x263, x224, x248); + var x266: u32 = undefined; + var x267: u1 = undefined; + addcarryxU32(&x266, &x267, x265, x226, x250); + var x268: u32 = undefined; + var x269: u1 = undefined; + addcarryxU32(&x268, &x269, x267, x228, x252); + var x270: u32 = undefined; + var x271: u1 = undefined; + addcarryxU32(&x270, &x271, x269, x230, x254); + var x272: u32 = undefined; + var x273: u1 = undefined; + addcarryxU32(&x272, &x273, x271, (cast(u32, x231) + cast(u32, x215)), (cast(u32, x255) + x233)); + var x274: u32 = undefined; + var x275: u1 = undefined; + addcarryxU32(&x274, &x275, 0x0, x258, (arg1[5])); + var x276: u32 = undefined; + var x277: u1 = undefined; + addcarryxU32(&x276, &x277, x275, x260, cast(u32, 0x0)); + var x278: u32 = undefined; + var x279: u1 = undefined; + addcarryxU32(&x278, &x279, x277, x262, cast(u32, 0x0)); + var x280: u32 = undefined; + var x281: u1 = undefined; + addcarryxU32(&x280, &x281, x279, x264, cast(u32, 0x0)); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, x281, x266, cast(u32, 0x0)); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x268, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x290, &x291, x274, 0xfffffffe); + var x292: u32 = undefined; + var x293: u32 = undefined; + mulxU32(&x292, &x293, x274, 0xffffffff); + var x294: u32 = undefined; + var x295: u32 = undefined; + mulxU32(&x294, &x295, x274, 0xffffffff); + var x296: u32 = undefined; + var x297: u32 = undefined; + mulxU32(&x296, &x297, x274, 0xffffffff); + var x298: u32 = undefined; + var x299: u32 = undefined; + mulxU32(&x298, &x299, x274, 0xffffffff); + var x300: u32 = undefined; + var x301: u32 = undefined; + mulxU32(&x300, &x301, x274, 0xffffffff); + var x302: u32 = undefined; + var x303: u32 = undefined; + mulxU32(&x302, &x303, x274, 0xffffffff); + var x304: u32 = undefined; + var x305: u1 = undefined; + addcarryxU32(&x304, &x305, 0x0, x303, x300); + var x306: u32 = undefined; + var x307: u1 = undefined; + addcarryxU32(&x306, &x307, 0x0, x299, x296); + var x308: u32 = undefined; + var x309: u1 = undefined; + addcarryxU32(&x308, &x309, x307, x297, x294); + var x310: u32 = undefined; + var x311: u1 = undefined; + addcarryxU32(&x310, &x311, x309, x295, x292); + var x312: u32 = undefined; + var x313: u1 = undefined; + addcarryxU32(&x312, &x313, x311, x293, x290); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, 0x0, x274, x302); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x276, x304); + var x318: u32 = undefined; + var x319: u1 = undefined; + addcarryxU32(&x318, &x319, x317, x278, (cast(u32, x305) + x301)); + var x320: u32 = undefined; + var x321: u1 = undefined; + addcarryxU32(&x320, &x321, x319, x280, x298); + var x322: u32 = undefined; + var x323: u1 = undefined; + addcarryxU32(&x322, &x323, x321, x282, x306); + var x324: u32 = undefined; + var x325: u1 = undefined; + addcarryxU32(&x324, &x325, x323, x284, x308); + var x326: u32 = undefined; + var x327: u1 = undefined; + addcarryxU32(&x326, &x327, x325, x286, x310); + var x328: u32 = undefined; + var x329: u1 = undefined; + addcarryxU32(&x328, &x329, x327, x288, x312); + var x330: u32 = undefined; + var x331: u1 = undefined; + addcarryxU32(&x330, &x331, x329, (cast(u32, x289) + cast(u32, x273)), (cast(u32, x313) + x291)); + var x332: u32 = undefined; + var x333: u1 = undefined; + addcarryxU32(&x332, &x333, 0x0, x316, (arg1[6])); + var x334: u32 = undefined; + var x335: u1 = undefined; + addcarryxU32(&x334, &x335, x333, x318, cast(u32, 0x0)); + var x336: u32 = undefined; + var x337: u1 = undefined; + addcarryxU32(&x336, &x337, x335, x320, cast(u32, 0x0)); + var x338: u32 = undefined; + var x339: u1 = undefined; + addcarryxU32(&x338, &x339, x337, x322, cast(u32, 0x0)); + var x340: u32 = undefined; + var x341: u1 = undefined; + addcarryxU32(&x340, &x341, x339, x324, cast(u32, 0x0)); + var x342: u32 = undefined; + var x343: u1 = undefined; + addcarryxU32(&x342, &x343, x341, x326, cast(u32, 0x0)); + var x344: u32 = undefined; + var x345: u1 = undefined; + addcarryxU32(&x344, &x345, x343, x328, cast(u32, 0x0)); + var x346: u32 = undefined; + var x347: u1 = undefined; + addcarryxU32(&x346, &x347, x345, x330, cast(u32, 0x0)); + var x348: u32 = undefined; + var x349: u32 = undefined; + mulxU32(&x348, &x349, x332, 0xfffffffe); + var x350: u32 = undefined; + var x351: u32 = undefined; + mulxU32(&x350, &x351, x332, 0xffffffff); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x332, 0xffffffff); + var x354: u32 = undefined; + var x355: u32 = undefined; + mulxU32(&x354, &x355, x332, 0xffffffff); + var x356: u32 = undefined; + var x357: u32 = undefined; + mulxU32(&x356, &x357, x332, 0xffffffff); + var x358: u32 = undefined; + var x359: u32 = undefined; + mulxU32(&x358, &x359, x332, 0xffffffff); + var x360: u32 = undefined; + var x361: u32 = undefined; + mulxU32(&x360, &x361, x332, 0xffffffff); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, 0x0, x361, x358); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, 0x0, x357, x354); + var x366: u32 = undefined; + var x367: u1 = undefined; + addcarryxU32(&x366, &x367, x365, x355, x352); + var x368: u32 = undefined; + var x369: u1 = undefined; + addcarryxU32(&x368, &x369, x367, x353, x350); + var x370: u32 = undefined; + var x371: u1 = undefined; + addcarryxU32(&x370, &x371, x369, x351, x348); + var x372: u32 = undefined; + var x373: u1 = undefined; + addcarryxU32(&x372, &x373, 0x0, x332, x360); + var x374: u32 = undefined; + var x375: u1 = undefined; + addcarryxU32(&x374, &x375, x373, x334, x362); + var x376: u32 = undefined; + var x377: u1 = undefined; + addcarryxU32(&x376, &x377, x375, x336, (cast(u32, x363) + x359)); + var x378: u32 = undefined; + var x379: u1 = undefined; + addcarryxU32(&x378, &x379, x377, x338, x356); + var x380: u32 = undefined; + var x381: u1 = undefined; + addcarryxU32(&x380, &x381, x379, x340, x364); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, x381, x342, x366); + var x384: u32 = undefined; + var x385: u1 = undefined; + addcarryxU32(&x384, &x385, x383, x344, x368); + var x386: u32 = undefined; + var x387: u1 = undefined; + addcarryxU32(&x386, &x387, x385, x346, x370); + var x388: u32 = undefined; + var x389: u1 = undefined; + addcarryxU32(&x388, &x389, x387, (cast(u32, x347) + cast(u32, x331)), (cast(u32, x371) + x349)); + var x390: u32 = undefined; + var x391: u1 = undefined; + addcarryxU32(&x390, &x391, 0x0, x374, (arg1[7])); + 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: u1 = undefined; + addcarryxU32(&x398, &x399, x397, x382, cast(u32, 0x0)); + var x400: u32 = undefined; + var x401: u1 = undefined; + addcarryxU32(&x400, &x401, x399, x384, cast(u32, 0x0)); + var x402: u32 = undefined; + var x403: u1 = undefined; + addcarryxU32(&x402, &x403, x401, x386, cast(u32, 0x0)); + var x404: u32 = undefined; + var x405: u1 = undefined; + addcarryxU32(&x404, &x405, x403, x388, cast(u32, 0x0)); + var x406: u32 = undefined; + var x407: u32 = undefined; + mulxU32(&x406, &x407, x390, 0xfffffffe); + var x408: u32 = undefined; + var x409: u32 = undefined; + mulxU32(&x408, &x409, x390, 0xffffffff); + var x410: u32 = undefined; + var x411: u32 = undefined; + mulxU32(&x410, &x411, x390, 0xffffffff); + var x412: u32 = undefined; + var x413: u32 = undefined; + mulxU32(&x412, &x413, x390, 0xffffffff); + var x414: u32 = undefined; + var x415: u32 = undefined; + mulxU32(&x414, &x415, x390, 0xffffffff); + var x416: u32 = undefined; + var x417: u32 = undefined; + mulxU32(&x416, &x417, x390, 0xffffffff); + var x418: u32 = undefined; + var x419: u32 = undefined; + mulxU32(&x418, &x419, x390, 0xffffffff); + 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, 0x0, x415, x412); + var x424: u32 = undefined; + var x425: u1 = undefined; + addcarryxU32(&x424, &x425, x423, x413, x410); + var x426: u32 = undefined; + var x427: u1 = undefined; + addcarryxU32(&x426, &x427, x425, x411, x408); + var x428: u32 = undefined; + var x429: u1 = undefined; + addcarryxU32(&x428, &x429, x427, x409, x406); + var x430: u32 = undefined; + var x431: u1 = undefined; + addcarryxU32(&x430, &x431, 0x0, x390, x418); + var x432: u32 = undefined; + var x433: u1 = undefined; + addcarryxU32(&x432, &x433, x431, x392, x420); + var x434: u32 = undefined; + var x435: u1 = undefined; + addcarryxU32(&x434, &x435, x433, x394, (cast(u32, x421) + x417)); + var x436: u32 = undefined; + var x437: u1 = undefined; + addcarryxU32(&x436, &x437, x435, x396, x414); + var x438: u32 = undefined; + var x439: u1 = undefined; + addcarryxU32(&x438, &x439, x437, x398, x422); + var x440: u32 = undefined; + var x441: u1 = undefined; + addcarryxU32(&x440, &x441, x439, x400, x424); + var x442: u32 = undefined; + var x443: u1 = undefined; + addcarryxU32(&x442, &x443, x441, x402, x426); + var x444: u32 = undefined; + var x445: u1 = undefined; + addcarryxU32(&x444, &x445, x443, x404, x428); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, x445, (cast(u32, x405) + cast(u32, x389)), (cast(u32, x429) + x407)); + var x448: u32 = undefined; + var x449: u1 = undefined; + subborrowxU32(&x448, &x449, 0x0, x432, 0xffffffff); + var x450: u32 = undefined; + var x451: u1 = undefined; + subborrowxU32(&x450, &x451, x449, x434, 0xffffffff); + var x452: u32 = undefined; + var x453: u1 = undefined; + subborrowxU32(&x452, &x453, x451, x436, cast(u32, 0x0)); + var x454: u32 = undefined; + var x455: u1 = undefined; + subborrowxU32(&x454, &x455, x453, x438, 0xffffffff); + var x456: u32 = undefined; + var x457: u1 = undefined; + subborrowxU32(&x456, &x457, x455, x440, 0xffffffff); + var x458: u32 = undefined; + var x459: u1 = undefined; + subborrowxU32(&x458, &x459, x457, x442, 0xffffffff); + var x460: u32 = undefined; + var x461: u1 = undefined; + subborrowxU32(&x460, &x461, x459, x444, 0xffffffff); + var x462: u32 = undefined; + var x463: u1 = undefined; + subborrowxU32(&x462, &x463, x461, x446, 0xfffffffe); + var x464: u32 = undefined; + var x465: u1 = undefined; + subborrowxU32(&x464, &x465, x463, cast(u32, x447), cast(u32, 0x0)); + var x466: u32 = undefined; + cmovznzU32(&x466, x465, x448, x432); + var x467: u32 = undefined; + cmovznzU32(&x467, x465, x450, x434); + var x468: u32 = undefined; + cmovznzU32(&x468, x465, x452, x436); + var x469: u32 = undefined; + cmovznzU32(&x469, x465, x454, x438); + var x470: u32 = undefined; + cmovznzU32(&x470, x465, x456, x440); + var x471: u32 = undefined; + cmovznzU32(&x471, x465, x458, x442); + var x472: u32 = undefined; + cmovznzU32(&x472, x465, x460, x444); + var x473: u32 = undefined; + cmovznzU32(&x473, x465, x462, x446); + out1[0] = x466; + out1[1] = x467; + out1[2] = x468; + out1[3] = x469; + out1[4] = x470; + out1[5] = x471; + out1[6] = x472; + out1[7] = x473; +} + +/// 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, 0x4); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, 0x2); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, 0x2); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, 0xffffffff); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, 0x2); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, 0x3); + var x21: u32 = undefined; + var x22: u1 = undefined; + addcarryxU32(&x21, &x22, 0x0, x20, x17); + var x23: u32 = undefined; + var x24: u1 = undefined; + addcarryxU32(&x23, &x24, x22, cast(u32, cast(u1, x18)), x15); + var x25: u32 = undefined; + var x26: u1 = undefined; + addcarryxU32(&x25, &x26, x24, x16, x13); + var x27: u32 = undefined; + var x28: u1 = undefined; + addcarryxU32(&x27, &x28, x26, cast(u32, cast(u1, x14)), x8); + var x29: u32 = undefined; + var x30: u1 = undefined; + addcarryxU32(&x29, &x30, x28, cast(u32, 0x0), x8); + var x31: u32 = undefined; + var x32: u1 = undefined; + addcarryxU32(&x31, &x32, x30, cast(u32, 0x0), x11); + var x33: u32 = undefined; + var x34: u1 = undefined; + addcarryxU32(&x33, &x34, x32, cast(u32, cast(u1, x12)), x9); + var x35: u32 = undefined; + var x36: u32 = undefined; + mulxU32(&x35, &x36, x19, 0xfffffffe); + var x37: u32 = undefined; + var x38: u32 = undefined; + mulxU32(&x37, &x38, x19, 0xffffffff); + var x39: u32 = undefined; + var x40: u32 = undefined; + mulxU32(&x39, &x40, x19, 0xffffffff); + var x41: u32 = undefined; + var x42: u32 = undefined; + mulxU32(&x41, &x42, x19, 0xffffffff); + var x43: u32 = undefined; + var x44: u32 = undefined; + mulxU32(&x43, &x44, x19, 0xffffffff); + var x45: u32 = undefined; + var x46: u32 = undefined; + mulxU32(&x45, &x46, x19, 0xffffffff); + var x47: u32 = undefined; + var x48: u32 = undefined; + mulxU32(&x47, &x48, x19, 0xffffffff); + var x49: u32 = undefined; + var x50: u1 = undefined; + addcarryxU32(&x49, &x50, 0x0, x48, x45); + var x51: u32 = undefined; + var x52: u1 = undefined; + addcarryxU32(&x51, &x52, 0x0, x44, x41); + var x53: u32 = undefined; + var x54: u1 = undefined; + addcarryxU32(&x53, &x54, x52, x42, x39); + var x55: u32 = undefined; + var x56: u1 = undefined; + addcarryxU32(&x55, &x56, x54, x40, x37); + var x57: u32 = undefined; + var x58: u1 = undefined; + addcarryxU32(&x57, &x58, x56, x38, x35); + var x59: u32 = undefined; + var x60: u1 = undefined; + addcarryxU32(&x59, &x60, 0x0, x19, x47); + var x61: u32 = undefined; + var x62: u1 = undefined; + addcarryxU32(&x61, &x62, x60, x21, x49); + var x63: u32 = undefined; + var x64: u1 = undefined; + addcarryxU32(&x63, &x64, x62, x23, (cast(u32, x50) + x46)); + var x65: u32 = undefined; + var x66: u1 = undefined; + addcarryxU32(&x65, &x66, x64, x25, x43); + var x67: u32 = undefined; + var x68: u1 = undefined; + addcarryxU32(&x67, &x68, x66, x27, x51); + var x69: u32 = undefined; + var x70: u1 = undefined; + addcarryxU32(&x69, &x70, x68, x29, x53); + var x71: u32 = undefined; + var x72: u1 = undefined; + addcarryxU32(&x71, &x72, x70, x31, x55); + var x73: u32 = undefined; + var x74: u1 = undefined; + addcarryxU32(&x73, &x74, x72, x33, x57); + var x75: u32 = undefined; + var x76: u1 = undefined; + addcarryxU32(&x75, &x76, x74, (cast(u32, x34) + x10), (cast(u32, x58) + x36)); + var x77: u32 = undefined; + var x78: u32 = undefined; + mulxU32(&x77, &x78, x1, 0x4); + var x79: u32 = undefined; + var x80: u32 = undefined; + mulxU32(&x79, &x80, x1, 0x2); + var x81: u32 = undefined; + var x82: u32 = undefined; + mulxU32(&x81, &x82, x1, 0x2); + var x83: u32 = undefined; + var x84: u32 = undefined; + mulxU32(&x83, &x84, x1, 0xffffffff); + var x85: u32 = undefined; + var x86: u32 = undefined; + mulxU32(&x85, &x86, x1, 0x2); + var x87: u32 = undefined; + var x88: u32 = undefined; + mulxU32(&x87, &x88, x1, 0x3); + 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, cast(u32, cast(u1, 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, cast(u32, cast(u1, x82)), x1); + var x97: u32 = undefined; + var x98: u1 = undefined; + addcarryxU32(&x97, &x98, x96, cast(u32, 0x0), x1); + var x99: u32 = undefined; + var x100: u1 = undefined; + addcarryxU32(&x99, &x100, x98, cast(u32, 0x0), x79); + var x101: u32 = undefined; + var x102: u1 = undefined; + addcarryxU32(&x101, &x102, x100, cast(u32, cast(u1, x80)), x77); + var x103: u32 = undefined; + var x104: u1 = undefined; + addcarryxU32(&x103, &x104, 0x0, x61, x87); + var x105: u32 = undefined; + var x106: u1 = undefined; + addcarryxU32(&x105, &x106, x104, x63, x89); + var x107: u32 = undefined; + var x108: u1 = undefined; + addcarryxU32(&x107, &x108, x106, x65, x91); + var x109: u32 = undefined; + var x110: u1 = undefined; + addcarryxU32(&x109, &x110, x108, x67, x93); + var x111: u32 = undefined; + var x112: u1 = undefined; + addcarryxU32(&x111, &x112, x110, x69, x95); + var x113: u32 = undefined; + var x114: u1 = undefined; + addcarryxU32(&x113, &x114, x112, x71, x97); + var x115: u32 = undefined; + var x116: u1 = undefined; + addcarryxU32(&x115, &x116, x114, x73, x99); + var x117: u32 = undefined; + var x118: u1 = undefined; + addcarryxU32(&x117, &x118, x116, x75, x101); + var x119: u32 = undefined; + var x120: u32 = undefined; + mulxU32(&x119, &x120, x103, 0xfffffffe); + var x121: u32 = undefined; + var x122: u32 = undefined; + mulxU32(&x121, &x122, x103, 0xffffffff); + var x123: u32 = undefined; + var x124: u32 = undefined; + mulxU32(&x123, &x124, x103, 0xffffffff); + var x125: u32 = undefined; + var x126: u32 = undefined; + mulxU32(&x125, &x126, x103, 0xffffffff); + var x127: u32 = undefined; + var x128: u32 = undefined; + mulxU32(&x127, &x128, x103, 0xffffffff); + var x129: u32 = undefined; + var x130: u32 = undefined; + mulxU32(&x129, &x130, x103, 0xffffffff); + var x131: u32 = undefined; + var x132: u32 = undefined; + mulxU32(&x131, &x132, x103, 0xffffffff); + var x133: u32 = undefined; + var x134: u1 = undefined; + addcarryxU32(&x133, &x134, 0x0, x132, x129); + var x135: u32 = undefined; + var x136: u1 = undefined; + addcarryxU32(&x135, &x136, 0x0, x128, x125); + var x137: u32 = undefined; + var x138: u1 = undefined; + addcarryxU32(&x137, &x138, x136, x126, x123); + var x139: u32 = undefined; + var x140: u1 = undefined; + addcarryxU32(&x139, &x140, x138, x124, x121); + var x141: u32 = undefined; + var x142: u1 = undefined; + addcarryxU32(&x141, &x142, x140, x122, x119); + var x143: u32 = undefined; + var x144: u1 = undefined; + addcarryxU32(&x143, &x144, 0x0, x103, x131); + var x145: u32 = undefined; + var x146: u1 = undefined; + addcarryxU32(&x145, &x146, x144, x105, x133); + var x147: u32 = undefined; + var x148: u1 = undefined; + addcarryxU32(&x147, &x148, x146, x107, (cast(u32, x134) + x130)); + var x149: u32 = undefined; + var x150: u1 = undefined; + addcarryxU32(&x149, &x150, x148, x109, x127); + var x151: u32 = undefined; + var x152: u1 = undefined; + addcarryxU32(&x151, &x152, x150, x111, x135); + var x153: u32 = undefined; + var x154: u1 = undefined; + addcarryxU32(&x153, &x154, x152, x113, x137); + var x155: u32 = undefined; + var x156: u1 = undefined; + addcarryxU32(&x155, &x156, x154, x115, x139); + var x157: u32 = undefined; + var x158: u1 = undefined; + addcarryxU32(&x157, &x158, x156, x117, x141); + var x159: u32 = undefined; + var x160: u1 = undefined; + addcarryxU32(&x159, &x160, x158, ((cast(u32, x118) + cast(u32, x76)) + (cast(u32, x102) + x78)), (cast(u32, x142) + x120)); + var x161: u32 = undefined; + var x162: u32 = undefined; + mulxU32(&x161, &x162, x2, 0x4); + var x163: u32 = undefined; + var x164: u32 = undefined; + mulxU32(&x163, &x164, x2, 0x2); + var x165: u32 = undefined; + var x166: u32 = undefined; + mulxU32(&x165, &x166, x2, 0x2); + var x167: u32 = undefined; + var x168: u32 = undefined; + mulxU32(&x167, &x168, x2, 0xffffffff); + var x169: u32 = undefined; + var x170: u32 = undefined; + mulxU32(&x169, &x170, x2, 0x2); + var x171: u32 = undefined; + var x172: u32 = undefined; + mulxU32(&x171, &x172, x2, 0x3); + var x173: u32 = undefined; + var x174: u1 = undefined; + addcarryxU32(&x173, &x174, 0x0, x172, x169); + var x175: u32 = undefined; + var x176: u1 = undefined; + addcarryxU32(&x175, &x176, x174, cast(u32, cast(u1, x170)), x167); + var x177: u32 = undefined; + var x178: u1 = undefined; + addcarryxU32(&x177, &x178, x176, x168, x165); + var x179: u32 = undefined; + var x180: u1 = undefined; + addcarryxU32(&x179, &x180, x178, cast(u32, cast(u1, x166)), x2); + var x181: u32 = undefined; + var x182: u1 = undefined; + addcarryxU32(&x181, &x182, x180, cast(u32, 0x0), x2); + var x183: u32 = undefined; + var x184: u1 = undefined; + addcarryxU32(&x183, &x184, x182, cast(u32, 0x0), x163); + var x185: u32 = undefined; + var x186: u1 = undefined; + addcarryxU32(&x185, &x186, x184, cast(u32, cast(u1, x164)), x161); + var x187: u32 = undefined; + var x188: u1 = undefined; + addcarryxU32(&x187, &x188, 0x0, x145, x171); + var x189: u32 = undefined; + var x190: u1 = undefined; + addcarryxU32(&x189, &x190, x188, x147, x173); + var x191: u32 = undefined; + var x192: u1 = undefined; + addcarryxU32(&x191, &x192, x190, x149, x175); + var x193: u32 = undefined; + var x194: u1 = undefined; + addcarryxU32(&x193, &x194, x192, x151, x177); + var x195: u32 = undefined; + var x196: u1 = undefined; + addcarryxU32(&x195, &x196, x194, x153, x179); + var x197: u32 = undefined; + var x198: u1 = undefined; + addcarryxU32(&x197, &x198, x196, x155, x181); + var x199: u32 = undefined; + var x200: u1 = undefined; + addcarryxU32(&x199, &x200, x198, x157, x183); + var x201: u32 = undefined; + var x202: u1 = undefined; + addcarryxU32(&x201, &x202, x200, x159, x185); + var x203: u32 = undefined; + var x204: u32 = undefined; + mulxU32(&x203, &x204, x187, 0xfffffffe); + var x205: u32 = undefined; + var x206: u32 = undefined; + mulxU32(&x205, &x206, x187, 0xffffffff); + var x207: u32 = undefined; + var x208: u32 = undefined; + mulxU32(&x207, &x208, x187, 0xffffffff); + var x209: u32 = undefined; + var x210: u32 = undefined; + mulxU32(&x209, &x210, x187, 0xffffffff); + var x211: u32 = undefined; + var x212: u32 = undefined; + mulxU32(&x211, &x212, x187, 0xffffffff); + var x213: u32 = undefined; + var x214: u32 = undefined; + mulxU32(&x213, &x214, x187, 0xffffffff); + var x215: u32 = undefined; + var x216: u32 = undefined; + mulxU32(&x215, &x216, x187, 0xffffffff); + var x217: u32 = undefined; + var x218: u1 = undefined; + addcarryxU32(&x217, &x218, 0x0, x216, x213); + var x219: u32 = undefined; + var x220: u1 = undefined; + addcarryxU32(&x219, &x220, 0x0, x212, x209); + var x221: u32 = undefined; + var x222: u1 = undefined; + addcarryxU32(&x221, &x222, x220, x210, x207); + var x223: u32 = undefined; + var x224: u1 = undefined; + addcarryxU32(&x223, &x224, x222, x208, x205); + var x225: u32 = undefined; + var x226: u1 = undefined; + addcarryxU32(&x225, &x226, x224, x206, x203); + var x227: u32 = undefined; + var x228: u1 = undefined; + addcarryxU32(&x227, &x228, 0x0, x187, x215); + var x229: u32 = undefined; + var x230: u1 = undefined; + addcarryxU32(&x229, &x230, x228, x189, x217); + var x231: u32 = undefined; + var x232: u1 = undefined; + addcarryxU32(&x231, &x232, x230, x191, (cast(u32, x218) + x214)); + var x233: u32 = undefined; + var x234: u1 = undefined; + addcarryxU32(&x233, &x234, x232, x193, x211); + var x235: u32 = undefined; + var x236: u1 = undefined; + addcarryxU32(&x235, &x236, x234, x195, x219); + var x237: u32 = undefined; + var x238: u1 = undefined; + addcarryxU32(&x237, &x238, x236, x197, x221); + var x239: u32 = undefined; + var x240: u1 = undefined; + addcarryxU32(&x239, &x240, x238, x199, x223); + var x241: u32 = undefined; + var x242: u1 = undefined; + addcarryxU32(&x241, &x242, x240, x201, x225); + var x243: u32 = undefined; + var x244: u1 = undefined; + addcarryxU32(&x243, &x244, x242, ((cast(u32, x202) + cast(u32, x160)) + (cast(u32, x186) + x162)), (cast(u32, x226) + x204)); + var x245: u32 = undefined; + var x246: u32 = undefined; + mulxU32(&x245, &x246, x3, 0x4); + var x247: u32 = undefined; + var x248: u32 = undefined; + mulxU32(&x247, &x248, x3, 0x2); + var x249: u32 = undefined; + var x250: u32 = undefined; + mulxU32(&x249, &x250, x3, 0x2); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x3, 0xffffffff); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x3, 0x2); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x3, 0x3); + var x257: u32 = undefined; + var x258: u1 = undefined; + addcarryxU32(&x257, &x258, 0x0, x256, x253); + var x259: u32 = undefined; + var x260: u1 = undefined; + addcarryxU32(&x259, &x260, x258, cast(u32, cast(u1, x254)), x251); + var x261: u32 = undefined; + var x262: u1 = undefined; + addcarryxU32(&x261, &x262, x260, x252, x249); + var x263: u32 = undefined; + var x264: u1 = undefined; + addcarryxU32(&x263, &x264, x262, cast(u32, cast(u1, x250)), x3); + var x265: u32 = undefined; + var x266: u1 = undefined; + addcarryxU32(&x265, &x266, x264, cast(u32, 0x0), x3); + var x267: u32 = undefined; + var x268: u1 = undefined; + addcarryxU32(&x267, &x268, x266, cast(u32, 0x0), x247); + var x269: u32 = undefined; + var x270: u1 = undefined; + addcarryxU32(&x269, &x270, x268, cast(u32, cast(u1, x248)), x245); + var x271: u32 = undefined; + var x272: u1 = undefined; + addcarryxU32(&x271, &x272, 0x0, x229, x255); + var x273: u32 = undefined; + var x274: u1 = undefined; + addcarryxU32(&x273, &x274, x272, x231, x257); + var x275: u32 = undefined; + var x276: u1 = undefined; + addcarryxU32(&x275, &x276, x274, x233, x259); + var x277: u32 = undefined; + var x278: u1 = undefined; + addcarryxU32(&x277, &x278, x276, x235, x261); + var x279: u32 = undefined; + var x280: u1 = undefined; + addcarryxU32(&x279, &x280, x278, x237, x263); + var x281: u32 = undefined; + var x282: u1 = undefined; + addcarryxU32(&x281, &x282, x280, x239, x265); + var x283: u32 = undefined; + var x284: u1 = undefined; + addcarryxU32(&x283, &x284, x282, x241, x267); + var x285: u32 = undefined; + var x286: u1 = undefined; + addcarryxU32(&x285, &x286, x284, x243, x269); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x271, 0xfffffffe); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x271, 0xffffffff); + var x291: u32 = undefined; + var x292: u32 = undefined; + mulxU32(&x291, &x292, x271, 0xffffffff); + var x293: u32 = undefined; + var x294: u32 = undefined; + mulxU32(&x293, &x294, x271, 0xffffffff); + var x295: u32 = undefined; + var x296: u32 = undefined; + mulxU32(&x295, &x296, x271, 0xffffffff); + var x297: u32 = undefined; + var x298: u32 = undefined; + mulxU32(&x297, &x298, x271, 0xffffffff); + var x299: u32 = undefined; + var x300: u32 = undefined; + mulxU32(&x299, &x300, x271, 0xffffffff); + 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, 0x0, x296, x293); + var x305: u32 = undefined; + var x306: u1 = undefined; + addcarryxU32(&x305, &x306, x304, x294, x291); + var x307: u32 = undefined; + var x308: u1 = undefined; + addcarryxU32(&x307, &x308, x306, x292, x289); + var x309: u32 = undefined; + var x310: u1 = undefined; + addcarryxU32(&x309, &x310, x308, x290, x287); + var x311: u32 = undefined; + var x312: u1 = undefined; + addcarryxU32(&x311, &x312, 0x0, x271, x299); + var x313: u32 = undefined; + var x314: u1 = undefined; + addcarryxU32(&x313, &x314, x312, x273, x301); + var x315: u32 = undefined; + var x316: u1 = undefined; + addcarryxU32(&x315, &x316, x314, x275, (cast(u32, x302) + x298)); + var x317: u32 = undefined; + var x318: u1 = undefined; + addcarryxU32(&x317, &x318, x316, x277, x295); + var x319: u32 = undefined; + var x320: u1 = undefined; + addcarryxU32(&x319, &x320, x318, x279, x303); + var x321: u32 = undefined; + var x322: u1 = undefined; + addcarryxU32(&x321, &x322, x320, x281, x305); + var x323: u32 = undefined; + var x324: u1 = undefined; + addcarryxU32(&x323, &x324, x322, x283, x307); + var x325: u32 = undefined; + var x326: u1 = undefined; + addcarryxU32(&x325, &x326, x324, x285, x309); + var x327: u32 = undefined; + var x328: u1 = undefined; + addcarryxU32(&x327, &x328, x326, ((cast(u32, x286) + cast(u32, x244)) + (cast(u32, x270) + x246)), (cast(u32, x310) + x288)); + var x329: u32 = undefined; + var x330: u32 = undefined; + mulxU32(&x329, &x330, x4, 0x4); + var x331: u32 = undefined; + var x332: u32 = undefined; + mulxU32(&x331, &x332, x4, 0x2); + var x333: u32 = undefined; + var x334: u32 = undefined; + mulxU32(&x333, &x334, x4, 0x2); + var x335: u32 = undefined; + var x336: u32 = undefined; + mulxU32(&x335, &x336, x4, 0xffffffff); + var x337: u32 = undefined; + var x338: u32 = undefined; + mulxU32(&x337, &x338, x4, 0x2); + var x339: u32 = undefined; + var x340: u32 = undefined; + mulxU32(&x339, &x340, x4, 0x3); + var x341: u32 = undefined; + var x342: u1 = undefined; + addcarryxU32(&x341, &x342, 0x0, x340, x337); + var x343: u32 = undefined; + var x344: u1 = undefined; + addcarryxU32(&x343, &x344, x342, cast(u32, cast(u1, x338)), x335); + var x345: u32 = undefined; + var x346: u1 = undefined; + addcarryxU32(&x345, &x346, x344, x336, x333); + var x347: u32 = undefined; + var x348: u1 = undefined; + addcarryxU32(&x347, &x348, x346, cast(u32, cast(u1, x334)), x4); + var x349: u32 = undefined; + var x350: u1 = undefined; + addcarryxU32(&x349, &x350, x348, cast(u32, 0x0), x4); + var x351: u32 = undefined; + var x352: u1 = undefined; + addcarryxU32(&x351, &x352, x350, cast(u32, 0x0), x331); + var x353: u32 = undefined; + var x354: u1 = undefined; + addcarryxU32(&x353, &x354, x352, cast(u32, cast(u1, x332)), x329); + var x355: u32 = undefined; + var x356: u1 = undefined; + addcarryxU32(&x355, &x356, 0x0, x313, x339); + var x357: u32 = undefined; + var x358: u1 = undefined; + addcarryxU32(&x357, &x358, x356, x315, x341); + var x359: u32 = undefined; + var x360: u1 = undefined; + addcarryxU32(&x359, &x360, x358, x317, x343); + var x361: u32 = undefined; + var x362: u1 = undefined; + addcarryxU32(&x361, &x362, x360, x319, x345); + var x363: u32 = undefined; + var x364: u1 = undefined; + addcarryxU32(&x363, &x364, x362, x321, x347); + var x365: u32 = undefined; + var x366: u1 = undefined; + addcarryxU32(&x365, &x366, x364, x323, x349); + var x367: u32 = undefined; + var x368: u1 = undefined; + addcarryxU32(&x367, &x368, x366, x325, x351); + var x369: u32 = undefined; + var x370: u1 = undefined; + addcarryxU32(&x369, &x370, x368, x327, x353); + var x371: u32 = undefined; + var x372: u32 = undefined; + mulxU32(&x371, &x372, x355, 0xfffffffe); + var x373: u32 = undefined; + var x374: u32 = undefined; + mulxU32(&x373, &x374, x355, 0xffffffff); + var x375: u32 = undefined; + var x376: u32 = undefined; + mulxU32(&x375, &x376, x355, 0xffffffff); + var x377: u32 = undefined; + var x378: u32 = undefined; + mulxU32(&x377, &x378, x355, 0xffffffff); + var x379: u32 = undefined; + var x380: u32 = undefined; + mulxU32(&x379, &x380, x355, 0xffffffff); + var x381: u32 = undefined; + var x382: u32 = undefined; + mulxU32(&x381, &x382, x355, 0xffffffff); + var x383: u32 = undefined; + var x384: u32 = undefined; + mulxU32(&x383, &x384, x355, 0xffffffff); + var x385: u32 = undefined; + var x386: u1 = undefined; + addcarryxU32(&x385, &x386, 0x0, x384, x381); + var x387: u32 = undefined; + var x388: u1 = undefined; + addcarryxU32(&x387, &x388, 0x0, x380, x377); + var x389: u32 = undefined; + var x390: u1 = undefined; + addcarryxU32(&x389, &x390, x388, x378, x375); + var x391: u32 = undefined; + var x392: u1 = undefined; + addcarryxU32(&x391, &x392, x390, x376, x373); + var x393: u32 = undefined; + var x394: u1 = undefined; + addcarryxU32(&x393, &x394, x392, x374, x371); + var x395: u32 = undefined; + var x396: u1 = undefined; + addcarryxU32(&x395, &x396, 0x0, x355, x383); + var x397: u32 = undefined; + var x398: u1 = undefined; + addcarryxU32(&x397, &x398, x396, x357, x385); + var x399: u32 = undefined; + var x400: u1 = undefined; + addcarryxU32(&x399, &x400, x398, x359, (cast(u32, x386) + x382)); + var x401: u32 = undefined; + var x402: u1 = undefined; + addcarryxU32(&x401, &x402, x400, x361, x379); + var x403: u32 = undefined; + var x404: u1 = undefined; + addcarryxU32(&x403, &x404, x402, x363, x387); + var x405: u32 = undefined; + var x406: u1 = undefined; + addcarryxU32(&x405, &x406, x404, x365, x389); + var x407: u32 = undefined; + var x408: u1 = undefined; + addcarryxU32(&x407, &x408, x406, x367, x391); + var x409: u32 = undefined; + var x410: u1 = undefined; + addcarryxU32(&x409, &x410, x408, x369, x393); + var x411: u32 = undefined; + var x412: u1 = undefined; + addcarryxU32(&x411, &x412, x410, ((cast(u32, x370) + cast(u32, x328)) + (cast(u32, x354) + x330)), (cast(u32, x394) + x372)); + var x413: u32 = undefined; + var x414: u32 = undefined; + mulxU32(&x413, &x414, x5, 0x4); + var x415: u32 = undefined; + var x416: u32 = undefined; + mulxU32(&x415, &x416, x5, 0x2); + var x417: u32 = undefined; + var x418: u32 = undefined; + mulxU32(&x417, &x418, x5, 0x2); + var x419: u32 = undefined; + var x420: u32 = undefined; + mulxU32(&x419, &x420, x5, 0xffffffff); + var x421: u32 = undefined; + var x422: u32 = undefined; + mulxU32(&x421, &x422, x5, 0x2); + var x423: u32 = undefined; + var x424: u32 = undefined; + mulxU32(&x423, &x424, x5, 0x3); + var x425: u32 = undefined; + var x426: u1 = undefined; + addcarryxU32(&x425, &x426, 0x0, x424, x421); + var x427: u32 = undefined; + var x428: u1 = undefined; + addcarryxU32(&x427, &x428, x426, cast(u32, cast(u1, x422)), x419); + var x429: u32 = undefined; + var x430: u1 = undefined; + addcarryxU32(&x429, &x430, x428, x420, x417); + var x431: u32 = undefined; + var x432: u1 = undefined; + addcarryxU32(&x431, &x432, x430, cast(u32, cast(u1, x418)), x5); + var x433: u32 = undefined; + var x434: u1 = undefined; + addcarryxU32(&x433, &x434, x432, cast(u32, 0x0), x5); + var x435: u32 = undefined; + var x436: u1 = undefined; + addcarryxU32(&x435, &x436, x434, cast(u32, 0x0), x415); + var x437: u32 = undefined; + var x438: u1 = undefined; + addcarryxU32(&x437, &x438, x436, cast(u32, cast(u1, x416)), x413); + var x439: u32 = undefined; + var x440: u1 = undefined; + addcarryxU32(&x439, &x440, 0x0, x397, x423); + var x441: u32 = undefined; + var x442: u1 = undefined; + addcarryxU32(&x441, &x442, x440, x399, x425); + var x443: u32 = undefined; + var x444: u1 = undefined; + addcarryxU32(&x443, &x444, x442, x401, x427); + var x445: u32 = undefined; + var x446: u1 = undefined; + addcarryxU32(&x445, &x446, x444, x403, x429); + var x447: u32 = undefined; + var x448: u1 = undefined; + addcarryxU32(&x447, &x448, x446, x405, x431); + var x449: u32 = undefined; + var x450: u1 = undefined; + addcarryxU32(&x449, &x450, x448, x407, x433); + var x451: u32 = undefined; + var x452: u1 = undefined; + addcarryxU32(&x451, &x452, x450, x409, x435); + var x453: u32 = undefined; + var x454: u1 = undefined; + addcarryxU32(&x453, &x454, x452, x411, x437); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x439, 0xfffffffe); + var x457: u32 = undefined; + var x458: u32 = undefined; + mulxU32(&x457, &x458, x439, 0xffffffff); + var x459: u32 = undefined; + var x460: u32 = undefined; + mulxU32(&x459, &x460, x439, 0xffffffff); + var x461: u32 = undefined; + var x462: u32 = undefined; + mulxU32(&x461, &x462, x439, 0xffffffff); + var x463: u32 = undefined; + var x464: u32 = undefined; + mulxU32(&x463, &x464, x439, 0xffffffff); + var x465: u32 = undefined; + var x466: u32 = undefined; + mulxU32(&x465, &x466, x439, 0xffffffff); + var x467: u32 = undefined; + var x468: u32 = undefined; + mulxU32(&x467, &x468, x439, 0xffffffff); + var x469: u32 = undefined; + var x470: u1 = undefined; + addcarryxU32(&x469, &x470, 0x0, x468, x465); + var x471: u32 = undefined; + var x472: u1 = undefined; + addcarryxU32(&x471, &x472, 0x0, x464, x461); + var x473: u32 = undefined; + var x474: u1 = undefined; + addcarryxU32(&x473, &x474, x472, x462, x459); + var x475: u32 = undefined; + var x476: u1 = undefined; + addcarryxU32(&x475, &x476, x474, x460, x457); + var x477: u32 = undefined; + var x478: u1 = undefined; + addcarryxU32(&x477, &x478, x476, x458, x455); + var x479: u32 = undefined; + var x480: u1 = undefined; + addcarryxU32(&x479, &x480, 0x0, x439, x467); + var x481: u32 = undefined; + var x482: u1 = undefined; + addcarryxU32(&x481, &x482, x480, x441, x469); + var x483: u32 = undefined; + var x484: u1 = undefined; + addcarryxU32(&x483, &x484, x482, x443, (cast(u32, x470) + x466)); + var x485: u32 = undefined; + var x486: u1 = undefined; + addcarryxU32(&x485, &x486, x484, x445, x463); + var x487: u32 = undefined; + var x488: u1 = undefined; + addcarryxU32(&x487, &x488, x486, x447, x471); + var x489: u32 = undefined; + var x490: u1 = undefined; + addcarryxU32(&x489, &x490, x488, x449, x473); + var x491: u32 = undefined; + var x492: u1 = undefined; + addcarryxU32(&x491, &x492, x490, x451, x475); + var x493: u32 = undefined; + var x494: u1 = undefined; + addcarryxU32(&x493, &x494, x492, x453, x477); + var x495: u32 = undefined; + var x496: u1 = undefined; + addcarryxU32(&x495, &x496, x494, ((cast(u32, x454) + cast(u32, x412)) + (cast(u32, x438) + x414)), (cast(u32, x478) + x456)); + var x497: u32 = undefined; + var x498: u32 = undefined; + mulxU32(&x497, &x498, x6, 0x4); + var x499: u32 = undefined; + var x500: u32 = undefined; + mulxU32(&x499, &x500, x6, 0x2); + var x501: u32 = undefined; + var x502: u32 = undefined; + mulxU32(&x501, &x502, x6, 0x2); + var x503: u32 = undefined; + var x504: u32 = undefined; + mulxU32(&x503, &x504, x6, 0xffffffff); + var x505: u32 = undefined; + var x506: u32 = undefined; + mulxU32(&x505, &x506, x6, 0x2); + var x507: u32 = undefined; + var x508: u32 = undefined; + mulxU32(&x507, &x508, x6, 0x3); + var x509: u32 = undefined; + var x510: u1 = undefined; + addcarryxU32(&x509, &x510, 0x0, x508, x505); + var x511: u32 = undefined; + var x512: u1 = undefined; + addcarryxU32(&x511, &x512, x510, cast(u32, cast(u1, x506)), x503); + var x513: u32 = undefined; + var x514: u1 = undefined; + addcarryxU32(&x513, &x514, x512, x504, x501); + var x515: u32 = undefined; + var x516: u1 = undefined; + addcarryxU32(&x515, &x516, x514, cast(u32, cast(u1, x502)), x6); + var x517: u32 = undefined; + var x518: u1 = undefined; + addcarryxU32(&x517, &x518, x516, cast(u32, 0x0), x6); + var x519: u32 = undefined; + var x520: u1 = undefined; + addcarryxU32(&x519, &x520, x518, cast(u32, 0x0), x499); + var x521: u32 = undefined; + var x522: u1 = undefined; + addcarryxU32(&x521, &x522, x520, cast(u32, cast(u1, x500)), x497); + var x523: u32 = undefined; + var x524: u1 = undefined; + addcarryxU32(&x523, &x524, 0x0, x481, x507); + var x525: u32 = undefined; + var x526: u1 = undefined; + addcarryxU32(&x525, &x526, x524, x483, x509); + var x527: u32 = undefined; + var x528: u1 = undefined; + addcarryxU32(&x527, &x528, x526, x485, x511); + var x529: u32 = undefined; + var x530: u1 = undefined; + addcarryxU32(&x529, &x530, x528, x487, x513); + var x531: u32 = undefined; + var x532: u1 = undefined; + addcarryxU32(&x531, &x532, x530, x489, x515); + var x533: u32 = undefined; + var x534: u1 = undefined; + addcarryxU32(&x533, &x534, x532, x491, x517); + var x535: u32 = undefined; + var x536: u1 = undefined; + addcarryxU32(&x535, &x536, x534, x493, x519); + var x537: u32 = undefined; + var x538: u1 = undefined; + addcarryxU32(&x537, &x538, x536, x495, x521); + var x539: u32 = undefined; + var x540: u32 = undefined; + mulxU32(&x539, &x540, x523, 0xfffffffe); + var x541: u32 = undefined; + var x542: u32 = undefined; + mulxU32(&x541, &x542, x523, 0xffffffff); + var x543: u32 = undefined; + var x544: u32 = undefined; + mulxU32(&x543, &x544, x523, 0xffffffff); + var x545: u32 = undefined; + var x546: u32 = undefined; + mulxU32(&x545, &x546, x523, 0xffffffff); + var x547: u32 = undefined; + var x548: u32 = undefined; + mulxU32(&x547, &x548, x523, 0xffffffff); + var x549: u32 = undefined; + var x550: u32 = undefined; + mulxU32(&x549, &x550, x523, 0xffffffff); + var x551: u32 = undefined; + var x552: u32 = undefined; + mulxU32(&x551, &x552, x523, 0xffffffff); + var x553: u32 = undefined; + var x554: u1 = undefined; + addcarryxU32(&x553, &x554, 0x0, x552, x549); + var x555: u32 = undefined; + var x556: u1 = undefined; + addcarryxU32(&x555, &x556, 0x0, x548, x545); + var x557: u32 = undefined; + var x558: u1 = undefined; + addcarryxU32(&x557, &x558, x556, x546, x543); + var x559: u32 = undefined; + var x560: u1 = undefined; + addcarryxU32(&x559, &x560, x558, x544, x541); + var x561: u32 = undefined; + var x562: u1 = undefined; + addcarryxU32(&x561, &x562, x560, x542, x539); + var x563: u32 = undefined; + var x564: u1 = undefined; + addcarryxU32(&x563, &x564, 0x0, x523, x551); + var x565: u32 = undefined; + var x566: u1 = undefined; + addcarryxU32(&x565, &x566, x564, x525, x553); + var x567: u32 = undefined; + var x568: u1 = undefined; + addcarryxU32(&x567, &x568, x566, x527, (cast(u32, x554) + x550)); + var x569: u32 = undefined; + var x570: u1 = undefined; + addcarryxU32(&x569, &x570, x568, x529, x547); + var x571: u32 = undefined; + var x572: u1 = undefined; + addcarryxU32(&x571, &x572, x570, x531, x555); + var x573: u32 = undefined; + var x574: u1 = undefined; + addcarryxU32(&x573, &x574, x572, x533, x557); + var x575: u32 = undefined; + var x576: u1 = undefined; + addcarryxU32(&x575, &x576, x574, x535, x559); + var x577: u32 = undefined; + var x578: u1 = undefined; + addcarryxU32(&x577, &x578, x576, x537, x561); + var x579: u32 = undefined; + var x580: u1 = undefined; + addcarryxU32(&x579, &x580, x578, ((cast(u32, x538) + cast(u32, x496)) + (cast(u32, x522) + x498)), (cast(u32, x562) + x540)); + var x581: u32 = undefined; + var x582: u32 = undefined; + mulxU32(&x581, &x582, x7, 0x4); + var x583: u32 = undefined; + var x584: u32 = undefined; + mulxU32(&x583, &x584, x7, 0x2); + var x585: u32 = undefined; + var x586: u32 = undefined; + mulxU32(&x585, &x586, x7, 0x2); + var x587: u32 = undefined; + var x588: u32 = undefined; + mulxU32(&x587, &x588, x7, 0xffffffff); + var x589: u32 = undefined; + var x590: u32 = undefined; + mulxU32(&x589, &x590, x7, 0x2); + var x591: u32 = undefined; + var x592: u32 = undefined; + mulxU32(&x591, &x592, x7, 0x3); + var x593: u32 = undefined; + var x594: u1 = undefined; + addcarryxU32(&x593, &x594, 0x0, x592, x589); + var x595: u32 = undefined; + var x596: u1 = undefined; + addcarryxU32(&x595, &x596, x594, cast(u32, cast(u1, x590)), x587); + var x597: u32 = undefined; + var x598: u1 = undefined; + addcarryxU32(&x597, &x598, x596, x588, x585); + var x599: u32 = undefined; + var x600: u1 = undefined; + addcarryxU32(&x599, &x600, x598, cast(u32, cast(u1, x586)), x7); + var x601: u32 = undefined; + var x602: u1 = undefined; + addcarryxU32(&x601, &x602, x600, cast(u32, 0x0), x7); + var x603: u32 = undefined; + var x604: u1 = undefined; + addcarryxU32(&x603, &x604, x602, cast(u32, 0x0), x583); + var x605: u32 = undefined; + var x606: u1 = undefined; + addcarryxU32(&x605, &x606, x604, cast(u32, cast(u1, x584)), x581); + var x607: u32 = undefined; + var x608: u1 = undefined; + addcarryxU32(&x607, &x608, 0x0, x565, x591); + var x609: u32 = undefined; + var x610: u1 = undefined; + addcarryxU32(&x609, &x610, x608, x567, x593); + var x611: u32 = undefined; + var x612: u1 = undefined; + addcarryxU32(&x611, &x612, x610, x569, x595); + var x613: u32 = undefined; + var x614: u1 = undefined; + addcarryxU32(&x613, &x614, x612, x571, x597); + var x615: u32 = undefined; + var x616: u1 = undefined; + addcarryxU32(&x615, &x616, x614, x573, x599); + var x617: u32 = undefined; + var x618: u1 = undefined; + addcarryxU32(&x617, &x618, x616, x575, x601); + var x619: u32 = undefined; + var x620: u1 = undefined; + addcarryxU32(&x619, &x620, x618, x577, x603); + var x621: u32 = undefined; + var x622: u1 = undefined; + addcarryxU32(&x621, &x622, x620, x579, x605); + var x623: u32 = undefined; + var x624: u32 = undefined; + mulxU32(&x623, &x624, x607, 0xfffffffe); + var x625: u32 = undefined; + var x626: u32 = undefined; + mulxU32(&x625, &x626, x607, 0xffffffff); + var x627: u32 = undefined; + var x628: u32 = undefined; + mulxU32(&x627, &x628, x607, 0xffffffff); + var x629: u32 = undefined; + var x630: u32 = undefined; + mulxU32(&x629, &x630, x607, 0xffffffff); + var x631: u32 = undefined; + var x632: u32 = undefined; + mulxU32(&x631, &x632, x607, 0xffffffff); + var x633: u32 = undefined; + var x634: u32 = undefined; + mulxU32(&x633, &x634, x607, 0xffffffff); + var x635: u32 = undefined; + var x636: u32 = undefined; + mulxU32(&x635, &x636, x607, 0xffffffff); + var x637: u32 = undefined; + var x638: u1 = undefined; + addcarryxU32(&x637, &x638, 0x0, x636, x633); + var x639: u32 = undefined; + var x640: u1 = undefined; + addcarryxU32(&x639, &x640, 0x0, x632, x629); + var x641: u32 = undefined; + var x642: u1 = undefined; + addcarryxU32(&x641, &x642, x640, x630, x627); + var x643: u32 = undefined; + var x644: u1 = undefined; + addcarryxU32(&x643, &x644, x642, x628, x625); + var x645: u32 = undefined; + var x646: u1 = undefined; + addcarryxU32(&x645, &x646, x644, x626, x623); + var x647: u32 = undefined; + var x648: u1 = undefined; + addcarryxU32(&x647, &x648, 0x0, x607, x635); + var x649: u32 = undefined; + var x650: u1 = undefined; + addcarryxU32(&x649, &x650, x648, x609, x637); + var x651: u32 = undefined; + var x652: u1 = undefined; + addcarryxU32(&x651, &x652, x650, x611, (cast(u32, x638) + x634)); + var x653: u32 = undefined; + var x654: u1 = undefined; + addcarryxU32(&x653, &x654, x652, x613, x631); + var x655: u32 = undefined; + var x656: u1 = undefined; + addcarryxU32(&x655, &x656, x654, x615, x639); + var x657: u32 = undefined; + var x658: u1 = undefined; + addcarryxU32(&x657, &x658, x656, x617, x641); + var x659: u32 = undefined; + var x660: u1 = undefined; + addcarryxU32(&x659, &x660, x658, x619, x643); + var x661: u32 = undefined; + var x662: u1 = undefined; + addcarryxU32(&x661, &x662, x660, x621, x645); + var x663: u32 = undefined; + var x664: u1 = undefined; + addcarryxU32(&x663, &x664, x662, ((cast(u32, x622) + cast(u32, x580)) + (cast(u32, x606) + x582)), (cast(u32, x646) + x624)); + var x665: u32 = undefined; + var x666: u1 = undefined; + subborrowxU32(&x665, &x666, 0x0, x649, 0xffffffff); + var x667: u32 = undefined; + var x668: u1 = undefined; + subborrowxU32(&x667, &x668, x666, x651, 0xffffffff); + var x669: u32 = undefined; + var x670: u1 = undefined; + subborrowxU32(&x669, &x670, x668, x653, cast(u32, 0x0)); + var x671: u32 = undefined; + var x672: u1 = undefined; + subborrowxU32(&x671, &x672, x670, x655, 0xffffffff); + var x673: u32 = undefined; + var x674: u1 = undefined; + subborrowxU32(&x673, &x674, x672, x657, 0xffffffff); + var x675: u32 = undefined; + var x676: u1 = undefined; + subborrowxU32(&x675, &x676, x674, x659, 0xffffffff); + var x677: u32 = undefined; + var x678: u1 = undefined; + subborrowxU32(&x677, &x678, x676, x661, 0xffffffff); + var x679: u32 = undefined; + var x680: u1 = undefined; + subborrowxU32(&x679, &x680, x678, x663, 0xfffffffe); + var x681: u32 = undefined; + var x682: u1 = undefined; + subborrowxU32(&x681, &x682, x680, cast(u32, x664), cast(u32, 0x0)); + var x683: u32 = undefined; + cmovznzU32(&x683, x682, x665, x649); + var x684: u32 = undefined; + cmovznzU32(&x684, x682, x667, x651); + var x685: u32 = undefined; + cmovznzU32(&x685, x682, x669, x653); + var x686: u32 = undefined; + cmovznzU32(&x686, x682, x671, x655); + var x687: u32 = undefined; + cmovznzU32(&x687, x682, x673, x657); + var x688: u32 = undefined; + cmovznzU32(&x688, x682, x675, x659); + var x689: u32 = undefined; + cmovznzU32(&x689, x682, x677, x661); + var x690: u32 = undefined; + cmovznzU32(&x690, x682, x679, x663); + out1[0] = x683; + out1[1] = x684; + out1[2] = x685; + out1[3] = x686; + out1[4] = x687; + out1[5] = x688; + out1[6] = x689; + out1[7] = x690; +} + +/// 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] = cast(u32, 0x1); + out1[1] = cast(u32, 0x0); + out1[2] = 0xffffffff; + out1[3] = cast(u32, 0x0); + out1[4] = cast(u32, 0x0); + out1[5] = cast(u32, 0x0); + out1[6] = cast(u32, 0x0); + out1[7] = cast(u32, 0x1); +} + +/// 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] = 0xffffffff; + out1[1] = 0xffffffff; + out1[2] = cast(u32, 0x0); + out1[3] = 0xffffffff; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffffe; + 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, 0xffffffff); + var x69: u32 = undefined; + var x70: u1 = undefined; + subborrowxU32(&x69, &x70, x68, x53, 0xffffffff); + var x71: u32 = undefined; + var x72: u1 = undefined; + subborrowxU32(&x71, &x72, x70, x55, cast(u32, 0x0)); + var x73: u32 = undefined; + var x74: u1 = undefined; + subborrowxU32(&x73, &x74, x72, x57, 0xffffffff); + 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, 0xffffffff); + var x81: u32 = undefined; + var x82: u1 = undefined; + subborrowxU32(&x81, &x82, x80, x65, 0xfffffffe); + 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); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x95, x109); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x97, cast(u32, 0x0)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x99, x109); + 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, x109); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x107, (x109 & 0xfffffffe)); + 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, 0xffffffff); + var x188: u32 = undefined; + var x189: u1 = undefined; + subborrowxU32(&x188, &x189, x187, x172, 0xffffffff); + var x190: u32 = undefined; + var x191: u1 = undefined; + subborrowxU32(&x190, &x191, x189, x174, cast(u32, 0x0)); + var x192: u32 = undefined; + var x193: u1 = undefined; + subborrowxU32(&x192, &x193, x191, x176, 0xffffffff); + 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, 0xffffffff); + var x200: u32 = undefined; + var x201: u1 = undefined; + subborrowxU32(&x200, &x201, x199, x184, 0xfffffffe); + 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] = 0x8ffffffe; + out1[1] = 0x50000002; + out1[2] = 0x9ffffffe; + out1[3] = 0xe8000000; + out1[4] = 0x8ffffffe; + out1[5] = 0xd0000001; + out1[6] = 0x1ffffffd; + out1[7] = 0x28000001; +} diff --git a/fiat-zig/src/sm2_64.zig b/fiat-zig/src/sm2_64.zig new file mode 100644 index 00000000000..d5662ba937c --- /dev/null +++ b/fiat-zig/src/sm2_64.zig @@ -0,0 +1,1975 @@ +// 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 sm2 '' 64 '2^256 - 2^224 - 2^96 + 2^64 - 1' 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): sm2 +// 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 = 0xfffffffeffffffffffffffffffffffffffffffff00000000ffffffffffffffff (from "2^256 - 2^224 - 2^96 + 2^64 - 1") +// +// 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 { + @setEvalBranchQuota(10000); + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + const T = std.meta.Int(source.signedness, dest.bits); + return @bitCast(@as(T, @truncate(target))); + } + } + return 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, 0xfffffffeffffffff); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x11, 0xffffffffffffffff); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x11, 0xffffffff00000000); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x11, 0xffffffffffffffff); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, 0x0, x27, x24); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, x29, x25, x22); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x23, x20); + const x34 = (cast(u64, x33) + x21); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, 0x0, x11, x26); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x13, x28); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x15, x30); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x17, x32); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x19, x34); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, (arg2[3])); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg2[2])); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, (arg2[1])); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, (arg2[0])); + 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); + const x59 = (cast(u64, x58) + x46); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, 0x0, 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, 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, cast(u64, x44), x59); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x60, 0xfffffffeffffffff); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x60, 0xffffffffffffffff); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x60, 0xffffffff00000000); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x60, 0xffffffffffffffff); + var x78: u64 = undefined; + var x79: u1 = undefined; + addcarryxU64(&x78, &x79, 0x0, x77, x74); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, x79, x75, x72); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x73, x70); + const x84 = (cast(u64, x83) + x71); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, 0x0, x60, x76); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x62, x78); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x64, x80); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x66, x82); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x68, x84); + const x95 = (cast(u64, x94) + cast(u64, x69)); + var x96: u64 = undefined; + var x97: u64 = undefined; + mulxU64(&x96, &x97, x2, (arg2[3])); + var x98: u64 = undefined; + var x99: u64 = undefined; + mulxU64(&x98, &x99, x2, (arg2[2])); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x2, (arg2[1])); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x2, (arg2[0])); + var x104: u64 = undefined; + var x105: u1 = undefined; + addcarryxU64(&x104, &x105, 0x0, x103, x100); + var x106: u64 = undefined; + var x107: u1 = undefined; + addcarryxU64(&x106, &x107, x105, x101, x98); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, x107, x99, x96); + const x110 = (cast(u64, x109) + x97); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, 0x0, x87, x102); + var x113: u64 = undefined; + var x114: u1 = undefined; + addcarryxU64(&x113, &x114, x112, x89, x104); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, x114, 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: u64 = undefined; + mulxU64(&x121, &x122, x111, 0xfffffffeffffffff); + var x123: u64 = undefined; + var x124: u64 = undefined; + mulxU64(&x123, &x124, x111, 0xffffffffffffffff); + var x125: u64 = undefined; + var x126: u64 = undefined; + mulxU64(&x125, &x126, x111, 0xffffffff00000000); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x111, 0xffffffffffffffff); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, 0x0, x128, x125); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, x130, x126, x123); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x124, x121); + const x135 = (cast(u64, x134) + x122); + var x136: u64 = undefined; + var x137: u1 = undefined; + addcarryxU64(&x136, &x137, 0x0, x111, x127); + var x138: u64 = undefined; + var x139: u1 = undefined; + addcarryxU64(&x138, &x139, x137, x113, x129); + var x140: u64 = undefined; + var x141: u1 = undefined; + addcarryxU64(&x140, &x141, x139, x115, x131); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, x141, x117, x133); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x119, x135); + const x146 = (cast(u64, x145) + cast(u64, x120)); + var x147: u64 = undefined; + var x148: u64 = undefined; + mulxU64(&x147, &x148, x3, (arg2[3])); + var x149: u64 = undefined; + var x150: u64 = undefined; + mulxU64(&x149, &x150, x3, (arg2[2])); + var x151: u64 = undefined; + var x152: u64 = undefined; + mulxU64(&x151, &x152, x3, (arg2[1])); + var x153: u64 = undefined; + var x154: u64 = undefined; + mulxU64(&x153, &x154, x3, (arg2[0])); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, 0x0, x154, x151); + var x157: u64 = undefined; + var x158: u1 = undefined; + addcarryxU64(&x157, &x158, x156, x152, x149); + var x159: u64 = undefined; + var x160: u1 = undefined; + addcarryxU64(&x159, &x160, x158, x150, x147); + const x161 = (cast(u64, x160) + x148); + var x162: u64 = undefined; + var x163: u1 = undefined; + addcarryxU64(&x162, &x163, 0x0, x138, x153); + var x164: u64 = undefined; + var x165: u1 = undefined; + addcarryxU64(&x164, &x165, x163, x140, x155); + var x166: u64 = undefined; + var x167: u1 = undefined; + addcarryxU64(&x166, &x167, x165, x142, x157); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, x167, x144, x159); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x146, x161); + var x172: u64 = undefined; + var x173: u64 = undefined; + mulxU64(&x172, &x173, x162, 0xfffffffeffffffff); + var x174: u64 = undefined; + var x175: u64 = undefined; + mulxU64(&x174, &x175, x162, 0xffffffffffffffff); + var x176: u64 = undefined; + var x177: u64 = undefined; + mulxU64(&x176, &x177, x162, 0xffffffff00000000); + var x178: u64 = undefined; + var x179: u64 = undefined; + mulxU64(&x178, &x179, x162, 0xffffffffffffffff); + var x180: u64 = undefined; + var x181: u1 = undefined; + addcarryxU64(&x180, &x181, 0x0, x179, x176); + var x182: u64 = undefined; + var x183: u1 = undefined; + addcarryxU64(&x182, &x183, x181, x177, x174); + var x184: u64 = undefined; + var x185: u1 = undefined; + addcarryxU64(&x184, &x185, x183, x175, x172); + const x186 = (cast(u64, x185) + x173); + var x187: u64 = undefined; + var x188: u1 = undefined; + addcarryxU64(&x187, &x188, 0x0, x162, x178); + var x189: u64 = undefined; + var x190: u1 = undefined; + addcarryxU64(&x189, &x190, x188, x164, x180); + var x191: u64 = undefined; + var x192: u1 = undefined; + addcarryxU64(&x191, &x192, x190, x166, x182); + var x193: u64 = undefined; + var x194: u1 = undefined; + addcarryxU64(&x193, &x194, x192, x168, x184); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, x194, x170, x186); + const x197 = (cast(u64, x196) + cast(u64, x171)); + var x198: u64 = undefined; + var x199: u1 = undefined; + subborrowxU64(&x198, &x199, 0x0, x189, 0xffffffffffffffff); + var x200: u64 = undefined; + var x201: u1 = undefined; + subborrowxU64(&x200, &x201, x199, x191, 0xffffffff00000000); + var x202: u64 = undefined; + var x203: u1 = undefined; + subborrowxU64(&x202, &x203, x201, x193, 0xffffffffffffffff); + var x204: u64 = undefined; + var x205: u1 = undefined; + subborrowxU64(&x204, &x205, x203, x195, 0xfffffffeffffffff); + var x206: u64 = undefined; + var x207: u1 = undefined; + subborrowxU64(&x206, &x207, x205, x197, cast(u64, 0x0)); + var x208: u64 = undefined; + cmovznzU64(&x208, x207, x198, x189); + var x209: u64 = undefined; + cmovznzU64(&x209, x207, x200, x191); + var x210: u64 = undefined; + cmovznzU64(&x210, x207, x202, x193); + var x211: u64 = undefined; + cmovznzU64(&x211, x207, x204, x195); + out1[0] = x208; + out1[1] = x209; + out1[2] = x210; + out1[3] = x211; +} + +/// 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, 0xfffffffeffffffff); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x11, 0xffffffffffffffff); + var x24: u64 = undefined; + var x25: u64 = undefined; + mulxU64(&x24, &x25, x11, 0xffffffff00000000); + var x26: u64 = undefined; + var x27: u64 = undefined; + mulxU64(&x26, &x27, x11, 0xffffffffffffffff); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, 0x0, x27, x24); + var x30: u64 = undefined; + var x31: u1 = undefined; + addcarryxU64(&x30, &x31, x29, x25, x22); + var x32: u64 = undefined; + var x33: u1 = undefined; + addcarryxU64(&x32, &x33, x31, x23, x20); + const x34 = (cast(u64, x33) + x21); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, 0x0, x11, x26); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x13, x28); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x15, x30); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, x17, x32); + var x43: u64 = undefined; + var x44: u1 = undefined; + addcarryxU64(&x43, &x44, x42, x19, x34); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, (arg1[3])); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, (arg1[2])); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, (arg1[1])); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, (arg1[0])); + 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); + const x59 = (cast(u64, x58) + x46); + var x60: u64 = undefined; + var x61: u1 = undefined; + addcarryxU64(&x60, &x61, 0x0, 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, 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, cast(u64, x44), x59); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x60, 0xfffffffeffffffff); + var x72: u64 = undefined; + var x73: u64 = undefined; + mulxU64(&x72, &x73, x60, 0xffffffffffffffff); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x60, 0xffffffff00000000); + var x76: u64 = undefined; + var x77: u64 = undefined; + mulxU64(&x76, &x77, x60, 0xffffffffffffffff); + var x78: u64 = undefined; + var x79: u1 = undefined; + addcarryxU64(&x78, &x79, 0x0, x77, x74); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, x79, x75, x72); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x73, x70); + const x84 = (cast(u64, x83) + x71); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, 0x0, x60, x76); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, x62, x78); + var x89: u64 = undefined; + var x90: u1 = undefined; + addcarryxU64(&x89, &x90, x88, x64, x80); + var x91: u64 = undefined; + var x92: u1 = undefined; + addcarryxU64(&x91, &x92, x90, x66, x82); + var x93: u64 = undefined; + var x94: u1 = undefined; + addcarryxU64(&x93, &x94, x92, x68, x84); + const x95 = (cast(u64, x94) + cast(u64, x69)); + var x96: u64 = undefined; + var x97: u64 = undefined; + mulxU64(&x96, &x97, x2, (arg1[3])); + var x98: u64 = undefined; + var x99: u64 = undefined; + mulxU64(&x98, &x99, x2, (arg1[2])); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x2, (arg1[1])); + var x102: u64 = undefined; + var x103: u64 = undefined; + mulxU64(&x102, &x103, x2, (arg1[0])); + var x104: u64 = undefined; + var x105: u1 = undefined; + addcarryxU64(&x104, &x105, 0x0, x103, x100); + var x106: u64 = undefined; + var x107: u1 = undefined; + addcarryxU64(&x106, &x107, x105, x101, x98); + var x108: u64 = undefined; + var x109: u1 = undefined; + addcarryxU64(&x108, &x109, x107, x99, x96); + const x110 = (cast(u64, x109) + x97); + var x111: u64 = undefined; + var x112: u1 = undefined; + addcarryxU64(&x111, &x112, 0x0, x87, x102); + var x113: u64 = undefined; + var x114: u1 = undefined; + addcarryxU64(&x113, &x114, x112, x89, x104); + var x115: u64 = undefined; + var x116: u1 = undefined; + addcarryxU64(&x115, &x116, x114, 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: u64 = undefined; + mulxU64(&x121, &x122, x111, 0xfffffffeffffffff); + var x123: u64 = undefined; + var x124: u64 = undefined; + mulxU64(&x123, &x124, x111, 0xffffffffffffffff); + var x125: u64 = undefined; + var x126: u64 = undefined; + mulxU64(&x125, &x126, x111, 0xffffffff00000000); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x111, 0xffffffffffffffff); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, 0x0, x128, x125); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, x130, x126, x123); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, x124, x121); + const x135 = (cast(u64, x134) + x122); + var x136: u64 = undefined; + var x137: u1 = undefined; + addcarryxU64(&x136, &x137, 0x0, x111, x127); + var x138: u64 = undefined; + var x139: u1 = undefined; + addcarryxU64(&x138, &x139, x137, x113, x129); + var x140: u64 = undefined; + var x141: u1 = undefined; + addcarryxU64(&x140, &x141, x139, x115, x131); + var x142: u64 = undefined; + var x143: u1 = undefined; + addcarryxU64(&x142, &x143, x141, x117, x133); + var x144: u64 = undefined; + var x145: u1 = undefined; + addcarryxU64(&x144, &x145, x143, x119, x135); + const x146 = (cast(u64, x145) + cast(u64, x120)); + var x147: u64 = undefined; + var x148: u64 = undefined; + mulxU64(&x147, &x148, x3, (arg1[3])); + var x149: u64 = undefined; + var x150: u64 = undefined; + mulxU64(&x149, &x150, x3, (arg1[2])); + var x151: u64 = undefined; + var x152: u64 = undefined; + mulxU64(&x151, &x152, x3, (arg1[1])); + var x153: u64 = undefined; + var x154: u64 = undefined; + mulxU64(&x153, &x154, x3, (arg1[0])); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, 0x0, x154, x151); + var x157: u64 = undefined; + var x158: u1 = undefined; + addcarryxU64(&x157, &x158, x156, x152, x149); + var x159: u64 = undefined; + var x160: u1 = undefined; + addcarryxU64(&x159, &x160, x158, x150, x147); + const x161 = (cast(u64, x160) + x148); + var x162: u64 = undefined; + var x163: u1 = undefined; + addcarryxU64(&x162, &x163, 0x0, x138, x153); + var x164: u64 = undefined; + var x165: u1 = undefined; + addcarryxU64(&x164, &x165, x163, x140, x155); + var x166: u64 = undefined; + var x167: u1 = undefined; + addcarryxU64(&x166, &x167, x165, x142, x157); + var x168: u64 = undefined; + var x169: u1 = undefined; + addcarryxU64(&x168, &x169, x167, x144, x159); + var x170: u64 = undefined; + var x171: u1 = undefined; + addcarryxU64(&x170, &x171, x169, x146, x161); + var x172: u64 = undefined; + var x173: u64 = undefined; + mulxU64(&x172, &x173, x162, 0xfffffffeffffffff); + var x174: u64 = undefined; + var x175: u64 = undefined; + mulxU64(&x174, &x175, x162, 0xffffffffffffffff); + var x176: u64 = undefined; + var x177: u64 = undefined; + mulxU64(&x176, &x177, x162, 0xffffffff00000000); + var x178: u64 = undefined; + var x179: u64 = undefined; + mulxU64(&x178, &x179, x162, 0xffffffffffffffff); + var x180: u64 = undefined; + var x181: u1 = undefined; + addcarryxU64(&x180, &x181, 0x0, x179, x176); + var x182: u64 = undefined; + var x183: u1 = undefined; + addcarryxU64(&x182, &x183, x181, x177, x174); + var x184: u64 = undefined; + var x185: u1 = undefined; + addcarryxU64(&x184, &x185, x183, x175, x172); + const x186 = (cast(u64, x185) + x173); + var x187: u64 = undefined; + var x188: u1 = undefined; + addcarryxU64(&x187, &x188, 0x0, x162, x178); + var x189: u64 = undefined; + var x190: u1 = undefined; + addcarryxU64(&x189, &x190, x188, x164, x180); + var x191: u64 = undefined; + var x192: u1 = undefined; + addcarryxU64(&x191, &x192, x190, x166, x182); + var x193: u64 = undefined; + var x194: u1 = undefined; + addcarryxU64(&x193, &x194, x192, x168, x184); + var x195: u64 = undefined; + var x196: u1 = undefined; + addcarryxU64(&x195, &x196, x194, x170, x186); + const x197 = (cast(u64, x196) + cast(u64, x171)); + var x198: u64 = undefined; + var x199: u1 = undefined; + subborrowxU64(&x198, &x199, 0x0, x189, 0xffffffffffffffff); + var x200: u64 = undefined; + var x201: u1 = undefined; + subborrowxU64(&x200, &x201, x199, x191, 0xffffffff00000000); + var x202: u64 = undefined; + var x203: u1 = undefined; + subborrowxU64(&x202, &x203, x201, x193, 0xffffffffffffffff); + var x204: u64 = undefined; + var x205: u1 = undefined; + subborrowxU64(&x204, &x205, x203, x195, 0xfffffffeffffffff); + var x206: u64 = undefined; + var x207: u1 = undefined; + subborrowxU64(&x206, &x207, x205, x197, cast(u64, 0x0)); + var x208: u64 = undefined; + cmovznzU64(&x208, x207, x198, x189); + var x209: u64 = undefined; + cmovznzU64(&x209, x207, x200, x191); + var x210: u64 = undefined; + cmovznzU64(&x210, x207, x202, x193); + var x211: u64 = undefined; + cmovznzU64(&x211, x207, x204, x195); + out1[0] = x208; + out1[1] = x209; + out1[2] = x210; + out1[3] = x211; +} + +/// 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, 0xffffffffffffffff); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, x3, 0xffffffff00000000); + 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, 0xfffffffeffffffff); + 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); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0xffffffff00000000)); + 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 & 0xfffffffeffffffff)); + 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); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0xffffffff00000000)); + 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 & 0xfffffffeffffffff)); + 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, 0xfffffffeffffffff); + var x4: u64 = undefined; + var x5: u64 = undefined; + mulxU64(&x4, &x5, x1, 0xffffffffffffffff); + var x6: u64 = undefined; + var x7: u64 = undefined; + mulxU64(&x6, &x7, x1, 0xffffffff00000000); + var x8: u64 = undefined; + var x9: u64 = undefined; + mulxU64(&x8, &x9, x1, 0xffffffffffffffff); + 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, x11, x7, x4); + var x14: u64 = undefined; + var x15: u1 = undefined; + addcarryxU64(&x14, &x15, x13, x5, x2); + var x16: u64 = undefined; + var x17: u1 = undefined; + addcarryxU64(&x16, &x17, 0x0, x1, x8); + var x18: u64 = undefined; + var x19: u1 = undefined; + addcarryxU64(&x18, &x19, x17, cast(u64, 0x0), 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, 0x0, x18, (arg1[1])); + var x26: u64 = undefined; + var x27: u1 = undefined; + addcarryxU64(&x26, &x27, x25, x20, cast(u64, 0x0)); + var x28: u64 = undefined; + var x29: u1 = undefined; + addcarryxU64(&x28, &x29, x27, x22, cast(u64, 0x0)); + var x30: u64 = undefined; + var x31: u64 = undefined; + mulxU64(&x30, &x31, x24, 0xfffffffeffffffff); + var x32: u64 = undefined; + var x33: u64 = undefined; + mulxU64(&x32, &x33, x24, 0xffffffffffffffff); + var x34: u64 = undefined; + var x35: u64 = undefined; + mulxU64(&x34, &x35, x24, 0xffffffff00000000); + var x36: u64 = undefined; + var x37: u64 = undefined; + mulxU64(&x36, &x37, x24, 0xffffffffffffffff); + var x38: u64 = undefined; + var x39: u1 = undefined; + addcarryxU64(&x38, &x39, 0x0, x37, x34); + var x40: u64 = undefined; + var x41: u1 = undefined; + addcarryxU64(&x40, &x41, x39, x35, x32); + var x42: u64 = undefined; + var x43: u1 = undefined; + addcarryxU64(&x42, &x43, x41, x33, x30); + var x44: u64 = undefined; + var x45: u1 = undefined; + addcarryxU64(&x44, &x45, 0x0, x24, x36); + var x46: u64 = undefined; + var x47: u1 = undefined; + addcarryxU64(&x46, &x47, x45, x26, x38); + var x48: u64 = undefined; + var x49: u1 = undefined; + addcarryxU64(&x48, &x49, x47, x28, x40); + var x50: u64 = undefined; + var x51: u1 = undefined; + addcarryxU64(&x50, &x51, x49, (cast(u64, x29) + (cast(u64, x23) + (cast(u64, x15) + x3))), x42); + var x52: u64 = undefined; + var x53: u1 = undefined; + addcarryxU64(&x52, &x53, 0x0, x46, (arg1[2])); + var x54: u64 = undefined; + var x55: u1 = undefined; + addcarryxU64(&x54, &x55, x53, x48, cast(u64, 0x0)); + var x56: u64 = undefined; + var x57: u1 = undefined; + addcarryxU64(&x56, &x57, x55, x50, cast(u64, 0x0)); + var x58: u64 = undefined; + var x59: u64 = undefined; + mulxU64(&x58, &x59, x52, 0xfffffffeffffffff); + var x60: u64 = undefined; + var x61: u64 = undefined; + mulxU64(&x60, &x61, x52, 0xffffffffffffffff); + var x62: u64 = undefined; + var x63: u64 = undefined; + mulxU64(&x62, &x63, x52, 0xffffffff00000000); + var x64: u64 = undefined; + var x65: u64 = undefined; + mulxU64(&x64, &x65, x52, 0xffffffffffffffff); + 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, 0x0, x52, x64); + var x74: u64 = undefined; + var x75: u1 = undefined; + addcarryxU64(&x74, &x75, x73, x54, x66); + var x76: u64 = undefined; + var x77: u1 = undefined; + addcarryxU64(&x76, &x77, x75, x56, x68); + var x78: u64 = undefined; + var x79: u1 = undefined; + addcarryxU64(&x78, &x79, x77, (cast(u64, x57) + (cast(u64, x51) + (cast(u64, x43) + x31))), x70); + var x80: u64 = undefined; + var x81: u1 = undefined; + addcarryxU64(&x80, &x81, 0x0, x74, (arg1[3])); + var x82: u64 = undefined; + var x83: u1 = undefined; + addcarryxU64(&x82, &x83, x81, x76, cast(u64, 0x0)); + var x84: u64 = undefined; + var x85: u1 = undefined; + addcarryxU64(&x84, &x85, x83, x78, cast(u64, 0x0)); + var x86: u64 = undefined; + var x87: u64 = undefined; + mulxU64(&x86, &x87, x80, 0xfffffffeffffffff); + var x88: u64 = undefined; + var x89: u64 = undefined; + mulxU64(&x88, &x89, x80, 0xffffffffffffffff); + var x90: u64 = undefined; + var x91: u64 = undefined; + mulxU64(&x90, &x91, x80, 0xffffffff00000000); + var x92: u64 = undefined; + var x93: u64 = undefined; + mulxU64(&x92, &x93, x80, 0xffffffffffffffff); + var x94: u64 = undefined; + var x95: u1 = undefined; + addcarryxU64(&x94, &x95, 0x0, x93, x90); + var x96: u64 = undefined; + var x97: u1 = undefined; + addcarryxU64(&x96, &x97, x95, x91, x88); + var x98: u64 = undefined; + var x99: u1 = undefined; + addcarryxU64(&x98, &x99, x97, x89, x86); + var x100: u64 = undefined; + var x101: u1 = undefined; + addcarryxU64(&x100, &x101, 0x0, x80, x92); + var x102: u64 = undefined; + var x103: u1 = undefined; + addcarryxU64(&x102, &x103, x101, x82, x94); + var x104: u64 = undefined; + var x105: u1 = undefined; + addcarryxU64(&x104, &x105, x103, x84, x96); + var x106: u64 = undefined; + var x107: u1 = undefined; + addcarryxU64(&x106, &x107, x105, (cast(u64, x85) + (cast(u64, x79) + (cast(u64, x71) + x59))), x98); + const x108 = (cast(u64, x107) + (cast(u64, x99) + x87)); + var x109: u64 = undefined; + var x110: u1 = undefined; + subborrowxU64(&x109, &x110, 0x0, x102, 0xffffffffffffffff); + var x111: u64 = undefined; + var x112: u1 = undefined; + subborrowxU64(&x111, &x112, x110, x104, 0xffffffff00000000); + var x113: u64 = undefined; + var x114: u1 = undefined; + subborrowxU64(&x113, &x114, x112, x106, 0xffffffffffffffff); + var x115: u64 = undefined; + var x116: u1 = undefined; + subborrowxU64(&x115, &x116, x114, x108, 0xfffffffeffffffff); + var x117: u64 = undefined; + var x118: u1 = undefined; + subborrowxU64(&x117, &x118, x116, cast(u64, 0x0), cast(u64, 0x0)); + var x119: u64 = undefined; + cmovznzU64(&x119, x118, x109, x102); + var x120: u64 = undefined; + cmovznzU64(&x120, x118, x111, x104); + var x121: u64 = undefined; + cmovznzU64(&x121, x118, x113, x106); + var x122: u64 = undefined; + cmovznzU64(&x122, x118, x115, x108); + out1[0] = x119; + out1[1] = x120; + out1[2] = x121; + out1[3] = x122; +} + +/// 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, 0x400000002); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, 0x100000001); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, 0x2ffffffff); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, 0x200000003); + 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, 0xfffffffeffffffff); + var x21: u64 = undefined; + var x22: u64 = undefined; + mulxU64(&x21, &x22, x11, 0xffffffffffffffff); + var x23: u64 = undefined; + var x24: u64 = undefined; + mulxU64(&x23, &x24, x11, 0xffffffff00000000); + var x25: u64 = undefined; + var x26: u64 = undefined; + mulxU64(&x25, &x26, x11, 0xffffffffffffffff); + 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, x28, x24, x21); + var x31: u64 = undefined; + var x32: u1 = undefined; + addcarryxU64(&x31, &x32, x30, x22, x19); + var x33: u64 = undefined; + var x34: u1 = undefined; + addcarryxU64(&x33, &x34, 0x0, x11, x25); + var x35: u64 = undefined; + var x36: u1 = undefined; + addcarryxU64(&x35, &x36, x34, x13, x27); + var x37: u64 = undefined; + var x38: u1 = undefined; + addcarryxU64(&x37, &x38, x36, x15, x29); + var x39: u64 = undefined; + var x40: u1 = undefined; + addcarryxU64(&x39, &x40, x38, x17, x31); + var x41: u64 = undefined; + var x42: u1 = undefined; + addcarryxU64(&x41, &x42, x40, (cast(u64, x18) + x6), (cast(u64, x32) + x20)); + var x43: u64 = undefined; + var x44: u64 = undefined; + mulxU64(&x43, &x44, x1, 0x400000002); + var x45: u64 = undefined; + var x46: u64 = undefined; + mulxU64(&x45, &x46, x1, 0x100000001); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, 0x2ffffffff); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, 0x200000003); + var x51: u64 = undefined; + var x52: u1 = undefined; + addcarryxU64(&x51, &x52, 0x0, x50, x47); + var x53: u64 = undefined; + var x54: u1 = undefined; + addcarryxU64(&x53, &x54, x52, x48, x45); + var x55: u64 = undefined; + var x56: u1 = undefined; + addcarryxU64(&x55, &x56, x54, x46, x43); + var x57: u64 = undefined; + var x58: u1 = undefined; + addcarryxU64(&x57, &x58, 0x0, x35, x49); + var x59: u64 = undefined; + var x60: u1 = undefined; + addcarryxU64(&x59, &x60, x58, 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: u64 = undefined; + mulxU64(&x65, &x66, x57, 0xfffffffeffffffff); + var x67: u64 = undefined; + var x68: u64 = undefined; + mulxU64(&x67, &x68, x57, 0xffffffffffffffff); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x57, 0xffffffff00000000); + var x71: u64 = undefined; + var x72: u64 = undefined; + mulxU64(&x71, &x72, x57, 0xffffffffffffffff); + var x73: u64 = undefined; + var x74: u1 = undefined; + addcarryxU64(&x73, &x74, 0x0, x72, x69); + var x75: u64 = undefined; + var x76: u1 = undefined; + addcarryxU64(&x75, &x76, x74, x70, x67); + var x77: u64 = undefined; + var x78: u1 = undefined; + addcarryxU64(&x77, &x78, x76, x68, x65); + var x79: u64 = undefined; + var x80: u1 = undefined; + addcarryxU64(&x79, &x80, 0x0, x57, x71); + var x81: u64 = undefined; + var x82: u1 = undefined; + addcarryxU64(&x81, &x82, x80, x59, x73); + var x83: u64 = undefined; + var x84: u1 = undefined; + addcarryxU64(&x83, &x84, x82, x61, x75); + var x85: u64 = undefined; + var x86: u1 = undefined; + addcarryxU64(&x85, &x86, x84, x63, x77); + var x87: u64 = undefined; + var x88: u1 = undefined; + addcarryxU64(&x87, &x88, x86, ((cast(u64, x64) + cast(u64, x42)) + (cast(u64, x56) + x44)), (cast(u64, x78) + x66)); + var x89: u64 = undefined; + var x90: u64 = undefined; + mulxU64(&x89, &x90, x2, 0x400000002); + var x91: u64 = undefined; + var x92: u64 = undefined; + mulxU64(&x91, &x92, x2, 0x100000001); + var x93: u64 = undefined; + var x94: u64 = undefined; + mulxU64(&x93, &x94, x2, 0x2ffffffff); + var x95: u64 = undefined; + var x96: u64 = undefined; + mulxU64(&x95, &x96, x2, 0x200000003); + var x97: u64 = undefined; + var x98: u1 = undefined; + addcarryxU64(&x97, &x98, 0x0, x96, x93); + var x99: u64 = undefined; + var x100: u1 = undefined; + addcarryxU64(&x99, &x100, x98, x94, x91); + var x101: u64 = undefined; + var x102: u1 = undefined; + addcarryxU64(&x101, &x102, x100, x92, x89); + var x103: u64 = undefined; + var x104: u1 = undefined; + addcarryxU64(&x103, &x104, 0x0, x81, x95); + var x105: u64 = undefined; + var x106: u1 = undefined; + addcarryxU64(&x105, &x106, x104, x83, x97); + var x107: u64 = undefined; + var x108: u1 = undefined; + addcarryxU64(&x107, &x108, x106, x85, x99); + var x109: u64 = undefined; + var x110: u1 = undefined; + addcarryxU64(&x109, &x110, x108, x87, x101); + var x111: u64 = undefined; + var x112: u64 = undefined; + mulxU64(&x111, &x112, x103, 0xfffffffeffffffff); + var x113: u64 = undefined; + var x114: u64 = undefined; + mulxU64(&x113, &x114, x103, 0xffffffffffffffff); + var x115: u64 = undefined; + var x116: u64 = undefined; + mulxU64(&x115, &x116, x103, 0xffffffff00000000); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x103, 0xffffffffffffffff); + var x119: u64 = undefined; + var x120: u1 = undefined; + addcarryxU64(&x119, &x120, 0x0, x118, x115); + var x121: u64 = undefined; + var x122: u1 = undefined; + addcarryxU64(&x121, &x122, x120, x116, x113); + var x123: u64 = undefined; + var x124: u1 = undefined; + addcarryxU64(&x123, &x124, x122, x114, x111); + var x125: u64 = undefined; + var x126: u1 = undefined; + addcarryxU64(&x125, &x126, 0x0, x103, x117); + var x127: u64 = undefined; + var x128: u1 = undefined; + addcarryxU64(&x127, &x128, x126, x105, x119); + var x129: u64 = undefined; + var x130: u1 = undefined; + addcarryxU64(&x129, &x130, x128, x107, x121); + var x131: u64 = undefined; + var x132: u1 = undefined; + addcarryxU64(&x131, &x132, x130, x109, x123); + var x133: u64 = undefined; + var x134: u1 = undefined; + addcarryxU64(&x133, &x134, x132, ((cast(u64, x110) + cast(u64, x88)) + (cast(u64, x102) + x90)), (cast(u64, x124) + x112)); + var x135: u64 = undefined; + var x136: u64 = undefined; + mulxU64(&x135, &x136, x3, 0x400000002); + var x137: u64 = undefined; + var x138: u64 = undefined; + mulxU64(&x137, &x138, x3, 0x100000001); + var x139: u64 = undefined; + var x140: u64 = undefined; + mulxU64(&x139, &x140, x3, 0x2ffffffff); + var x141: u64 = undefined; + var x142: u64 = undefined; + mulxU64(&x141, &x142, x3, 0x200000003); + 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); + var x149: u64 = undefined; + var x150: u1 = undefined; + addcarryxU64(&x149, &x150, 0x0, x127, x141); + var x151: u64 = undefined; + var x152: u1 = undefined; + addcarryxU64(&x151, &x152, x150, x129, x143); + var x153: u64 = undefined; + var x154: u1 = undefined; + addcarryxU64(&x153, &x154, x152, x131, x145); + var x155: u64 = undefined; + var x156: u1 = undefined; + addcarryxU64(&x155, &x156, x154, x133, x147); + var x157: u64 = undefined; + var x158: u64 = undefined; + mulxU64(&x157, &x158, x149, 0xfffffffeffffffff); + var x159: u64 = undefined; + var x160: u64 = undefined; + mulxU64(&x159, &x160, x149, 0xffffffffffffffff); + var x161: u64 = undefined; + var x162: u64 = undefined; + mulxU64(&x161, &x162, x149, 0xffffffff00000000); + var x163: u64 = undefined; + var x164: u64 = undefined; + mulxU64(&x163, &x164, x149, 0xffffffffffffffff); + var x165: u64 = undefined; + var x166: u1 = undefined; + addcarryxU64(&x165, &x166, 0x0, x164, x161); + var x167: u64 = undefined; + var x168: u1 = undefined; + addcarryxU64(&x167, &x168, x166, x162, x159); + var x169: u64 = undefined; + var x170: u1 = undefined; + addcarryxU64(&x169, &x170, x168, x160, x157); + var x171: u64 = undefined; + var x172: u1 = undefined; + addcarryxU64(&x171, &x172, 0x0, x149, x163); + var x173: u64 = undefined; + var x174: u1 = undefined; + addcarryxU64(&x173, &x174, x172, x151, x165); + var x175: u64 = undefined; + var x176: u1 = undefined; + addcarryxU64(&x175, &x176, x174, x153, x167); + var x177: u64 = undefined; + var x178: u1 = undefined; + addcarryxU64(&x177, &x178, x176, x155, x169); + var x179: u64 = undefined; + var x180: u1 = undefined; + addcarryxU64(&x179, &x180, x178, ((cast(u64, x156) + cast(u64, x134)) + (cast(u64, x148) + x136)), (cast(u64, x170) + x158)); + var x181: u64 = undefined; + var x182: u1 = undefined; + subborrowxU64(&x181, &x182, 0x0, x173, 0xffffffffffffffff); + var x183: u64 = undefined; + var x184: u1 = undefined; + subborrowxU64(&x183, &x184, x182, x175, 0xffffffff00000000); + var x185: u64 = undefined; + var x186: u1 = undefined; + subborrowxU64(&x185, &x186, x184, x177, 0xffffffffffffffff); + var x187: u64 = undefined; + var x188: u1 = undefined; + subborrowxU64(&x187, &x188, x186, x179, 0xfffffffeffffffff); + var x189: u64 = undefined; + var x190: u1 = undefined; + subborrowxU64(&x189, &x190, x188, cast(u64, x180), cast(u64, 0x0)); + var x191: u64 = undefined; + cmovznzU64(&x191, x190, x181, x173); + var x192: u64 = undefined; + cmovznzU64(&x192, x190, x183, x175); + var x193: u64 = undefined; + cmovznzU64(&x193, x190, x185, x177); + var x194: u64 = undefined; + cmovznzU64(&x194, x190, x187, x179); + out1[0] = x191; + out1[1] = x192; + out1[2] = x193; + out1[3] = x194; +} + +/// 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] = cast(u64, 0x1); + out1[1] = 0xffffffff; + out1[2] = cast(u64, 0x0); + out1[3] = 0x100000000; +} + +/// 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] = 0xffffffffffffffff; + out1[1] = 0xffffffff00000000; + out1[2] = 0xffffffffffffffff; + out1[3] = 0xfffffffeffffffff; + 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, 0xffffffffffffffff); + var x41: u64 = undefined; + var x42: u1 = undefined; + subborrowxU64(&x41, &x42, x40, x33, 0xffffffff00000000); + 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, 0xfffffffeffffffff); + 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); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x55, (x61 & 0xffffffff00000000)); + 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 & 0xfffffffeffffffff)); + 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, 0xffffffffffffffff); + var x104: u64 = undefined; + var x105: u1 = undefined; + subborrowxU64(&x104, &x105, x103, x96, 0xffffffff00000000); + 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, 0xfffffffeffffffff); + 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] = 0x500000028ffffffe; + out1[1] = 0xe80000009ffffffe; + out1[2] = 0xd00000018ffffffe; + out1[3] = 0x280000011ffffffd; +} diff --git a/fiat-zig/src/sm2_scalar_32.zig b/fiat-zig/src/sm2_scalar_32.zig new file mode 100644 index 00000000000..8bb81bbab22 --- /dev/null +++ b/fiat-zig/src/sm2_scalar_32.zig @@ -0,0 +1,5624 @@ +// 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 sm2_scalar '' 32 '2^256 - 2^224 - 188730267045675049073202170516080344797' 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): sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") +// +// 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 { + @setEvalBranchQuota(10000); + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + const T = std.meta.Int(source.signedness, dest.bits); + return @bitCast(@as(T, @truncate(target))); + } + } + return 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, 0x72350975); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0xfffffffe); + 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, 0xffffffff); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0x7203df6b); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x40, 0x21c6052b); + var x54: u32 = undefined; + var x55: u32 = undefined; + mulxU32(&x54, &x55, x40, 0x53bbf409); + var x56: u32 = undefined; + var x57: u32 = undefined; + mulxU32(&x56, &x57, x40, 0x39d54123); + 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, 0x72350975); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x140, 0xfffffffe); + 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, 0xffffffff); + var x150: u32 = undefined; + var x151: u32 = undefined; + mulxU32(&x150, &x151, x140, 0x7203df6b); + var x152: u32 = undefined; + var x153: u32 = undefined; + mulxU32(&x152, &x153, x140, 0x21c6052b); + var x154: u32 = undefined; + var x155: u32 = undefined; + mulxU32(&x154, &x155, x140, 0x53bbf409); + var x156: u32 = undefined; + var x157: u32 = undefined; + mulxU32(&x156, &x157, x140, 0x39d54123); + 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, 0x72350975); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x241, 0xfffffffe); + 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, 0xffffffff); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x241, 0x7203df6b); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x241, 0x21c6052b); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x241, 0x53bbf409); + var x257: u32 = undefined; + var x258: u32 = undefined; + mulxU32(&x257, &x258, x241, 0x39d54123); + 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, 0x72350975); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x342, 0xfffffffe); + 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, 0xffffffff); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x342, 0x7203df6b); + var x354: u32 = undefined; + var x355: u32 = undefined; + mulxU32(&x354, &x355, x342, 0x21c6052b); + var x356: u32 = undefined; + var x357: u32 = undefined; + mulxU32(&x356, &x357, x342, 0x53bbf409); + var x358: u32 = undefined; + var x359: u32 = undefined; + mulxU32(&x358, &x359, x342, 0x39d54123); + 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, 0x72350975); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x443, 0xfffffffe); + 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, 0xffffffff); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x443, 0x7203df6b); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x443, 0x21c6052b); + var x457: u32 = undefined; + var x458: u32 = undefined; + mulxU32(&x457, &x458, x443, 0x53bbf409); + var x459: u32 = undefined; + var x460: u32 = undefined; + mulxU32(&x459, &x460, x443, 0x39d54123); + 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, 0x72350975); + var x546: u32 = undefined; + var x547: u32 = undefined; + mulxU32(&x546, &x547, x544, 0xfffffffe); + 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, 0xffffffff); + var x554: u32 = undefined; + var x555: u32 = undefined; + mulxU32(&x554, &x555, x544, 0x7203df6b); + var x556: u32 = undefined; + var x557: u32 = undefined; + mulxU32(&x556, &x557, x544, 0x21c6052b); + var x558: u32 = undefined; + var x559: u32 = undefined; + mulxU32(&x558, &x559, x544, 0x53bbf409); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x544, 0x39d54123); + 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, 0x72350975); + var x647: u32 = undefined; + var x648: u32 = undefined; + mulxU32(&x647, &x648, x645, 0xfffffffe); + 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, 0xffffffff); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x645, 0x7203df6b); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x645, 0x21c6052b); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x645, 0x53bbf409); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x645, 0x39d54123); + 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, 0x72350975); + var x748: u32 = undefined; + var x749: u32 = undefined; + mulxU32(&x748, &x749, x746, 0xfffffffe); + 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, 0xffffffff); + var x756: u32 = undefined; + var x757: u32 = undefined; + mulxU32(&x756, &x757, x746, 0x7203df6b); + var x758: u32 = undefined; + var x759: u32 = undefined; + mulxU32(&x758, &x759, x746, 0x21c6052b); + var x760: u32 = undefined; + var x761: u32 = undefined; + mulxU32(&x760, &x761, x746, 0x53bbf409); + var x762: u32 = undefined; + var x763: u32 = undefined; + mulxU32(&x762, &x763, x746, 0x39d54123); + 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, 0x39d54123); + var x800: u32 = undefined; + var x801: u1 = undefined; + subborrowxU32(&x800, &x801, x799, x783, 0x53bbf409); + var x802: u32 = undefined; + var x803: u1 = undefined; + subborrowxU32(&x802, &x803, x801, x785, 0x21c6052b); + var x804: u32 = undefined; + var x805: u1 = undefined; + subborrowxU32(&x804, &x805, x803, x787, 0x7203df6b); + var x806: u32 = undefined; + var x807: u1 = undefined; + subborrowxU32(&x806, &x807, x805, x789, 0xffffffff); + 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, 0xfffffffe); + 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, 0x72350975); + var x42: u32 = undefined; + var x43: u32 = undefined; + mulxU32(&x42, &x43, x40, 0xfffffffe); + 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, 0xffffffff); + var x50: u32 = undefined; + var x51: u32 = undefined; + mulxU32(&x50, &x51, x40, 0x7203df6b); + var x52: u32 = undefined; + var x53: u32 = undefined; + mulxU32(&x52, &x53, x40, 0x21c6052b); + var x54: u32 = undefined; + var x55: u32 = undefined; + mulxU32(&x54, &x55, x40, 0x53bbf409); + var x56: u32 = undefined; + var x57: u32 = undefined; + mulxU32(&x56, &x57, x40, 0x39d54123); + 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, 0x72350975); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x140, 0xfffffffe); + 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, 0xffffffff); + var x150: u32 = undefined; + var x151: u32 = undefined; + mulxU32(&x150, &x151, x140, 0x7203df6b); + var x152: u32 = undefined; + var x153: u32 = undefined; + mulxU32(&x152, &x153, x140, 0x21c6052b); + var x154: u32 = undefined; + var x155: u32 = undefined; + mulxU32(&x154, &x155, x140, 0x53bbf409); + var x156: u32 = undefined; + var x157: u32 = undefined; + mulxU32(&x156, &x157, x140, 0x39d54123); + 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, 0x72350975); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x241, 0xfffffffe); + 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, 0xffffffff); + var x251: u32 = undefined; + var x252: u32 = undefined; + mulxU32(&x251, &x252, x241, 0x7203df6b); + var x253: u32 = undefined; + var x254: u32 = undefined; + mulxU32(&x253, &x254, x241, 0x21c6052b); + var x255: u32 = undefined; + var x256: u32 = undefined; + mulxU32(&x255, &x256, x241, 0x53bbf409); + var x257: u32 = undefined; + var x258: u32 = undefined; + mulxU32(&x257, &x258, x241, 0x39d54123); + 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, 0x72350975); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x342, 0xfffffffe); + 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, 0xffffffff); + var x352: u32 = undefined; + var x353: u32 = undefined; + mulxU32(&x352, &x353, x342, 0x7203df6b); + var x354: u32 = undefined; + var x355: u32 = undefined; + mulxU32(&x354, &x355, x342, 0x21c6052b); + var x356: u32 = undefined; + var x357: u32 = undefined; + mulxU32(&x356, &x357, x342, 0x53bbf409); + var x358: u32 = undefined; + var x359: u32 = undefined; + mulxU32(&x358, &x359, x342, 0x39d54123); + 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, 0x72350975); + var x445: u32 = undefined; + var x446: u32 = undefined; + mulxU32(&x445, &x446, x443, 0xfffffffe); + 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, 0xffffffff); + var x453: u32 = undefined; + var x454: u32 = undefined; + mulxU32(&x453, &x454, x443, 0x7203df6b); + var x455: u32 = undefined; + var x456: u32 = undefined; + mulxU32(&x455, &x456, x443, 0x21c6052b); + var x457: u32 = undefined; + var x458: u32 = undefined; + mulxU32(&x457, &x458, x443, 0x53bbf409); + var x459: u32 = undefined; + var x460: u32 = undefined; + mulxU32(&x459, &x460, x443, 0x39d54123); + 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, 0x72350975); + var x546: u32 = undefined; + var x547: u32 = undefined; + mulxU32(&x546, &x547, x544, 0xfffffffe); + 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, 0xffffffff); + var x554: u32 = undefined; + var x555: u32 = undefined; + mulxU32(&x554, &x555, x544, 0x7203df6b); + var x556: u32 = undefined; + var x557: u32 = undefined; + mulxU32(&x556, &x557, x544, 0x21c6052b); + var x558: u32 = undefined; + var x559: u32 = undefined; + mulxU32(&x558, &x559, x544, 0x53bbf409); + var x560: u32 = undefined; + var x561: u32 = undefined; + mulxU32(&x560, &x561, x544, 0x39d54123); + 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, 0x72350975); + var x647: u32 = undefined; + var x648: u32 = undefined; + mulxU32(&x647, &x648, x645, 0xfffffffe); + 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, 0xffffffff); + var x655: u32 = undefined; + var x656: u32 = undefined; + mulxU32(&x655, &x656, x645, 0x7203df6b); + var x657: u32 = undefined; + var x658: u32 = undefined; + mulxU32(&x657, &x658, x645, 0x21c6052b); + var x659: u32 = undefined; + var x660: u32 = undefined; + mulxU32(&x659, &x660, x645, 0x53bbf409); + var x661: u32 = undefined; + var x662: u32 = undefined; + mulxU32(&x661, &x662, x645, 0x39d54123); + 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, 0x72350975); + var x748: u32 = undefined; + var x749: u32 = undefined; + mulxU32(&x748, &x749, x746, 0xfffffffe); + 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, 0xffffffff); + var x756: u32 = undefined; + var x757: u32 = undefined; + mulxU32(&x756, &x757, x746, 0x7203df6b); + var x758: u32 = undefined; + var x759: u32 = undefined; + mulxU32(&x758, &x759, x746, 0x21c6052b); + var x760: u32 = undefined; + var x761: u32 = undefined; + mulxU32(&x760, &x761, x746, 0x53bbf409); + var x762: u32 = undefined; + var x763: u32 = undefined; + mulxU32(&x762, &x763, x746, 0x39d54123); + 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, 0x39d54123); + var x800: u32 = undefined; + var x801: u1 = undefined; + subborrowxU32(&x800, &x801, x799, x783, 0x53bbf409); + var x802: u32 = undefined; + var x803: u1 = undefined; + subborrowxU32(&x802, &x803, x801, x785, 0x21c6052b); + var x804: u32 = undefined; + var x805: u1 = undefined; + subborrowxU32(&x804, &x805, x803, x787, 0x7203df6b); + var x806: u32 = undefined; + var x807: u1 = undefined; + subborrowxU32(&x806, &x807, x805, x789, 0xffffffff); + 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, 0xfffffffe); + 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, 0x39d54123); + var x19: u32 = undefined; + var x20: u1 = undefined; + subborrowxU32(&x19, &x20, x18, x3, 0x53bbf409); + var x21: u32 = undefined; + var x22: u1 = undefined; + subborrowxU32(&x21, &x22, x20, x5, 0x21c6052b); + var x23: u32 = undefined; + var x24: u1 = undefined; + subborrowxU32(&x23, &x24, x22, x7, 0x7203df6b); + 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, 0xffffffff); + var x31: u32 = undefined; + var x32: u1 = undefined; + subborrowxU32(&x31, &x32, x30, x15, 0xfffffffe); + 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 & 0x39d54123)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0x53bbf409)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0x21c6052b)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0x7203df6b)); + 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, x17); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, (x17 & 0xfffffffe)); + 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 & 0x39d54123)); + var x20: u32 = undefined; + var x21: u1 = undefined; + addcarryxU32(&x20, &x21, x19, x3, (x17 & 0x53bbf409)); + var x22: u32 = undefined; + var x23: u1 = undefined; + addcarryxU32(&x22, &x23, x21, x5, (x17 & 0x21c6052b)); + var x24: u32 = undefined; + var x25: u1 = undefined; + addcarryxU32(&x24, &x25, x23, x7, (x17 & 0x7203df6b)); + 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, x17); + var x32: u32 = undefined; + var x33: u1 = undefined; + addcarryxU32(&x32, &x33, x31, x15, (x17 & 0xfffffffe)); + 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, 0x72350975); + var x4: u32 = undefined; + var x5: u32 = undefined; + mulxU32(&x4, &x5, x2, 0xfffffffe); + 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, 0x7203df6b); + var x14: u32 = undefined; + var x15: u32 = undefined; + mulxU32(&x14, &x15, x2, 0x21c6052b); + var x16: u32 = undefined; + var x17: u32 = undefined; + mulxU32(&x16, &x17, x2, 0x53bbf409); + var x18: u32 = undefined; + var x19: u32 = undefined; + mulxU32(&x18, &x19, x2, 0x39d54123); + 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, 0x0, x36, (arg1[1])); + 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, x44, cast(u32, 0x0)); + var x60: u32 = undefined; + var x61: u1 = undefined; + addcarryxU32(&x60, &x61, x59, x46, cast(u32, 0x0)); + var x62: u32 = undefined; + var x63: u1 = undefined; + addcarryxU32(&x62, &x63, x61, x48, cast(u32, 0x0)); + var x64: u32 = undefined; + var x65: u1 = undefined; + addcarryxU32(&x64, &x65, x63, (cast(u32, x49) + (cast(u32, x33) + x5)), cast(u32, 0x0)); + var x66: u32 = undefined; + var x67: u32 = undefined; + mulxU32(&x66, &x67, x50, 0x72350975); + var x68: u32 = undefined; + var x69: u32 = undefined; + mulxU32(&x68, &x69, x66, 0xfffffffe); + var x70: u32 = undefined; + var x71: u32 = undefined; + mulxU32(&x70, &x71, x66, 0xffffffff); + var x72: u32 = undefined; + var x73: u32 = undefined; + mulxU32(&x72, &x73, x66, 0xffffffff); + var x74: u32 = undefined; + var x75: u32 = undefined; + mulxU32(&x74, &x75, x66, 0xffffffff); + var x76: u32 = undefined; + var x77: u32 = undefined; + mulxU32(&x76, &x77, x66, 0x7203df6b); + var x78: u32 = undefined; + var x79: u32 = undefined; + mulxU32(&x78, &x79, x66, 0x21c6052b); + var x80: u32 = undefined; + var x81: u32 = undefined; + mulxU32(&x80, &x81, x66, 0x53bbf409); + var x82: u32 = undefined; + var x83: u32 = undefined; + mulxU32(&x82, &x83, x66, 0x39d54123); + var x84: u32 = undefined; + var x85: u1 = undefined; + addcarryxU32(&x84, &x85, 0x0, x83, x80); + var x86: u32 = undefined; + var x87: u1 = undefined; + addcarryxU32(&x86, &x87, x85, x81, x78); + var x88: u32 = undefined; + var x89: u1 = undefined; + addcarryxU32(&x88, &x89, x87, x79, x76); + var x90: u32 = undefined; + var x91: u1 = undefined; + addcarryxU32(&x90, &x91, x89, x77, x74); + var x92: u32 = undefined; + var x93: u1 = undefined; + addcarryxU32(&x92, &x93, x91, x75, x72); + var x94: u32 = undefined; + var x95: u1 = undefined; + addcarryxU32(&x94, &x95, x93, x73, x70); + var x96: u32 = undefined; + var x97: u1 = undefined; + addcarryxU32(&x96, &x97, x95, x71, x68); + var x98: u32 = undefined; + var x99: u1 = undefined; + addcarryxU32(&x98, &x99, 0x0, x50, x82); + var x100: u32 = undefined; + var x101: u1 = undefined; + addcarryxU32(&x100, &x101, x99, 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, cast(u32, x65), (cast(u32, x97) + x69)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, 0x0, x100, (arg1[2])); + var x118: u32 = undefined; + var x119: u1 = undefined; + addcarryxU32(&x118, &x119, x117, x102, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x132, &x133, x116, 0x72350975); + var x134: u32 = undefined; + var x135: u32 = undefined; + mulxU32(&x134, &x135, x132, 0xfffffffe); + var x136: u32 = undefined; + var x137: u32 = undefined; + mulxU32(&x136, &x137, x132, 0xffffffff); + var x138: u32 = undefined; + var x139: u32 = undefined; + mulxU32(&x138, &x139, x132, 0xffffffff); + var x140: u32 = undefined; + var x141: u32 = undefined; + mulxU32(&x140, &x141, x132, 0xffffffff); + var x142: u32 = undefined; + var x143: u32 = undefined; + mulxU32(&x142, &x143, x132, 0x7203df6b); + var x144: u32 = undefined; + var x145: u32 = undefined; + mulxU32(&x144, &x145, x132, 0x21c6052b); + var x146: u32 = undefined; + var x147: u32 = undefined; + mulxU32(&x146, &x147, x132, 0x53bbf409); + var x148: u32 = undefined; + var x149: u32 = undefined; + mulxU32(&x148, &x149, x132, 0x39d54123); + 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); + var x160: u32 = undefined; + var x161: u1 = undefined; + addcarryxU32(&x160, &x161, x159, x139, x136); + var x162: u32 = undefined; + var x163: u1 = undefined; + addcarryxU32(&x162, &x163, x161, x137, x134); + var x164: u32 = undefined; + var x165: u1 = undefined; + addcarryxU32(&x164, &x165, 0x0, x116, x148); + var x166: u32 = undefined; + var x167: u1 = undefined; + addcarryxU32(&x166, &x167, x165, 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, (cast(u32, x131) + cast(u32, x115)), (cast(u32, x163) + x135)); + var x182: u32 = undefined; + var x183: u1 = undefined; + addcarryxU32(&x182, &x183, 0x0, x166, (arg1[3])); + var x184: u32 = undefined; + var x185: u1 = undefined; + addcarryxU32(&x184, &x185, x183, x168, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x198, &x199, x182, 0x72350975); + var x200: u32 = undefined; + var x201: u32 = undefined; + mulxU32(&x200, &x201, x198, 0xfffffffe); + 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, 0x7203df6b); + var x210: u32 = undefined; + var x211: u32 = undefined; + mulxU32(&x210, &x211, x198, 0x21c6052b); + var x212: u32 = undefined; + var x213: u32 = undefined; + mulxU32(&x212, &x213, x198, 0x53bbf409); + var x214: u32 = undefined; + var x215: u32 = undefined; + mulxU32(&x214, &x215, x198, 0x39d54123); + var x216: u32 = undefined; + var x217: u1 = undefined; + addcarryxU32(&x216, &x217, 0x0, x215, x212); + var x218: u32 = undefined; + var x219: u1 = undefined; + addcarryxU32(&x218, &x219, x217, x213, x210); + var x220: u32 = undefined; + var x221: u1 = undefined; + addcarryxU32(&x220, &x221, x219, x211, x208); + var x222: u32 = undefined; + var x223: u1 = undefined; + addcarryxU32(&x222, &x223, x221, x209, x206); + var x224: u32 = undefined; + var x225: u1 = undefined; + addcarryxU32(&x224, &x225, x223, x207, x204); + var x226: u32 = undefined; + var x227: u1 = undefined; + addcarryxU32(&x226, &x227, x225, x205, x202); + var x228: u32 = undefined; + var x229: u1 = undefined; + addcarryxU32(&x228, &x229, x227, x203, x200); + var x230: u32 = undefined; + var x231: u1 = undefined; + addcarryxU32(&x230, &x231, 0x0, x182, x214); + var x232: u32 = undefined; + var x233: u1 = undefined; + addcarryxU32(&x232, &x233, x231, 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, (cast(u32, x197) + cast(u32, x181)), (cast(u32, x229) + x201)); + var x248: u32 = undefined; + var x249: u1 = undefined; + addcarryxU32(&x248, &x249, 0x0, x232, (arg1[4])); + var x250: u32 = undefined; + var x251: u1 = undefined; + addcarryxU32(&x250, &x251, x249, x234, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x264, &x265, x248, 0x72350975); + var x266: u32 = undefined; + var x267: u32 = undefined; + mulxU32(&x266, &x267, x264, 0xfffffffe); + var x268: u32 = undefined; + var x269: u32 = undefined; + mulxU32(&x268, &x269, x264, 0xffffffff); + var x270: u32 = undefined; + var x271: u32 = undefined; + mulxU32(&x270, &x271, x264, 0xffffffff); + var x272: u32 = undefined; + var x273: u32 = undefined; + mulxU32(&x272, &x273, x264, 0xffffffff); + var x274: u32 = undefined; + var x275: u32 = undefined; + mulxU32(&x274, &x275, x264, 0x7203df6b); + var x276: u32 = undefined; + var x277: u32 = undefined; + mulxU32(&x276, &x277, x264, 0x21c6052b); + var x278: u32 = undefined; + var x279: u32 = undefined; + mulxU32(&x278, &x279, x264, 0x53bbf409); + var x280: u32 = undefined; + var x281: u32 = undefined; + mulxU32(&x280, &x281, x264, 0x39d54123); + var x282: u32 = undefined; + var x283: u1 = undefined; + addcarryxU32(&x282, &x283, 0x0, x281, x278); + var x284: u32 = undefined; + var x285: u1 = undefined; + addcarryxU32(&x284, &x285, x283, x279, x276); + var x286: u32 = undefined; + var x287: u1 = undefined; + addcarryxU32(&x286, &x287, x285, x277, x274); + var x288: u32 = undefined; + var x289: u1 = undefined; + addcarryxU32(&x288, &x289, x287, x275, x272); + var x290: u32 = undefined; + var x291: u1 = undefined; + addcarryxU32(&x290, &x291, x289, x273, x270); + var x292: u32 = undefined; + var x293: u1 = undefined; + addcarryxU32(&x292, &x293, x291, x271, x268); + var x294: u32 = undefined; + var x295: u1 = undefined; + addcarryxU32(&x294, &x295, x293, x269, x266); + var x296: u32 = undefined; + var x297: u1 = undefined; + addcarryxU32(&x296, &x297, 0x0, x248, x280); + var x298: u32 = undefined; + var x299: u1 = undefined; + addcarryxU32(&x298, &x299, x297, 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, (cast(u32, x263) + cast(u32, x247)), (cast(u32, x295) + x267)); + var x314: u32 = undefined; + var x315: u1 = undefined; + addcarryxU32(&x314, &x315, 0x0, x298, (arg1[5])); + var x316: u32 = undefined; + var x317: u1 = undefined; + addcarryxU32(&x316, &x317, x315, x300, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x330, &x331, x314, 0x72350975); + var x332: u32 = undefined; + var x333: u32 = undefined; + mulxU32(&x332, &x333, x330, 0xfffffffe); + var x334: u32 = undefined; + var x335: u32 = undefined; + mulxU32(&x334, &x335, x330, 0xffffffff); + var x336: u32 = undefined; + var x337: u32 = undefined; + mulxU32(&x336, &x337, x330, 0xffffffff); + var x338: u32 = undefined; + var x339: u32 = undefined; + mulxU32(&x338, &x339, x330, 0xffffffff); + var x340: u32 = undefined; + var x341: u32 = undefined; + mulxU32(&x340, &x341, x330, 0x7203df6b); + var x342: u32 = undefined; + var x343: u32 = undefined; + mulxU32(&x342, &x343, x330, 0x21c6052b); + var x344: u32 = undefined; + var x345: u32 = undefined; + mulxU32(&x344, &x345, x330, 0x53bbf409); + var x346: u32 = undefined; + var x347: u32 = undefined; + mulxU32(&x346, &x347, x330, 0x39d54123); + var x348: u32 = undefined; + var x349: u1 = undefined; + addcarryxU32(&x348, &x349, 0x0, x347, x344); + var x350: u32 = undefined; + var x351: u1 = undefined; + addcarryxU32(&x350, &x351, x349, x345, x342); + var x352: u32 = undefined; + var x353: u1 = undefined; + addcarryxU32(&x352, &x353, x351, x343, x340); + var x354: u32 = undefined; + var x355: u1 = undefined; + addcarryxU32(&x354, &x355, x353, x341, x338); + var x356: u32 = undefined; + var x357: u1 = undefined; + addcarryxU32(&x356, &x357, x355, x339, x336); + var x358: u32 = undefined; + var x359: u1 = undefined; + addcarryxU32(&x358, &x359, x357, x337, x334); + var x360: u32 = undefined; + var x361: u1 = undefined; + addcarryxU32(&x360, &x361, x359, x335, x332); + var x362: u32 = undefined; + var x363: u1 = undefined; + addcarryxU32(&x362, &x363, 0x0, x314, x346); + var x364: u32 = undefined; + var x365: u1 = undefined; + addcarryxU32(&x364, &x365, x363, 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, (cast(u32, x329) + cast(u32, x313)), (cast(u32, x361) + x333)); + var x380: u32 = undefined; + var x381: u1 = undefined; + addcarryxU32(&x380, &x381, 0x0, x364, (arg1[6])); + var x382: u32 = undefined; + var x383: u1 = undefined; + addcarryxU32(&x382, &x383, x381, x366, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x396, &x397, x380, 0x72350975); + var x398: u32 = undefined; + var x399: u32 = undefined; + mulxU32(&x398, &x399, x396, 0xfffffffe); + var x400: u32 = undefined; + var x401: u32 = undefined; + mulxU32(&x400, &x401, x396, 0xffffffff); + var x402: u32 = undefined; + var x403: u32 = undefined; + mulxU32(&x402, &x403, x396, 0xffffffff); + var x404: u32 = undefined; + var x405: u32 = undefined; + mulxU32(&x404, &x405, x396, 0xffffffff); + var x406: u32 = undefined; + var x407: u32 = undefined; + mulxU32(&x406, &x407, x396, 0x7203df6b); + var x408: u32 = undefined; + var x409: u32 = undefined; + mulxU32(&x408, &x409, x396, 0x21c6052b); + var x410: u32 = undefined; + var x411: u32 = undefined; + mulxU32(&x410, &x411, x396, 0x53bbf409); + var x412: u32 = undefined; + var x413: u32 = undefined; + mulxU32(&x412, &x413, x396, 0x39d54123); + var x414: u32 = undefined; + var x415: u1 = undefined; + addcarryxU32(&x414, &x415, 0x0, x413, x410); + var x416: u32 = undefined; + var x417: u1 = undefined; + addcarryxU32(&x416, &x417, x415, x411, x408); + var x418: u32 = undefined; + var x419: u1 = undefined; + addcarryxU32(&x418, &x419, x417, x409, x406); + var x420: u32 = undefined; + var x421: u1 = undefined; + addcarryxU32(&x420, &x421, x419, x407, x404); + var x422: u32 = undefined; + var x423: u1 = undefined; + addcarryxU32(&x422, &x423, x421, x405, x402); + var x424: u32 = undefined; + var x425: u1 = undefined; + addcarryxU32(&x424, &x425, x423, x403, x400); + var x426: u32 = undefined; + var x427: u1 = undefined; + addcarryxU32(&x426, &x427, x425, x401, x398); + var x428: u32 = undefined; + var x429: u1 = undefined; + addcarryxU32(&x428, &x429, 0x0, x380, x412); + var x430: u32 = undefined; + var x431: u1 = undefined; + addcarryxU32(&x430, &x431, x429, 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, (cast(u32, x395) + cast(u32, x379)), (cast(u32, x427) + x399)); + var x446: u32 = undefined; + var x447: u1 = undefined; + addcarryxU32(&x446, &x447, 0x0, x430, (arg1[7])); + var x448: u32 = undefined; + var x449: u1 = undefined; + addcarryxU32(&x448, &x449, x447, x432, cast(u32, 0x0)); + 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: u32 = undefined; + mulxU32(&x462, &x463, x446, 0x72350975); + var x464: u32 = undefined; + var x465: u32 = undefined; + mulxU32(&x464, &x465, x462, 0xfffffffe); + var x466: u32 = undefined; + var x467: u32 = undefined; + mulxU32(&x466, &x467, x462, 0xffffffff); + var x468: u32 = undefined; + var x469: u32 = undefined; + mulxU32(&x468, &x469, x462, 0xffffffff); + var x470: u32 = undefined; + var x471: u32 = undefined; + mulxU32(&x470, &x471, x462, 0xffffffff); + var x472: u32 = undefined; + var x473: u32 = undefined; + mulxU32(&x472, &x473, x462, 0x7203df6b); + var x474: u32 = undefined; + var x475: u32 = undefined; + mulxU32(&x474, &x475, x462, 0x21c6052b); + var x476: u32 = undefined; + var x477: u32 = undefined; + mulxU32(&x476, &x477, x462, 0x53bbf409); + var x478: u32 = undefined; + var x479: u32 = undefined; + mulxU32(&x478, &x479, x462, 0x39d54123); + var x480: u32 = undefined; + var x481: u1 = undefined; + addcarryxU32(&x480, &x481, 0x0, x479, x476); + var x482: u32 = undefined; + var x483: u1 = undefined; + addcarryxU32(&x482, &x483, x481, x477, x474); + var x484: u32 = undefined; + var x485: u1 = undefined; + addcarryxU32(&x484, &x485, x483, x475, x472); + var x486: u32 = undefined; + var x487: u1 = undefined; + addcarryxU32(&x486, &x487, x485, x473, x470); + var x488: u32 = undefined; + var x489: u1 = undefined; + addcarryxU32(&x488, &x489, x487, x471, x468); + var x490: u32 = undefined; + var x491: u1 = undefined; + addcarryxU32(&x490, &x491, x489, x469, x466); + var x492: u32 = undefined; + var x493: u1 = undefined; + addcarryxU32(&x492, &x493, x491, x467, x464); + var x494: u32 = undefined; + var x495: u1 = undefined; + addcarryxU32(&x494, &x495, 0x0, x446, x478); + var x496: u32 = undefined; + var x497: u1 = undefined; + addcarryxU32(&x496, &x497, x495, 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, (cast(u32, x461) + cast(u32, x445)), (cast(u32, x493) + x465)); + var x512: u32 = undefined; + var x513: u1 = undefined; + subborrowxU32(&x512, &x513, 0x0, x496, 0x39d54123); + var x514: u32 = undefined; + var x515: u1 = undefined; + subborrowxU32(&x514, &x515, x513, x498, 0x53bbf409); + var x516: u32 = undefined; + var x517: u1 = undefined; + subborrowxU32(&x516, &x517, x515, x500, 0x21c6052b); + var x518: u32 = undefined; + var x519: u1 = undefined; + subborrowxU32(&x518, &x519, x517, x502, 0x7203df6b); + var x520: u32 = undefined; + var x521: u1 = undefined; + subborrowxU32(&x520, &x521, x519, x504, 0xffffffff); + var x522: u32 = undefined; + var x523: u1 = undefined; + subborrowxU32(&x522, &x523, x521, x506, 0xffffffff); + 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, 0xfffffffe); + var x528: u32 = undefined; + var x529: u1 = undefined; + subborrowxU32(&x528, &x529, x527, cast(u32, x511), cast(u32, 0x0)); + var x530: u32 = undefined; + cmovznzU32(&x530, x529, x512, x496); + var x531: u32 = undefined; + cmovznzU32(&x531, x529, x514, x498); + var x532: u32 = undefined; + cmovznzU32(&x532, x529, x516, x500); + var x533: u32 = undefined; + cmovznzU32(&x533, x529, x518, x502); + var x534: u32 = undefined; + cmovznzU32(&x534, x529, x520, x504); + var x535: u32 = undefined; + cmovznzU32(&x535, x529, x522, x506); + var x536: u32 = undefined; + cmovznzU32(&x536, x529, x524, x508); + var x537: u32 = undefined; + cmovznzU32(&x537, x529, x526, x510); + out1[0] = x530; + out1[1] = x531; + out1[2] = x532; + out1[3] = x533; + out1[4] = x534; + out1[5] = x535; + out1[6] = x536; + out1[7] = x537; +} + +/// 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, 0x1eb5e412); + var x11: u32 = undefined; + var x12: u32 = undefined; + mulxU32(&x11, &x12, x8, 0xa22b3d3b); + var x13: u32 = undefined; + var x14: u32 = undefined; + mulxU32(&x13, &x14, x8, 0x620fc84c); + var x15: u32 = undefined; + var x16: u32 = undefined; + mulxU32(&x15, &x16, x8, 0x3affe0d4); + var x17: u32 = undefined; + var x18: u32 = undefined; + mulxU32(&x17, &x18, x8, 0x3464504a); + var x19: u32 = undefined; + var x20: u32 = undefined; + mulxU32(&x19, &x20, x8, 0xde6fa2fa); + var x21: u32 = undefined; + var x22: u32 = undefined; + mulxU32(&x21, &x22, x8, 0x901192af); + var x23: u32 = undefined; + var x24: u32 = undefined; + mulxU32(&x23, &x24, x8, 0x7c114f20); + 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, 0x72350975); + var x41: u32 = undefined; + var x42: u32 = undefined; + mulxU32(&x41, &x42, x39, 0xfffffffe); + 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, 0xffffffff); + var x49: u32 = undefined; + var x50: u32 = undefined; + mulxU32(&x49, &x50, x39, 0x7203df6b); + var x51: u32 = undefined; + var x52: u32 = undefined; + mulxU32(&x51, &x52, x39, 0x21c6052b); + var x53: u32 = undefined; + var x54: u32 = undefined; + mulxU32(&x53, &x54, x39, 0x53bbf409); + var x55: u32 = undefined; + var x56: u32 = undefined; + mulxU32(&x55, &x56, x39, 0x39d54123); + 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, 0x1eb5e412); + var x91: u32 = undefined; + var x92: u32 = undefined; + mulxU32(&x91, &x92, x1, 0xa22b3d3b); + var x93: u32 = undefined; + var x94: u32 = undefined; + mulxU32(&x93, &x94, x1, 0x620fc84c); + var x95: u32 = undefined; + var x96: u32 = undefined; + mulxU32(&x95, &x96, x1, 0x3affe0d4); + var x97: u32 = undefined; + var x98: u32 = undefined; + mulxU32(&x97, &x98, x1, 0x3464504a); + var x99: u32 = undefined; + var x100: u32 = undefined; + mulxU32(&x99, &x100, x1, 0xde6fa2fa); + var x101: u32 = undefined; + var x102: u32 = undefined; + mulxU32(&x101, &x102, x1, 0x901192af); + var x103: u32 = undefined; + var x104: u32 = undefined; + mulxU32(&x103, &x104, x1, 0x7c114f20); + 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, 0x72350975); + var x137: u32 = undefined; + var x138: u32 = undefined; + mulxU32(&x137, &x138, x135, 0xfffffffe); + 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, 0xffffffff); + var x145: u32 = undefined; + var x146: u32 = undefined; + mulxU32(&x145, &x146, x135, 0x7203df6b); + var x147: u32 = undefined; + var x148: u32 = undefined; + mulxU32(&x147, &x148, x135, 0x21c6052b); + var x149: u32 = undefined; + var x150: u32 = undefined; + mulxU32(&x149, &x150, x135, 0x53bbf409); + var x151: u32 = undefined; + var x152: u32 = undefined; + mulxU32(&x151, &x152, x135, 0x39d54123); + 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, 0x1eb5e412); + var x187: u32 = undefined; + var x188: u32 = undefined; + mulxU32(&x187, &x188, x2, 0xa22b3d3b); + var x189: u32 = undefined; + var x190: u32 = undefined; + mulxU32(&x189, &x190, x2, 0x620fc84c); + var x191: u32 = undefined; + var x192: u32 = undefined; + mulxU32(&x191, &x192, x2, 0x3affe0d4); + var x193: u32 = undefined; + var x194: u32 = undefined; + mulxU32(&x193, &x194, x2, 0x3464504a); + var x195: u32 = undefined; + var x196: u32 = undefined; + mulxU32(&x195, &x196, x2, 0xde6fa2fa); + var x197: u32 = undefined; + var x198: u32 = undefined; + mulxU32(&x197, &x198, x2, 0x901192af); + var x199: u32 = undefined; + var x200: u32 = undefined; + mulxU32(&x199, &x200, x2, 0x7c114f20); + 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, 0x72350975); + var x233: u32 = undefined; + var x234: u32 = undefined; + mulxU32(&x233, &x234, x231, 0xfffffffe); + 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, 0xffffffff); + var x241: u32 = undefined; + var x242: u32 = undefined; + mulxU32(&x241, &x242, x231, 0x7203df6b); + var x243: u32 = undefined; + var x244: u32 = undefined; + mulxU32(&x243, &x244, x231, 0x21c6052b); + var x245: u32 = undefined; + var x246: u32 = undefined; + mulxU32(&x245, &x246, x231, 0x53bbf409); + var x247: u32 = undefined; + var x248: u32 = undefined; + mulxU32(&x247, &x248, x231, 0x39d54123); + 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, 0x1eb5e412); + var x283: u32 = undefined; + var x284: u32 = undefined; + mulxU32(&x283, &x284, x3, 0xa22b3d3b); + var x285: u32 = undefined; + var x286: u32 = undefined; + mulxU32(&x285, &x286, x3, 0x620fc84c); + var x287: u32 = undefined; + var x288: u32 = undefined; + mulxU32(&x287, &x288, x3, 0x3affe0d4); + var x289: u32 = undefined; + var x290: u32 = undefined; + mulxU32(&x289, &x290, x3, 0x3464504a); + var x291: u32 = undefined; + var x292: u32 = undefined; + mulxU32(&x291, &x292, x3, 0xde6fa2fa); + var x293: u32 = undefined; + var x294: u32 = undefined; + mulxU32(&x293, &x294, x3, 0x901192af); + var x295: u32 = undefined; + var x296: u32 = undefined; + mulxU32(&x295, &x296, x3, 0x7c114f20); + 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, 0x72350975); + var x329: u32 = undefined; + var x330: u32 = undefined; + mulxU32(&x329, &x330, x327, 0xfffffffe); + 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, 0xffffffff); + var x337: u32 = undefined; + var x338: u32 = undefined; + mulxU32(&x337, &x338, x327, 0x7203df6b); + var x339: u32 = undefined; + var x340: u32 = undefined; + mulxU32(&x339, &x340, x327, 0x21c6052b); + var x341: u32 = undefined; + var x342: u32 = undefined; + mulxU32(&x341, &x342, x327, 0x53bbf409); + var x343: u32 = undefined; + var x344: u32 = undefined; + mulxU32(&x343, &x344, x327, 0x39d54123); + 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, 0x1eb5e412); + var x379: u32 = undefined; + var x380: u32 = undefined; + mulxU32(&x379, &x380, x4, 0xa22b3d3b); + var x381: u32 = undefined; + var x382: u32 = undefined; + mulxU32(&x381, &x382, x4, 0x620fc84c); + var x383: u32 = undefined; + var x384: u32 = undefined; + mulxU32(&x383, &x384, x4, 0x3affe0d4); + var x385: u32 = undefined; + var x386: u32 = undefined; + mulxU32(&x385, &x386, x4, 0x3464504a); + var x387: u32 = undefined; + var x388: u32 = undefined; + mulxU32(&x387, &x388, x4, 0xde6fa2fa); + var x389: u32 = undefined; + var x390: u32 = undefined; + mulxU32(&x389, &x390, x4, 0x901192af); + var x391: u32 = undefined; + var x392: u32 = undefined; + mulxU32(&x391, &x392, x4, 0x7c114f20); + 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, 0x72350975); + var x425: u32 = undefined; + var x426: u32 = undefined; + mulxU32(&x425, &x426, x423, 0xfffffffe); + 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, 0xffffffff); + var x433: u32 = undefined; + var x434: u32 = undefined; + mulxU32(&x433, &x434, x423, 0x7203df6b); + var x435: u32 = undefined; + var x436: u32 = undefined; + mulxU32(&x435, &x436, x423, 0x21c6052b); + var x437: u32 = undefined; + var x438: u32 = undefined; + mulxU32(&x437, &x438, x423, 0x53bbf409); + var x439: u32 = undefined; + var x440: u32 = undefined; + mulxU32(&x439, &x440, x423, 0x39d54123); + 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, 0x1eb5e412); + var x475: u32 = undefined; + var x476: u32 = undefined; + mulxU32(&x475, &x476, x5, 0xa22b3d3b); + var x477: u32 = undefined; + var x478: u32 = undefined; + mulxU32(&x477, &x478, x5, 0x620fc84c); + var x479: u32 = undefined; + var x480: u32 = undefined; + mulxU32(&x479, &x480, x5, 0x3affe0d4); + var x481: u32 = undefined; + var x482: u32 = undefined; + mulxU32(&x481, &x482, x5, 0x3464504a); + var x483: u32 = undefined; + var x484: u32 = undefined; + mulxU32(&x483, &x484, x5, 0xde6fa2fa); + var x485: u32 = undefined; + var x486: u32 = undefined; + mulxU32(&x485, &x486, x5, 0x901192af); + var x487: u32 = undefined; + var x488: u32 = undefined; + mulxU32(&x487, &x488, x5, 0x7c114f20); + 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, 0x72350975); + var x521: u32 = undefined; + var x522: u32 = undefined; + mulxU32(&x521, &x522, x519, 0xfffffffe); + 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, 0xffffffff); + var x529: u32 = undefined; + var x530: u32 = undefined; + mulxU32(&x529, &x530, x519, 0x7203df6b); + var x531: u32 = undefined; + var x532: u32 = undefined; + mulxU32(&x531, &x532, x519, 0x21c6052b); + var x533: u32 = undefined; + var x534: u32 = undefined; + mulxU32(&x533, &x534, x519, 0x53bbf409); + var x535: u32 = undefined; + var x536: u32 = undefined; + mulxU32(&x535, &x536, x519, 0x39d54123); + 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, 0x1eb5e412); + var x571: u32 = undefined; + var x572: u32 = undefined; + mulxU32(&x571, &x572, x6, 0xa22b3d3b); + var x573: u32 = undefined; + var x574: u32 = undefined; + mulxU32(&x573, &x574, x6, 0x620fc84c); + var x575: u32 = undefined; + var x576: u32 = undefined; + mulxU32(&x575, &x576, x6, 0x3affe0d4); + var x577: u32 = undefined; + var x578: u32 = undefined; + mulxU32(&x577, &x578, x6, 0x3464504a); + var x579: u32 = undefined; + var x580: u32 = undefined; + mulxU32(&x579, &x580, x6, 0xde6fa2fa); + var x581: u32 = undefined; + var x582: u32 = undefined; + mulxU32(&x581, &x582, x6, 0x901192af); + var x583: u32 = undefined; + var x584: u32 = undefined; + mulxU32(&x583, &x584, x6, 0x7c114f20); + 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, 0x72350975); + var x617: u32 = undefined; + var x618: u32 = undefined; + mulxU32(&x617, &x618, x615, 0xfffffffe); + 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, 0xffffffff); + var x625: u32 = undefined; + var x626: u32 = undefined; + mulxU32(&x625, &x626, x615, 0x7203df6b); + var x627: u32 = undefined; + var x628: u32 = undefined; + mulxU32(&x627, &x628, x615, 0x21c6052b); + var x629: u32 = undefined; + var x630: u32 = undefined; + mulxU32(&x629, &x630, x615, 0x53bbf409); + var x631: u32 = undefined; + var x632: u32 = undefined; + mulxU32(&x631, &x632, x615, 0x39d54123); + 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, 0x1eb5e412); + var x667: u32 = undefined; + var x668: u32 = undefined; + mulxU32(&x667, &x668, x7, 0xa22b3d3b); + var x669: u32 = undefined; + var x670: u32 = undefined; + mulxU32(&x669, &x670, x7, 0x620fc84c); + var x671: u32 = undefined; + var x672: u32 = undefined; + mulxU32(&x671, &x672, x7, 0x3affe0d4); + var x673: u32 = undefined; + var x674: u32 = undefined; + mulxU32(&x673, &x674, x7, 0x3464504a); + var x675: u32 = undefined; + var x676: u32 = undefined; + mulxU32(&x675, &x676, x7, 0xde6fa2fa); + var x677: u32 = undefined; + var x678: u32 = undefined; + mulxU32(&x677, &x678, x7, 0x901192af); + var x679: u32 = undefined; + var x680: u32 = undefined; + mulxU32(&x679, &x680, x7, 0x7c114f20); + 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, 0x72350975); + var x713: u32 = undefined; + var x714: u32 = undefined; + mulxU32(&x713, &x714, x711, 0xfffffffe); + 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, 0xffffffff); + var x721: u32 = undefined; + var x722: u32 = undefined; + mulxU32(&x721, &x722, x711, 0x7203df6b); + var x723: u32 = undefined; + var x724: u32 = undefined; + mulxU32(&x723, &x724, x711, 0x21c6052b); + var x725: u32 = undefined; + var x726: u32 = undefined; + mulxU32(&x725, &x726, x711, 0x53bbf409); + var x727: u32 = undefined; + var x728: u32 = undefined; + mulxU32(&x727, &x728, x711, 0x39d54123); + 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, 0x39d54123); + var x763: u32 = undefined; + var x764: u1 = undefined; + subborrowxU32(&x763, &x764, x762, x747, 0x53bbf409); + var x765: u32 = undefined; + var x766: u1 = undefined; + subborrowxU32(&x765, &x766, x764, x749, 0x21c6052b); + var x767: u32 = undefined; + var x768: u1 = undefined; + subborrowxU32(&x767, &x768, x766, x751, 0x7203df6b); + var x769: u32 = undefined; + var x770: u1 = undefined; + subborrowxU32(&x769, &x770, x768, x753, 0xffffffff); + 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, 0xfffffffe); + 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] = 0xc62abedd; + out1[1] = 0xac440bf6; + out1[2] = 0xde39fad4; + out1[3] = 0x8dfc2094; + out1[4] = cast(u32, 0x0); + out1[5] = cast(u32, 0x0); + out1[6] = cast(u32, 0x0); + out1[7] = cast(u32, 0x1); +} + +/// 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] = 0x39d54123; + out1[1] = 0x53bbf409; + out1[2] = 0x21c6052b; + out1[3] = 0x7203df6b; + out1[4] = 0xffffffff; + out1[5] = 0xffffffff; + out1[6] = 0xffffffff; + out1[7] = 0xfffffffe; + 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, 0x39d54123); + var x69: u32 = undefined; + var x70: u1 = undefined; + subborrowxU32(&x69, &x70, x68, x53, 0x53bbf409); + var x71: u32 = undefined; + var x72: u1 = undefined; + subborrowxU32(&x71, &x72, x70, x55, 0x21c6052b); + var x73: u32 = undefined; + var x74: u1 = undefined; + subborrowxU32(&x73, &x74, x72, x57, 0x7203df6b); + 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, 0xffffffff); + var x81: u32 = undefined; + var x82: u1 = undefined; + subborrowxU32(&x81, &x82, x80, x65, 0xfffffffe); + 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 & 0x39d54123)); + var x112: u32 = undefined; + var x113: u1 = undefined; + addcarryxU32(&x112, &x113, x111, x95, (x109 & 0x53bbf409)); + var x114: u32 = undefined; + var x115: u1 = undefined; + addcarryxU32(&x114, &x115, x113, x97, (x109 & 0x21c6052b)); + var x116: u32 = undefined; + var x117: u1 = undefined; + addcarryxU32(&x116, &x117, x115, x99, (x109 & 0x7203df6b)); + 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, x109); + var x124: u32 = undefined; + var x125: u1 = undefined; + addcarryxU32(&x124, &x125, x123, x107, (x109 & 0xfffffffe)); + 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, 0x39d54123); + var x188: u32 = undefined; + var x189: u1 = undefined; + subborrowxU32(&x188, &x189, x187, x172, 0x53bbf409); + var x190: u32 = undefined; + var x191: u1 = undefined; + subborrowxU32(&x190, &x191, x189, x174, 0x21c6052b); + var x192: u32 = undefined; + var x193: u1 = undefined; + subborrowxU32(&x192, &x193, x191, x176, 0x7203df6b); + 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, 0xffffffff); + var x200: u32 = undefined; + var x201: u1 = undefined; + subborrowxU32(&x200, &x201, x199, x184, 0xfffffffe); + 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] = 0xb351756d; + out1[1] = 0x1aa32707; + out1[2] = 0x1e2a62fa; + out1[3] = 0xabdd67; + out1[4] = 0xd4009a81; + out1[5] = 0x49280d7d; + out1[6] = 0xe6bb86e8; + out1[7] = 0xd730336e; +} diff --git a/fiat-zig/src/sm2_scalar_64.zig b/fiat-zig/src/sm2_scalar_64.zig new file mode 100644 index 00000000000..c2901d86fdc --- /dev/null +++ b/fiat-zig/src/sm2_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 sm2_scalar '' 64 '2^256 - 2^224 - 188730267045675049073202170516080344797' 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): sm2_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 = 0xfffffffeffffffffffffffffffffffff7203df6b21c6052b53bbf40939d54123 (from "2^256 - 2^224 - 188730267045675049073202170516080344797") +// +// 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 { + @setEvalBranchQuota(10000); + if (@typeInfo(@TypeOf(target)) == .Int) { + const dest = @typeInfo(DestType).Int; + const source = @typeInfo(@TypeOf(target)).Int; + if (dest.bits < source.bits) { + const T = std.meta.Int(source.signedness, dest.bits); + return @bitCast(@as(T, @truncate(target))); + } + } + return 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, 0x327f9e8872350975); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x28: u64 = undefined; + var x29: u64 = undefined; + mulxU64(&x28, &x29, x20, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x72, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x80: u64 = undefined; + var x81: u64 = undefined; + mulxU64(&x80, &x81, x72, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x125, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x133: u64 = undefined; + var x134: u64 = undefined; + mulxU64(&x133, &x134, x125, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x180: u64 = undefined; + var x181: u64 = undefined; + mulxU64(&x180, &x181, x178, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x186: u64 = undefined; + var x187: u64 = undefined; + mulxU64(&x186, &x187, x178, 0x53bbf40939d54123); + 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, 0x53bbf40939d54123); + var x208: u64 = undefined; + var x209: u1 = undefined; + subborrowxU64(&x208, &x209, x207, x199, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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, 0x327f9e8872350975); + var x22: u64 = undefined; + var x23: u64 = undefined; + mulxU64(&x22, &x23, x20, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x28: u64 = undefined; + var x29: u64 = undefined; + mulxU64(&x28, &x29, x20, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x74: u64 = undefined; + var x75: u64 = undefined; + mulxU64(&x74, &x75, x72, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x80: u64 = undefined; + var x81: u64 = undefined; + mulxU64(&x80, &x81, x72, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x127: u64 = undefined; + var x128: u64 = undefined; + mulxU64(&x127, &x128, x125, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x133: u64 = undefined; + var x134: u64 = undefined; + mulxU64(&x133, &x134, x125, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x180: u64 = undefined; + var x181: u64 = undefined; + mulxU64(&x180, &x181, x178, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x186: u64 = undefined; + var x187: u64 = undefined; + mulxU64(&x186, &x187, x178, 0x53bbf40939d54123); + 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, 0x53bbf40939d54123); + var x208: u64 = undefined; + var x209: u1 = undefined; + subborrowxU64(&x208, &x209, x207, x199, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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, 0x53bbf40939d54123); + var x11: u64 = undefined; + var x12: u1 = undefined; + subborrowxU64(&x11, &x12, x10, x3, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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 & 0x53bbf40939d54123)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0x7203df6b21c6052b)); + 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 & 0xfffffffeffffffff)); + 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 & 0x53bbf40939d54123)); + var x12: u64 = undefined; + var x13: u1 = undefined; + addcarryxU64(&x12, &x13, x11, x3, (x9 & 0x7203df6b21c6052b)); + 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 & 0xfffffffeffffffff)); + 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, 0x327f9e8872350975); + var x4: u64 = undefined; + var x5: u64 = undefined; + mulxU64(&x4, &x5, x2, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x10: u64 = undefined; + var x11: u64 = undefined; + mulxU64(&x10, &x11, x2, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x34: u64 = undefined; + var x35: u64 = undefined; + mulxU64(&x34, &x35, x32, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x40: u64 = undefined; + var x41: u64 = undefined; + mulxU64(&x40, &x41, x32, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x64: u64 = undefined; + var x65: u64 = undefined; + mulxU64(&x64, &x65, x62, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x70: u64 = undefined; + var x71: u64 = undefined; + mulxU64(&x70, &x71, x62, 0x53bbf40939d54123); + 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, 0x327f9e8872350975); + var x94: u64 = undefined; + var x95: u64 = undefined; + mulxU64(&x94, &x95, x92, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x100: u64 = undefined; + var x101: u64 = undefined; + mulxU64(&x100, &x101, x92, 0x53bbf40939d54123); + 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, 0x53bbf40939d54123); + var x119: u64 = undefined; + var x120: u1 = undefined; + subborrowxU64(&x119, &x120, x118, x112, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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, 0x1eb5e412a22b3d3b); + var x7: u64 = undefined; + var x8: u64 = undefined; + mulxU64(&x7, &x8, x4, 0x620fc84c3affe0d4); + var x9: u64 = undefined; + var x10: u64 = undefined; + mulxU64(&x9, &x10, x4, 0x3464504ade6fa2fa); + var x11: u64 = undefined; + var x12: u64 = undefined; + mulxU64(&x11, &x12, x4, 0x901192af7c114f20); + 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, 0x327f9e8872350975); + var x21: u64 = undefined; + var x22: u64 = undefined; + mulxU64(&x21, &x22, x19, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x27: u64 = undefined; + var x28: u64 = undefined; + mulxU64(&x27, &x28, x19, 0x53bbf40939d54123); + 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, 0x1eb5e412a22b3d3b); + var x47: u64 = undefined; + var x48: u64 = undefined; + mulxU64(&x47, &x48, x1, 0x620fc84c3affe0d4); + var x49: u64 = undefined; + var x50: u64 = undefined; + mulxU64(&x49, &x50, x1, 0x3464504ade6fa2fa); + var x51: u64 = undefined; + var x52: u64 = undefined; + mulxU64(&x51, &x52, x1, 0x901192af7c114f20); + 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, 0x327f9e8872350975); + var x69: u64 = undefined; + var x70: u64 = undefined; + mulxU64(&x69, &x70, x67, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x75: u64 = undefined; + var x76: u64 = undefined; + mulxU64(&x75, &x76, x67, 0x53bbf40939d54123); + 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, 0x1eb5e412a22b3d3b); + var x95: u64 = undefined; + var x96: u64 = undefined; + mulxU64(&x95, &x96, x2, 0x620fc84c3affe0d4); + var x97: u64 = undefined; + var x98: u64 = undefined; + mulxU64(&x97, &x98, x2, 0x3464504ade6fa2fa); + var x99: u64 = undefined; + var x100: u64 = undefined; + mulxU64(&x99, &x100, x2, 0x901192af7c114f20); + 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, 0x327f9e8872350975); + var x117: u64 = undefined; + var x118: u64 = undefined; + mulxU64(&x117, &x118, x115, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x123: u64 = undefined; + var x124: u64 = undefined; + mulxU64(&x123, &x124, x115, 0x53bbf40939d54123); + 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, 0x1eb5e412a22b3d3b); + var x143: u64 = undefined; + var x144: u64 = undefined; + mulxU64(&x143, &x144, x3, 0x620fc84c3affe0d4); + var x145: u64 = undefined; + var x146: u64 = undefined; + mulxU64(&x145, &x146, x3, 0x3464504ade6fa2fa); + var x147: u64 = undefined; + var x148: u64 = undefined; + mulxU64(&x147, &x148, x3, 0x901192af7c114f20); + 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, 0x327f9e8872350975); + var x165: u64 = undefined; + var x166: u64 = undefined; + mulxU64(&x165, &x166, x163, 0xfffffffeffffffff); + 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, 0x7203df6b21c6052b); + var x171: u64 = undefined; + var x172: u64 = undefined; + mulxU64(&x171, &x172, x163, 0x53bbf40939d54123); + 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, 0x53bbf40939d54123); + var x191: u64 = undefined; + var x192: u1 = undefined; + subborrowxU64(&x191, &x192, x190, x183, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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] = 0xac440bf6c62abedd; + out1[1] = 0x8dfc2094de39fad4; + out1[2] = cast(u64, 0x0); + out1[3] = 0x100000000; +} + +/// 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] = 0x53bbf40939d54123; + out1[1] = 0x7203df6b21c6052b; + out1[2] = 0xffffffffffffffff; + out1[3] = 0xfffffffeffffffff; + 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, 0x53bbf40939d54123); + var x41: u64 = undefined; + var x42: u1 = undefined; + subborrowxU64(&x41, &x42, x40, x33, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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 & 0x53bbf40939d54123)); + var x64: u64 = undefined; + var x65: u1 = undefined; + addcarryxU64(&x64, &x65, x63, x55, (x61 & 0x7203df6b21c6052b)); + 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 & 0xfffffffeffffffff)); + 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, 0x53bbf40939d54123); + var x104: u64 = undefined; + var x105: u1 = undefined; + subborrowxU64(&x104, &x105, x103, x96, 0x7203df6b21c6052b); + 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, 0xfffffffeffffffff); + 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] = 0x1aa32707b351756d; + out1[1] = 0xabdd671e2a62fa; + out1[2] = 0x49280d7dd4009a81; + out1[3] = 0xd730336ee6bb86e8; +}