p384_64.c

/* Autogenerated: 'src/ExtractionOCaml/bedrock2_word_by_word_montgomery' --lang bedrock2 --static --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select --no-field-element-typedefs p384 64 '2^384 - 2^128 - 2^96 + 2^32 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes one msat divstep divstep_precomp */
/* curve description: p384 */
/* 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 = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff (from "2^384 - 2^128 - 2^96 + 2^32 - 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) + (z[4] << 256) + (z[5] << 0x140) */
/*   bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */
/*   twos_complement_eval z = let x1 := z[0] + (z[1] << 64) + (z[2] << 128) + (z[3] << 192) + (z[4] << 256) + (z[5] << 0x140) in */
/*                            if x1 & (2^384-1) < 2^383 then x1 & (2^384-1) else (x1 & (2^384-1)) - 2^384 */

#include <stdint.h>
#include <string.h>

// We use memcpy to work around -fstrict-aliasing.
// A plain memcpy is enough on clang 10, but not on gcc 10, which fails
// to infer the bounds on an integer loaded by memcpy.
// Adding a range mask after memcpy in turn makes slower code in clang.
// Loading individual bytes, shifting them together, and or-ing is fast
// on clang and sometimes on GCC, but other times GCC inlines individual
// byte operations without reconstructing wider accesses.
// The little-endian idiom below seems fast in gcc 9+ and clang 10.
static __attribute__((always_inline)) inline uintptr_t
_br2_load(uintptr_t a, uintptr_t sz) {
  switch (sz) {
  case 1: { uint8_t  r = 0; memcpy(&r, (void*)a, 1); return r; }
  case 2: { uint16_t r = 0; memcpy(&r, (void*)a, 2); return r; }
  case 4: { uint32_t r = 0; memcpy(&r, (void*)a, 4); return r; }
  case 8: { uint64_t r = 0; memcpy(&r, (void*)a, 8); return r; }
  default: __builtin_unreachable();
  }
}

static __attribute__((always_inline)) inline void
_br2_store(uintptr_t a, uintptr_t v, uintptr_t sz) {
  memcpy((void*)a, &v, sz);
}


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

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_mul(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) {
  internal_fiat_p384_mul((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2);
}


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

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_square(uint64_t out1[6], const uint64_t arg1[6]) {
  internal_fiat_p384_square((uintptr_t)out1, (uintptr_t)arg1);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_add(uintptr_t out0, uintptr_t in0, uintptr_t in1) {
  uintptr_t x6, x0, x13, x1, x7, x15, x2, x8, x17, x3, x9, x19, x4, x10, x21, x5, x11, x25, x27, x29, x31, x23, x33, x12, x36, x24, x37, x14, x39, x26, x40, x16, x42, x28, x43, x18, x45, x30, x46, x20, x48, x32, x49, x35, x22, x51, x34, x52, x38, x41, x44, x47, x50, x53, x54, x55, x56, x57, x58, x59;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x12 = (x0)+(x6);
  x13 = ((uintptr_t)((x12)<(x0)))+(x1);
  x14 = (x13)+(x7);
  x15 = (((uintptr_t)((x13)<(x1)))+((uintptr_t)((x14)<(x7))))+(x2);
  x16 = (x15)+(x8);
  x17 = (((uintptr_t)((x15)<(x2)))+((uintptr_t)((x16)<(x8))))+(x3);
  x18 = (x17)+(x9);
  x19 = (((uintptr_t)((x17)<(x3)))+((uintptr_t)((x18)<(x9))))+(x4);
  x20 = (x19)+(x10);
  x21 = (((uintptr_t)((x19)<(x4)))+((uintptr_t)((x20)<(x10))))+(x5);
  x22 = (x21)+(x11);
  x23 = ((uintptr_t)((x21)<(x5)))+((uintptr_t)((x22)<(x11)));
  x24 = (x12)-((uintptr_t)4294967295ULL);
  x25 = (x14)-((uintptr_t)18446744069414584320ULL);
  x26 = (x25)-((uintptr_t)((x12)<(x24)));
  x27 = (x16)-((uintptr_t)18446744073709551614ULL);
  x28 = (x27)-(((uintptr_t)((x14)<(x25)))+((uintptr_t)((x25)<(x26))));
  x29 = (x18)-((uintptr_t)18446744073709551615ULL);
  x30 = (x29)-(((uintptr_t)((x16)<(x27)))+((uintptr_t)((x27)<(x28))));
  x31 = (x20)-((uintptr_t)18446744073709551615ULL);
  x32 = (x31)-(((uintptr_t)((x18)<(x29)))+((uintptr_t)((x29)<(x30))));
  x33 = (x22)-((uintptr_t)18446744073709551615ULL);
  x34 = (x33)-(((uintptr_t)((x20)<(x31)))+((uintptr_t)((x31)<(x32))));
  x35 = (uintptr_t)((x23)<((x23)-(((uintptr_t)((x22)<(x33)))+((uintptr_t)((x33)<(x34))))));
  x36 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL)));
  x37 = (x36)^((uintptr_t)18446744073709551615ULL);
  x38 = ((x12)&(x36))|((x24)&(x37));
  x39 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL)));
  x40 = (x39)^((uintptr_t)18446744073709551615ULL);
  x41 = ((x14)&(x39))|((x26)&(x40));
  x42 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL)));
  x43 = (x42)^((uintptr_t)18446744073709551615ULL);
  x44 = ((x16)&(x42))|((x28)&(x43));
  x45 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL)));
  x46 = (x45)^((uintptr_t)18446744073709551615ULL);
  x47 = ((x18)&(x45))|((x30)&(x46));
  x48 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL)));
  x49 = (x48)^((uintptr_t)18446744073709551615ULL);
  x50 = ((x20)&(x48))|((x32)&(x49));
  x51 = ((uintptr_t)-1ULL)+((uintptr_t)((x35)==((uintptr_t)0ULL)));
  x52 = (x51)^((uintptr_t)18446744073709551615ULL);
  x53 = ((x22)&(x51))|((x34)&(x52));
  x54 = x38;
  x55 = x41;
  x56 = x44;
  x57 = x47;
  x58 = x50;
  x59 = x53;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x54, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x55, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x56, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x57, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x58, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x59, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_add(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) {
  internal_fiat_p384_add((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_sub(uintptr_t out0, uintptr_t in0, uintptr_t in1) {
  uintptr_t x6, x7, x0, x8, x1, x13, x9, x2, x15, x10, x3, x17, x11, x4, x19, x5, x21, x12, x25, x14, x27, x16, x29, x18, x31, x20, x22, x23, x24, x26, x28, x30, x32, x33, x34, x35, x36, x37, x38, x39;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  x6 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x7 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x8 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x9 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x10 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x11 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x12 = (x0)-(x6);
  x13 = (x1)-(x7);
  x14 = (x13)-((uintptr_t)((x0)<(x12)));
  x15 = (x2)-(x8);
  x16 = (x15)-(((uintptr_t)((x1)<(x13)))+((uintptr_t)((x13)<(x14))));
  x17 = (x3)-(x9);
  x18 = (x17)-(((uintptr_t)((x2)<(x15)))+((uintptr_t)((x15)<(x16))));
  x19 = (x4)-(x10);
  x20 = (x19)-(((uintptr_t)((x3)<(x17)))+((uintptr_t)((x17)<(x18))));
  x21 = (x5)-(x11);
  x22 = (x21)-(((uintptr_t)((x4)<(x19)))+((uintptr_t)((x19)<(x20))));
  x23 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)((x5)<(x21)))+((uintptr_t)((x21)<(x22))))==((uintptr_t)0ULL)));
  x24 = (x12)+((x23)&((uintptr_t)4294967295ULL));
  x25 = ((uintptr_t)((x24)<(x12)))+(x14);
  x26 = (x25)+((x23)&((uintptr_t)18446744069414584320ULL));
  x27 = (((uintptr_t)((x25)<(x14)))+((uintptr_t)((x26)<((x23)&((uintptr_t)18446744069414584320ULL)))))+(x16);
  x28 = (x27)+((x23)&((uintptr_t)18446744073709551614ULL));
  x29 = (((uintptr_t)((x27)<(x16)))+((uintptr_t)((x28)<((x23)&((uintptr_t)18446744073709551614ULL)))))+(x18);
  x30 = (x29)+(x23);
  x31 = (((uintptr_t)((x29)<(x18)))+((uintptr_t)((x30)<(x23))))+(x20);
  x32 = (x31)+(x23);
  x33 = ((((uintptr_t)((x31)<(x20)))+((uintptr_t)((x32)<(x23))))+(x22))+(x23);
  x34 = x24;
  x35 = x26;
  x36 = x28;
  x37 = x30;
  x38 = x32;
  x39 = x33;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x34, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x35, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x36, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x37, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x38, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x39, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_sub(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) {
  internal_fiat_p384_sub((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_opp(uintptr_t out0, uintptr_t in0) {
  uintptr_t x0, x1, x2, x7, x3, x9, x4, x11, x5, x13, x15, x6, x19, x8, x21, x10, x23, x12, x25, x14, x16, x17, x18, x20, x22, x24, x26, x27, x28, x29, x30, x31, x32, x33;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x6 = ((uintptr_t)0ULL)-(x0);
  x7 = ((uintptr_t)0ULL)-(x1);
  x8 = (x7)-((uintptr_t)(((uintptr_t)0ULL)<(x6)));
  x9 = ((uintptr_t)0ULL)-(x2);
  x10 = (x9)-(((uintptr_t)(((uintptr_t)0ULL)<(x7)))+((uintptr_t)((x7)<(x8))));
  x11 = ((uintptr_t)0ULL)-(x3);
  x12 = (x11)-(((uintptr_t)(((uintptr_t)0ULL)<(x9)))+((uintptr_t)((x9)<(x10))));
  x13 = ((uintptr_t)0ULL)-(x4);
  x14 = (x13)-(((uintptr_t)(((uintptr_t)0ULL)<(x11)))+((uintptr_t)((x11)<(x12))));
  x15 = ((uintptr_t)0ULL)-(x5);
  x16 = (x15)-(((uintptr_t)(((uintptr_t)0ULL)<(x13)))+((uintptr_t)((x13)<(x14))));
  x17 = ((uintptr_t)-1ULL)+((uintptr_t)((((uintptr_t)(((uintptr_t)0ULL)<(x15)))+((uintptr_t)((x15)<(x16))))==((uintptr_t)0ULL)));
  x18 = (x6)+((x17)&((uintptr_t)4294967295ULL));
  x19 = ((uintptr_t)((x18)<(x6)))+(x8);
  x20 = (x19)+((x17)&((uintptr_t)18446744069414584320ULL));
  x21 = (((uintptr_t)((x19)<(x8)))+((uintptr_t)((x20)<((x17)&((uintptr_t)18446744069414584320ULL)))))+(x10);
  x22 = (x21)+((x17)&((uintptr_t)18446744073709551614ULL));
  x23 = (((uintptr_t)((x21)<(x10)))+((uintptr_t)((x22)<((x17)&((uintptr_t)18446744073709551614ULL)))))+(x12);
  x24 = (x23)+(x17);
  x25 = (((uintptr_t)((x23)<(x12)))+((uintptr_t)((x24)<(x17))))+(x14);
  x26 = (x25)+(x17);
  x27 = ((((uintptr_t)((x25)<(x14)))+((uintptr_t)((x26)<(x17))))+(x16))+(x17);
  x28 = x18;
  x29 = x20;
  x30 = x22;
  x31 = x24;
  x32 = x26;
  x33 = x27;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x28, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x29, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x30, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x31, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x32, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x33, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_opp(uint64_t out1[6], const uint64_t arg1[6]) {
  internal_fiat_p384_opp((uintptr_t)out1, (uintptr_t)arg1);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_from_montgomery(uintptr_t out0, uintptr_t in0) {
  uintptr_t x0, x17, x19, x16, x14, x21, x15, x12, x23, x13, x10, x25, x11, x8, x7, x6, x18, x20, x22, x24, x26, x27, x9, x1, x28, x29, x30, x31, x32, x33, x52, x54, x51, x49, x56, x50, x47, x58, x48, x45, x60, x46, x43, x42, x35, x63, x36, x53, x65, x37, x55, x67, x38, x57, x69, x39, x59, x71, x40, x61, x73, x41, x34, x62, x44, x2, x64, x66, x68, x70, x72, x74, x93, x95, x92, x90, x97, x91, x88, x99, x89, x86, x101, x87, x84, x83, x76, x104, x77, x94, x106, x78, x96, x108, x79, x98, x110, x80, x100, x112, x81, x102, x114, x82, x75, x103, x85, x3, x105, x107, x109, x111, x113, x115, x134, x136, x133, x131, x138, x132, x129, x140, x130, x127, x142, x128, x125, x124, x117, x145, x118, x135, x147, x119, x137, x149, x120, x139, x151, x121, x141, x153, x122, x143, x155, x123, x116, x144, x126, x4, x146, x148, x150, x152, x154, x156, x175, x177, x174, x172, x179, x173, x170, x181, x171, x168, x183, x169, x166, x165, x158, x186, x159, x176, x188, x160, x178, x190, x161, x180, x192, x162, x182, x194, x163, x184, x196, x164, x157, x185, x167, x5, x187, x189, x191, x193, x195, x197, x216, x218, x215, x213, x220, x214, x211, x222, x212, x209, x224, x210, x207, x206, x199, x227, x200, x217, x229, x201, x219, x231, x202, x221, x233, x203, x223, x235, x204, x225, x237, x205, x198, x226, x208, x241, x243, x245, x247, x239, x249, x228, x252, x240, x253, x230, x255, x242, x256, x232, x258, x244, x259, x234, x261, x246, x262, x236, x264, x248, x265, x251, x238, x267, x250, x268, x254, x257, x260, x263, x266, x269, x270, x271, x272, x273, x274, x275;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x6 = x0;
  x7 = (x6)*((uintptr_t)4294967297ULL);
  x8 = (x7)*((uintptr_t)18446744073709551615ULL);
  x9 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551615ULL))>>64);
  x10 = (x7)*((uintptr_t)18446744073709551615ULL);
  x11 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551615ULL))>>64);
  x12 = (x7)*((uintptr_t)18446744073709551615ULL);
  x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551615ULL))>>64);
  x14 = (x7)*((uintptr_t)18446744073709551614ULL);
  x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744073709551614ULL))>>64);
  x16 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744069414584320ULL))>>64);
  x17 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)4294967295ULL))>>64);
  x18 = (x17)+((x7)*((uintptr_t)18446744069414584320ULL));
  x19 = ((uintptr_t)((x18)<(x17)))+(x16);
  x20 = (x19)+(x14);
  x21 = (((uintptr_t)((x19)<(x16)))+((uintptr_t)((x20)<(x14))))+(x15);
  x22 = (x21)+(x12);
  x23 = (((uintptr_t)((x21)<(x15)))+((uintptr_t)((x22)<(x12))))+(x13);
  x24 = (x23)+(x10);
  x25 = (((uintptr_t)((x23)<(x13)))+((uintptr_t)((x24)<(x10))))+(x11);
  x26 = (x25)+(x8);
  x27 = ((uintptr_t)((x25)<(x11)))+((uintptr_t)((x26)<(x8)));
  x28 = ((uintptr_t)(((x6)+((x7)*((uintptr_t)4294967295ULL)))<(x6)))+(x18);
  x29 = ((uintptr_t)((x28)<(x18)))+(x20);
  x30 = ((uintptr_t)((x29)<(x20)))+(x22);
  x31 = ((uintptr_t)((x30)<(x22)))+(x24);
  x32 = ((uintptr_t)((x31)<(x24)))+(x26);
  x33 = ((uintptr_t)((x32)<(x26)))+((x27)+(x9));
  x34 = (uintptr_t)((x33)<((x27)+(x9)));
  x35 = (x28)+(x1);
  x36 = ((uintptr_t)((x35)<(x28)))+(x29);
  x37 = ((uintptr_t)((x36)<(x29)))+(x30);
  x38 = ((uintptr_t)((x37)<(x30)))+(x31);
  x39 = ((uintptr_t)((x38)<(x31)))+(x32);
  x40 = ((uintptr_t)((x39)<(x32)))+(x33);
  x41 = (uintptr_t)((x40)<(x33));
  x42 = (x35)*((uintptr_t)4294967297ULL);
  x43 = (x42)*((uintptr_t)18446744073709551615ULL);
  x44 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551615ULL))>>64);
  x45 = (x42)*((uintptr_t)18446744073709551615ULL);
  x46 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551615ULL))>>64);
  x47 = (x42)*((uintptr_t)18446744073709551615ULL);
  x48 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551615ULL))>>64);
  x49 = (x42)*((uintptr_t)18446744073709551614ULL);
  x50 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744073709551614ULL))>>64);
  x51 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)18446744069414584320ULL))>>64);
  x52 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x42)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x42)*((uintptr_t)4294967295ULL))>>64);
  x53 = (x52)+((x42)*((uintptr_t)18446744069414584320ULL));
  x54 = ((uintptr_t)((x53)<(x52)))+(x51);
  x55 = (x54)+(x49);
  x56 = (((uintptr_t)((x54)<(x51)))+((uintptr_t)((x55)<(x49))))+(x50);
  x57 = (x56)+(x47);
  x58 = (((uintptr_t)((x56)<(x50)))+((uintptr_t)((x57)<(x47))))+(x48);
  x59 = (x58)+(x45);
  x60 = (((uintptr_t)((x58)<(x48)))+((uintptr_t)((x59)<(x45))))+(x46);
  x61 = (x60)+(x43);
  x62 = ((uintptr_t)((x60)<(x46)))+((uintptr_t)((x61)<(x43)));
  x63 = ((uintptr_t)(((x35)+((x42)*((uintptr_t)4294967295ULL)))<(x35)))+(x36);
  x64 = (x63)+(x53);
  x65 = (((uintptr_t)((x63)<(x36)))+((uintptr_t)((x64)<(x53))))+(x37);
  x66 = (x65)+(x55);
  x67 = (((uintptr_t)((x65)<(x37)))+((uintptr_t)((x66)<(x55))))+(x38);
  x68 = (x67)+(x57);
  x69 = (((uintptr_t)((x67)<(x38)))+((uintptr_t)((x68)<(x57))))+(x39);
  x70 = (x69)+(x59);
  x71 = (((uintptr_t)((x69)<(x39)))+((uintptr_t)((x70)<(x59))))+(x40);
  x72 = (x71)+(x61);
  x73 = (((uintptr_t)((x71)<(x40)))+((uintptr_t)((x72)<(x61))))+((x41)+(x34));
  x74 = (x73)+((x62)+(x44));
  x75 = ((uintptr_t)((x73)<((x41)+(x34))))+((uintptr_t)((x74)<((x62)+(x44))));
  x76 = (x64)+(x2);
  x77 = ((uintptr_t)((x76)<(x64)))+(x66);
  x78 = ((uintptr_t)((x77)<(x66)))+(x68);
  x79 = ((uintptr_t)((x78)<(x68)))+(x70);
  x80 = ((uintptr_t)((x79)<(x70)))+(x72);
  x81 = ((uintptr_t)((x80)<(x72)))+(x74);
  x82 = (uintptr_t)((x81)<(x74));
  x83 = (x76)*((uintptr_t)4294967297ULL);
  x84 = (x83)*((uintptr_t)18446744073709551615ULL);
  x85 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551615ULL))>>64);
  x86 = (x83)*((uintptr_t)18446744073709551615ULL);
  x87 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551615ULL))>>64);
  x88 = (x83)*((uintptr_t)18446744073709551615ULL);
  x89 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551615ULL))>>64);
  x90 = (x83)*((uintptr_t)18446744073709551614ULL);
  x91 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744073709551614ULL))>>64);
  x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)18446744069414584320ULL))>>64);
  x93 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x83)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x83)*((uintptr_t)4294967295ULL))>>64);
  x94 = (x93)+((x83)*((uintptr_t)18446744069414584320ULL));
  x95 = ((uintptr_t)((x94)<(x93)))+(x92);
  x96 = (x95)+(x90);
  x97 = (((uintptr_t)((x95)<(x92)))+((uintptr_t)((x96)<(x90))))+(x91);
  x98 = (x97)+(x88);
  x99 = (((uintptr_t)((x97)<(x91)))+((uintptr_t)((x98)<(x88))))+(x89);
  x100 = (x99)+(x86);
  x101 = (((uintptr_t)((x99)<(x89)))+((uintptr_t)((x100)<(x86))))+(x87);
  x102 = (x101)+(x84);
  x103 = ((uintptr_t)((x101)<(x87)))+((uintptr_t)((x102)<(x84)));
  x104 = ((uintptr_t)(((x76)+((x83)*((uintptr_t)4294967295ULL)))<(x76)))+(x77);
  x105 = (x104)+(x94);
  x106 = (((uintptr_t)((x104)<(x77)))+((uintptr_t)((x105)<(x94))))+(x78);
  x107 = (x106)+(x96);
  x108 = (((uintptr_t)((x106)<(x78)))+((uintptr_t)((x107)<(x96))))+(x79);
  x109 = (x108)+(x98);
  x110 = (((uintptr_t)((x108)<(x79)))+((uintptr_t)((x109)<(x98))))+(x80);
  x111 = (x110)+(x100);
  x112 = (((uintptr_t)((x110)<(x80)))+((uintptr_t)((x111)<(x100))))+(x81);
  x113 = (x112)+(x102);
  x114 = (((uintptr_t)((x112)<(x81)))+((uintptr_t)((x113)<(x102))))+((x82)+(x75));
  x115 = (x114)+((x103)+(x85));
  x116 = ((uintptr_t)((x114)<((x82)+(x75))))+((uintptr_t)((x115)<((x103)+(x85))));
  x117 = (x105)+(x3);
  x118 = ((uintptr_t)((x117)<(x105)))+(x107);
  x119 = ((uintptr_t)((x118)<(x107)))+(x109);
  x120 = ((uintptr_t)((x119)<(x109)))+(x111);
  x121 = ((uintptr_t)((x120)<(x111)))+(x113);
  x122 = ((uintptr_t)((x121)<(x113)))+(x115);
  x123 = (uintptr_t)((x122)<(x115));
  x124 = (x117)*((uintptr_t)4294967297ULL);
  x125 = (x124)*((uintptr_t)18446744073709551615ULL);
  x126 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551615ULL))>>64);
  x127 = (x124)*((uintptr_t)18446744073709551615ULL);
  x128 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551615ULL))>>64);
  x129 = (x124)*((uintptr_t)18446744073709551615ULL);
  x130 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551615ULL))>>64);
  x131 = (x124)*((uintptr_t)18446744073709551614ULL);
  x132 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744073709551614ULL))>>64);
  x133 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)18446744069414584320ULL))>>64);
  x134 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x124)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x124)*((uintptr_t)4294967295ULL))>>64);
  x135 = (x134)+((x124)*((uintptr_t)18446744069414584320ULL));
  x136 = ((uintptr_t)((x135)<(x134)))+(x133);
  x137 = (x136)+(x131);
  x138 = (((uintptr_t)((x136)<(x133)))+((uintptr_t)((x137)<(x131))))+(x132);
  x139 = (x138)+(x129);
  x140 = (((uintptr_t)((x138)<(x132)))+((uintptr_t)((x139)<(x129))))+(x130);
  x141 = (x140)+(x127);
  x142 = (((uintptr_t)((x140)<(x130)))+((uintptr_t)((x141)<(x127))))+(x128);
  x143 = (x142)+(x125);
  x144 = ((uintptr_t)((x142)<(x128)))+((uintptr_t)((x143)<(x125)));
  x145 = ((uintptr_t)(((x117)+((x124)*((uintptr_t)4294967295ULL)))<(x117)))+(x118);
  x146 = (x145)+(x135);
  x147 = (((uintptr_t)((x145)<(x118)))+((uintptr_t)((x146)<(x135))))+(x119);
  x148 = (x147)+(x137);
  x149 = (((uintptr_t)((x147)<(x119)))+((uintptr_t)((x148)<(x137))))+(x120);
  x150 = (x149)+(x139);
  x151 = (((uintptr_t)((x149)<(x120)))+((uintptr_t)((x150)<(x139))))+(x121);
  x152 = (x151)+(x141);
  x153 = (((uintptr_t)((x151)<(x121)))+((uintptr_t)((x152)<(x141))))+(x122);
  x154 = (x153)+(x143);
  x155 = (((uintptr_t)((x153)<(x122)))+((uintptr_t)((x154)<(x143))))+((x123)+(x116));
  x156 = (x155)+((x144)+(x126));
  x157 = ((uintptr_t)((x155)<((x123)+(x116))))+((uintptr_t)((x156)<((x144)+(x126))));
  x158 = (x146)+(x4);
  x159 = ((uintptr_t)((x158)<(x146)))+(x148);
  x160 = ((uintptr_t)((x159)<(x148)))+(x150);
  x161 = ((uintptr_t)((x160)<(x150)))+(x152);
  x162 = ((uintptr_t)((x161)<(x152)))+(x154);
  x163 = ((uintptr_t)((x162)<(x154)))+(x156);
  x164 = (uintptr_t)((x163)<(x156));
  x165 = (x158)*((uintptr_t)4294967297ULL);
  x166 = (x165)*((uintptr_t)18446744073709551615ULL);
  x167 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64);
  x168 = (x165)*((uintptr_t)18446744073709551615ULL);
  x169 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64);
  x170 = (x165)*((uintptr_t)18446744073709551615ULL);
  x171 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551615ULL))>>64);
  x172 = (x165)*((uintptr_t)18446744073709551614ULL);
  x173 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744073709551614ULL))>>64);
  x174 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)18446744069414584320ULL))>>64);
  x175 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x165)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x165)*((uintptr_t)4294967295ULL))>>64);
  x176 = (x175)+((x165)*((uintptr_t)18446744069414584320ULL));
  x177 = ((uintptr_t)((x176)<(x175)))+(x174);
  x178 = (x177)+(x172);
  x179 = (((uintptr_t)((x177)<(x174)))+((uintptr_t)((x178)<(x172))))+(x173);
  x180 = (x179)+(x170);
  x181 = (((uintptr_t)((x179)<(x173)))+((uintptr_t)((x180)<(x170))))+(x171);
  x182 = (x181)+(x168);
  x183 = (((uintptr_t)((x181)<(x171)))+((uintptr_t)((x182)<(x168))))+(x169);
  x184 = (x183)+(x166);
  x185 = ((uintptr_t)((x183)<(x169)))+((uintptr_t)((x184)<(x166)));
  x186 = ((uintptr_t)(((x158)+((x165)*((uintptr_t)4294967295ULL)))<(x158)))+(x159);
  x187 = (x186)+(x176);
  x188 = (((uintptr_t)((x186)<(x159)))+((uintptr_t)((x187)<(x176))))+(x160);
  x189 = (x188)+(x178);
  x190 = (((uintptr_t)((x188)<(x160)))+((uintptr_t)((x189)<(x178))))+(x161);
  x191 = (x190)+(x180);
  x192 = (((uintptr_t)((x190)<(x161)))+((uintptr_t)((x191)<(x180))))+(x162);
  x193 = (x192)+(x182);
  x194 = (((uintptr_t)((x192)<(x162)))+((uintptr_t)((x193)<(x182))))+(x163);
  x195 = (x194)+(x184);
  x196 = (((uintptr_t)((x194)<(x163)))+((uintptr_t)((x195)<(x184))))+((x164)+(x157));
  x197 = (x196)+((x185)+(x167));
  x198 = ((uintptr_t)((x196)<((x164)+(x157))))+((uintptr_t)((x197)<((x185)+(x167))));
  x199 = (x187)+(x5);
  x200 = ((uintptr_t)((x199)<(x187)))+(x189);
  x201 = ((uintptr_t)((x200)<(x189)))+(x191);
  x202 = ((uintptr_t)((x201)<(x191)))+(x193);
  x203 = ((uintptr_t)((x202)<(x193)))+(x195);
  x204 = ((uintptr_t)((x203)<(x195)))+(x197);
  x205 = (uintptr_t)((x204)<(x197));
  x206 = (x199)*((uintptr_t)4294967297ULL);
  x207 = (x206)*((uintptr_t)18446744073709551615ULL);
  x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64);
  x209 = (x206)*((uintptr_t)18446744073709551615ULL);
  x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64);
  x211 = (x206)*((uintptr_t)18446744073709551615ULL);
  x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64);
  x213 = (x206)*((uintptr_t)18446744073709551614ULL);
  x214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551614ULL))>>64);
  x215 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744069414584320ULL))>>64);
  x216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)4294967295ULL))>>64);
  x217 = (x216)+((x206)*((uintptr_t)18446744069414584320ULL));
  x218 = ((uintptr_t)((x217)<(x216)))+(x215);
  x219 = (x218)+(x213);
  x220 = (((uintptr_t)((x218)<(x215)))+((uintptr_t)((x219)<(x213))))+(x214);
  x221 = (x220)+(x211);
  x222 = (((uintptr_t)((x220)<(x214)))+((uintptr_t)((x221)<(x211))))+(x212);
  x223 = (x222)+(x209);
  x224 = (((uintptr_t)((x222)<(x212)))+((uintptr_t)((x223)<(x209))))+(x210);
  x225 = (x224)+(x207);
  x226 = ((uintptr_t)((x224)<(x210)))+((uintptr_t)((x225)<(x207)));
  x227 = ((uintptr_t)(((x199)+((x206)*((uintptr_t)4294967295ULL)))<(x199)))+(x200);
  x228 = (x227)+(x217);
  x229 = (((uintptr_t)((x227)<(x200)))+((uintptr_t)((x228)<(x217))))+(x201);
  x230 = (x229)+(x219);
  x231 = (((uintptr_t)((x229)<(x201)))+((uintptr_t)((x230)<(x219))))+(x202);
  x232 = (x231)+(x221);
  x233 = (((uintptr_t)((x231)<(x202)))+((uintptr_t)((x232)<(x221))))+(x203);
  x234 = (x233)+(x223);
  x235 = (((uintptr_t)((x233)<(x203)))+((uintptr_t)((x234)<(x223))))+(x204);
  x236 = (x235)+(x225);
  x237 = (((uintptr_t)((x235)<(x204)))+((uintptr_t)((x236)<(x225))))+((x205)+(x198));
  x238 = (x237)+((x226)+(x208));
  x239 = ((uintptr_t)((x237)<((x205)+(x198))))+((uintptr_t)((x238)<((x226)+(x208))));
  x240 = (x228)-((uintptr_t)4294967295ULL);
  x241 = (x230)-((uintptr_t)18446744069414584320ULL);
  x242 = (x241)-((uintptr_t)((x228)<(x240)));
  x243 = (x232)-((uintptr_t)18446744073709551614ULL);
  x244 = (x243)-(((uintptr_t)((x230)<(x241)))+((uintptr_t)((x241)<(x242))));
  x245 = (x234)-((uintptr_t)18446744073709551615ULL);
  x246 = (x245)-(((uintptr_t)((x232)<(x243)))+((uintptr_t)((x243)<(x244))));
  x247 = (x236)-((uintptr_t)18446744073709551615ULL);
  x248 = (x247)-(((uintptr_t)((x234)<(x245)))+((uintptr_t)((x245)<(x246))));
  x249 = (x238)-((uintptr_t)18446744073709551615ULL);
  x250 = (x249)-(((uintptr_t)((x236)<(x247)))+((uintptr_t)((x247)<(x248))));
  x251 = (uintptr_t)((x239)<((x239)-(((uintptr_t)((x238)<(x249)))+((uintptr_t)((x249)<(x250))))));
  x252 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL)));
  x253 = (x252)^((uintptr_t)18446744073709551615ULL);
  x254 = ((x228)&(x252))|((x240)&(x253));
  x255 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL)));
  x256 = (x255)^((uintptr_t)18446744073709551615ULL);
  x257 = ((x230)&(x255))|((x242)&(x256));
  x258 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL)));
  x259 = (x258)^((uintptr_t)18446744073709551615ULL);
  x260 = ((x232)&(x258))|((x244)&(x259));
  x261 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL)));
  x262 = (x261)^((uintptr_t)18446744073709551615ULL);
  x263 = ((x234)&(x261))|((x246)&(x262));
  x264 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL)));
  x265 = (x264)^((uintptr_t)18446744073709551615ULL);
  x266 = ((x236)&(x264))|((x248)&(x265));
  x267 = ((uintptr_t)-1ULL)+((uintptr_t)((x251)==((uintptr_t)0ULL)));
  x268 = (x267)^((uintptr_t)18446744073709551615ULL);
  x269 = ((x238)&(x267))|((x250)&(x268));
  x270 = x254;
  x271 = x257;
  x272 = x260;
  x273 = x263;
  x274 = x266;
  x275 = x269;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x270, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x271, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x272, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x273, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x274, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x275, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_from_montgomery(uint64_t out1[6], const uint64_t arg1[6]) {
  internal_fiat_p384_from_montgomery((uintptr_t)out1, (uintptr_t)arg1);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_to_montgomery(uintptr_t out0, uintptr_t in0) {
  uintptr_t x1, x2, x3, x4, x5, x0, x18, x20, x16, x14, x22, x15, x12, x24, x13, x11, x37, x39, x36, x34, x41, x35, x32, x43, x33, x30, x45, x31, x28, x27, x17, x48, x19, x38, x50, x21, x40, x52, x23, x42, x54, x25, x44, x56, x26, x46, x47, x29, x65, x67, x64, x62, x69, x63, x60, x71, x61, x6, x49, x75, x51, x66, x77, x53, x68, x79, x55, x70, x81, x57, x72, x83, x58, x73, x96, x98, x95, x93, x100, x94, x91, x102, x92, x89, x104, x90, x87, x86, x74, x107, x76, x97, x109, x78, x99, x111, x80, x101, x113, x82, x103, x115, x84, x105, x117, x85, x59, x106, x88, x125, x127, x124, x122, x129, x123, x120, x131, x121, x7, x108, x135, x110, x126, x137, x112, x128, x139, x114, x130, x141, x116, x132, x143, x118, x133, x156, x158, x155, x153, x160, x154, x151, x162, x152, x149, x164, x150, x147, x146, x134, x167, x136, x157, x169, x138, x159, x171, x140, x161, x173, x142, x163, x175, x144, x165, x177, x145, x119, x166, x148, x185, x187, x184, x182, x189, x183, x180, x191, x181, x8, x168, x195, x170, x186, x197, x172, x188, x199, x174, x190, x201, x176, x192, x203, x178, x193, x216, x218, x215, x213, x220, x214, x211, x222, x212, x209, x224, x210, x207, x206, x194, x227, x196, x217, x229, x198, x219, x231, x200, x221, x233, x202, x223, x235, x204, x225, x237, x205, x179, x226, x208, x245, x247, x244, x242, x249, x243, x240, x251, x241, x9, x228, x255, x230, x246, x257, x232, x248, x259, x234, x250, x261, x236, x252, x263, x238, x253, x276, x278, x275, x273, x280, x274, x271, x282, x272, x269, x284, x270, x267, x266, x254, x287, x256, x277, x289, x258, x279, x291, x260, x281, x293, x262, x283, x295, x264, x285, x297, x265, x239, x286, x268, x305, x307, x304, x302, x309, x303, x300, x311, x301, x10, x288, x315, x290, x306, x317, x292, x308, x319, x294, x310, x321, x296, x312, x323, x298, x313, x336, x338, x335, x333, x340, x334, x331, x342, x332, x329, x344, x330, x327, x326, x314, x347, x316, x337, x349, x318, x339, x351, x320, x341, x353, x322, x343, x355, x324, x345, x357, x325, x299, x346, x328, x361, x363, x365, x367, x359, x369, x348, x372, x360, x373, x350, x375, x362, x376, x352, x378, x364, x379, x354, x381, x366, x382, x356, x384, x368, x385, x371, x358, x387, x370, x388, x374, x377, x380, x383, x386, x389, x390, x391, x392, x393, x394, x395;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x6 = x1;
  x7 = x2;
  x8 = x3;
  x9 = x4;
  x10 = x5;
  x11 = x0;
  x12 = (x11)*((uintptr_t)8589934592ULL);
  x13 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)8589934592ULL))>>64);
  x14 = (x11)*((uintptr_t)18446744065119617024ULL);
  x15 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)18446744065119617024ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)18446744065119617024ULL))>>64);
  x16 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)8589934592ULL))>>64);
  x17 = (x11)*((uintptr_t)18446744065119617025ULL);
  x18 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x11)*((uintptr_t)18446744065119617025ULL))>>32 : ((__uint128_t)(x11)*((uintptr_t)18446744065119617025ULL))>>64);
  x19 = (x18)+((x11)*((uintptr_t)8589934592ULL));
  x20 = ((uintptr_t)((x19)<(x18)))+(x16);
  x21 = (x20)+(x14);
  x22 = (((uintptr_t)((x20)<(x16)))+((uintptr_t)((x21)<(x14))))+(x15);
  x23 = (x22)+(x12);
  x24 = (((uintptr_t)((x22)<(x15)))+((uintptr_t)((x23)<(x12))))+(x13);
  x25 = (x24)+(x11);
  x26 = ((uintptr_t)((x24)<(x13)))+((uintptr_t)((x25)<(x11)));
  x27 = (x17)*((uintptr_t)4294967297ULL);
  x28 = (x27)*((uintptr_t)18446744073709551615ULL);
  x29 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x27)*((uintptr_t)18446744073709551615ULL))>>64);
  x30 = (x27)*((uintptr_t)18446744073709551615ULL);
  x31 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x27)*((uintptr_t)18446744073709551615ULL))>>64);
  x32 = (x27)*((uintptr_t)18446744073709551615ULL);
  x33 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x27)*((uintptr_t)18446744073709551615ULL))>>64);
  x34 = (x27)*((uintptr_t)18446744073709551614ULL);
  x35 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x27)*((uintptr_t)18446744073709551614ULL))>>64);
  x36 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x27)*((uintptr_t)18446744069414584320ULL))>>64);
  x37 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x27)*((uintptr_t)4294967295ULL))>>64);
  x38 = (x37)+((x27)*((uintptr_t)18446744069414584320ULL));
  x39 = ((uintptr_t)((x38)<(x37)))+(x36);
  x40 = (x39)+(x34);
  x41 = (((uintptr_t)((x39)<(x36)))+((uintptr_t)((x40)<(x34))))+(x35);
  x42 = (x41)+(x32);
  x43 = (((uintptr_t)((x41)<(x35)))+((uintptr_t)((x42)<(x32))))+(x33);
  x44 = (x43)+(x30);
  x45 = (((uintptr_t)((x43)<(x33)))+((uintptr_t)((x44)<(x30))))+(x31);
  x46 = (x45)+(x28);
  x47 = ((uintptr_t)((x45)<(x31)))+((uintptr_t)((x46)<(x28)));
  x48 = ((uintptr_t)(((x17)+((x27)*((uintptr_t)4294967295ULL)))<(x17)))+(x19);
  x49 = (x48)+(x38);
  x50 = (((uintptr_t)((x48)<(x19)))+((uintptr_t)((x49)<(x38))))+(x21);
  x51 = (x50)+(x40);
  x52 = (((uintptr_t)((x50)<(x21)))+((uintptr_t)((x51)<(x40))))+(x23);
  x53 = (x52)+(x42);
  x54 = (((uintptr_t)((x52)<(x23)))+((uintptr_t)((x53)<(x42))))+(x25);
  x55 = (x54)+(x44);
  x56 = (((uintptr_t)((x54)<(x25)))+((uintptr_t)((x55)<(x44))))+(x26);
  x57 = (x56)+(x46);
  x58 = (((uintptr_t)((x56)<(x26)))+((uintptr_t)((x57)<(x46))))+((x47)+(x29));
  x59 = (uintptr_t)((x58)<((x47)+(x29)));
  x60 = (x6)*((uintptr_t)8589934592ULL);
  x61 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)8589934592ULL))>>64);
  x62 = (x6)*((uintptr_t)18446744065119617024ULL);
  x63 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)18446744065119617024ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)18446744065119617024ULL))>>64);
  x64 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)8589934592ULL))>>64);
  x65 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x6)*((uintptr_t)18446744065119617025ULL))>>32 : ((__uint128_t)(x6)*((uintptr_t)18446744065119617025ULL))>>64);
  x66 = (x65)+((x6)*((uintptr_t)8589934592ULL));
  x67 = ((uintptr_t)((x66)<(x65)))+(x64);
  x68 = (x67)+(x62);
  x69 = (((uintptr_t)((x67)<(x64)))+((uintptr_t)((x68)<(x62))))+(x63);
  x70 = (x69)+(x60);
  x71 = (((uintptr_t)((x69)<(x63)))+((uintptr_t)((x70)<(x60))))+(x61);
  x72 = (x71)+(x6);
  x73 = ((uintptr_t)((x71)<(x61)))+((uintptr_t)((x72)<(x6)));
  x74 = (x49)+((x6)*((uintptr_t)18446744065119617025ULL));
  x75 = ((uintptr_t)((x74)<(x49)))+(x51);
  x76 = (x75)+(x66);
  x77 = (((uintptr_t)((x75)<(x51)))+((uintptr_t)((x76)<(x66))))+(x53);
  x78 = (x77)+(x68);
  x79 = (((uintptr_t)((x77)<(x53)))+((uintptr_t)((x78)<(x68))))+(x55);
  x80 = (x79)+(x70);
  x81 = (((uintptr_t)((x79)<(x55)))+((uintptr_t)((x80)<(x70))))+(x57);
  x82 = (x81)+(x72);
  x83 = (((uintptr_t)((x81)<(x57)))+((uintptr_t)((x82)<(x72))))+(x58);
  x84 = (x83)+(x73);
  x85 = ((uintptr_t)((x83)<(x58)))+((uintptr_t)((x84)<(x73)));
  x86 = (x74)*((uintptr_t)4294967297ULL);
  x87 = (x86)*((uintptr_t)18446744073709551615ULL);
  x88 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)18446744073709551615ULL))>>64);
  x89 = (x86)*((uintptr_t)18446744073709551615ULL);
  x90 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)18446744073709551615ULL))>>64);
  x91 = (x86)*((uintptr_t)18446744073709551615ULL);
  x92 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)18446744073709551615ULL))>>64);
  x93 = (x86)*((uintptr_t)18446744073709551614ULL);
  x94 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)18446744073709551614ULL))>>64);
  x95 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)18446744069414584320ULL))>>64);
  x96 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x86)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x86)*((uintptr_t)4294967295ULL))>>64);
  x97 = (x96)+((x86)*((uintptr_t)18446744069414584320ULL));
  x98 = ((uintptr_t)((x97)<(x96)))+(x95);
  x99 = (x98)+(x93);
  x100 = (((uintptr_t)((x98)<(x95)))+((uintptr_t)((x99)<(x93))))+(x94);
  x101 = (x100)+(x91);
  x102 = (((uintptr_t)((x100)<(x94)))+((uintptr_t)((x101)<(x91))))+(x92);
  x103 = (x102)+(x89);
  x104 = (((uintptr_t)((x102)<(x92)))+((uintptr_t)((x103)<(x89))))+(x90);
  x105 = (x104)+(x87);
  x106 = ((uintptr_t)((x104)<(x90)))+((uintptr_t)((x105)<(x87)));
  x107 = ((uintptr_t)(((x74)+((x86)*((uintptr_t)4294967295ULL)))<(x74)))+(x76);
  x108 = (x107)+(x97);
  x109 = (((uintptr_t)((x107)<(x76)))+((uintptr_t)((x108)<(x97))))+(x78);
  x110 = (x109)+(x99);
  x111 = (((uintptr_t)((x109)<(x78)))+((uintptr_t)((x110)<(x99))))+(x80);
  x112 = (x111)+(x101);
  x113 = (((uintptr_t)((x111)<(x80)))+((uintptr_t)((x112)<(x101))))+(x82);
  x114 = (x113)+(x103);
  x115 = (((uintptr_t)((x113)<(x82)))+((uintptr_t)((x114)<(x103))))+(x84);
  x116 = (x115)+(x105);
  x117 = (((uintptr_t)((x115)<(x84)))+((uintptr_t)((x116)<(x105))))+((x85)+(x59));
  x118 = (x117)+((x106)+(x88));
  x119 = ((uintptr_t)((x117)<((x85)+(x59))))+((uintptr_t)((x118)<((x106)+(x88))));
  x120 = (x7)*((uintptr_t)8589934592ULL);
  x121 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)8589934592ULL))>>64);
  x122 = (x7)*((uintptr_t)18446744065119617024ULL);
  x123 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744065119617024ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744065119617024ULL))>>64);
  x124 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)8589934592ULL))>>64);
  x125 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x7)*((uintptr_t)18446744065119617025ULL))>>32 : ((__uint128_t)(x7)*((uintptr_t)18446744065119617025ULL))>>64);
  x126 = (x125)+((x7)*((uintptr_t)8589934592ULL));
  x127 = ((uintptr_t)((x126)<(x125)))+(x124);
  x128 = (x127)+(x122);
  x129 = (((uintptr_t)((x127)<(x124)))+((uintptr_t)((x128)<(x122))))+(x123);
  x130 = (x129)+(x120);
  x131 = (((uintptr_t)((x129)<(x123)))+((uintptr_t)((x130)<(x120))))+(x121);
  x132 = (x131)+(x7);
  x133 = ((uintptr_t)((x131)<(x121)))+((uintptr_t)((x132)<(x7)));
  x134 = (x108)+((x7)*((uintptr_t)18446744065119617025ULL));
  x135 = ((uintptr_t)((x134)<(x108)))+(x110);
  x136 = (x135)+(x126);
  x137 = (((uintptr_t)((x135)<(x110)))+((uintptr_t)((x136)<(x126))))+(x112);
  x138 = (x137)+(x128);
  x139 = (((uintptr_t)((x137)<(x112)))+((uintptr_t)((x138)<(x128))))+(x114);
  x140 = (x139)+(x130);
  x141 = (((uintptr_t)((x139)<(x114)))+((uintptr_t)((x140)<(x130))))+(x116);
  x142 = (x141)+(x132);
  x143 = (((uintptr_t)((x141)<(x116)))+((uintptr_t)((x142)<(x132))))+(x118);
  x144 = (x143)+(x133);
  x145 = ((uintptr_t)((x143)<(x118)))+((uintptr_t)((x144)<(x133)));
  x146 = (x134)*((uintptr_t)4294967297ULL);
  x147 = (x146)*((uintptr_t)18446744073709551615ULL);
  x148 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x146)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x146)*((uintptr_t)18446744073709551615ULL))>>64);
  x149 = (x146)*((uintptr_t)18446744073709551615ULL);
  x150 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x146)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x146)*((uintptr_t)18446744073709551615ULL))>>64);
  x151 = (x146)*((uintptr_t)18446744073709551615ULL);
  x152 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x146)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x146)*((uintptr_t)18446744073709551615ULL))>>64);
  x153 = (x146)*((uintptr_t)18446744073709551614ULL);
  x154 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x146)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x146)*((uintptr_t)18446744073709551614ULL))>>64);
  x155 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x146)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x146)*((uintptr_t)18446744069414584320ULL))>>64);
  x156 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x146)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x146)*((uintptr_t)4294967295ULL))>>64);
  x157 = (x156)+((x146)*((uintptr_t)18446744069414584320ULL));
  x158 = ((uintptr_t)((x157)<(x156)))+(x155);
  x159 = (x158)+(x153);
  x160 = (((uintptr_t)((x158)<(x155)))+((uintptr_t)((x159)<(x153))))+(x154);
  x161 = (x160)+(x151);
  x162 = (((uintptr_t)((x160)<(x154)))+((uintptr_t)((x161)<(x151))))+(x152);
  x163 = (x162)+(x149);
  x164 = (((uintptr_t)((x162)<(x152)))+((uintptr_t)((x163)<(x149))))+(x150);
  x165 = (x164)+(x147);
  x166 = ((uintptr_t)((x164)<(x150)))+((uintptr_t)((x165)<(x147)));
  x167 = ((uintptr_t)(((x134)+((x146)*((uintptr_t)4294967295ULL)))<(x134)))+(x136);
  x168 = (x167)+(x157);
  x169 = (((uintptr_t)((x167)<(x136)))+((uintptr_t)((x168)<(x157))))+(x138);
  x170 = (x169)+(x159);
  x171 = (((uintptr_t)((x169)<(x138)))+((uintptr_t)((x170)<(x159))))+(x140);
  x172 = (x171)+(x161);
  x173 = (((uintptr_t)((x171)<(x140)))+((uintptr_t)((x172)<(x161))))+(x142);
  x174 = (x173)+(x163);
  x175 = (((uintptr_t)((x173)<(x142)))+((uintptr_t)((x174)<(x163))))+(x144);
  x176 = (x175)+(x165);
  x177 = (((uintptr_t)((x175)<(x144)))+((uintptr_t)((x176)<(x165))))+((x145)+(x119));
  x178 = (x177)+((x166)+(x148));
  x179 = ((uintptr_t)((x177)<((x145)+(x119))))+((uintptr_t)((x178)<((x166)+(x148))));
  x180 = (x8)*((uintptr_t)8589934592ULL);
  x181 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)8589934592ULL))>>64);
  x182 = (x8)*((uintptr_t)18446744065119617024ULL);
  x183 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)18446744065119617024ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)18446744065119617024ULL))>>64);
  x184 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)8589934592ULL))>>64);
  x185 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x8)*((uintptr_t)18446744065119617025ULL))>>32 : ((__uint128_t)(x8)*((uintptr_t)18446744065119617025ULL))>>64);
  x186 = (x185)+((x8)*((uintptr_t)8589934592ULL));
  x187 = ((uintptr_t)((x186)<(x185)))+(x184);
  x188 = (x187)+(x182);
  x189 = (((uintptr_t)((x187)<(x184)))+((uintptr_t)((x188)<(x182))))+(x183);
  x190 = (x189)+(x180);
  x191 = (((uintptr_t)((x189)<(x183)))+((uintptr_t)((x190)<(x180))))+(x181);
  x192 = (x191)+(x8);
  x193 = ((uintptr_t)((x191)<(x181)))+((uintptr_t)((x192)<(x8)));
  x194 = (x168)+((x8)*((uintptr_t)18446744065119617025ULL));
  x195 = ((uintptr_t)((x194)<(x168)))+(x170);
  x196 = (x195)+(x186);
  x197 = (((uintptr_t)((x195)<(x170)))+((uintptr_t)((x196)<(x186))))+(x172);
  x198 = (x197)+(x188);
  x199 = (((uintptr_t)((x197)<(x172)))+((uintptr_t)((x198)<(x188))))+(x174);
  x200 = (x199)+(x190);
  x201 = (((uintptr_t)((x199)<(x174)))+((uintptr_t)((x200)<(x190))))+(x176);
  x202 = (x201)+(x192);
  x203 = (((uintptr_t)((x201)<(x176)))+((uintptr_t)((x202)<(x192))))+(x178);
  x204 = (x203)+(x193);
  x205 = ((uintptr_t)((x203)<(x178)))+((uintptr_t)((x204)<(x193)));
  x206 = (x194)*((uintptr_t)4294967297ULL);
  x207 = (x206)*((uintptr_t)18446744073709551615ULL);
  x208 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64);
  x209 = (x206)*((uintptr_t)18446744073709551615ULL);
  x210 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64);
  x211 = (x206)*((uintptr_t)18446744073709551615ULL);
  x212 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551615ULL))>>64);
  x213 = (x206)*((uintptr_t)18446744073709551614ULL);
  x214 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744073709551614ULL))>>64);
  x215 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)18446744069414584320ULL))>>64);
  x216 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x206)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x206)*((uintptr_t)4294967295ULL))>>64);
  x217 = (x216)+((x206)*((uintptr_t)18446744069414584320ULL));
  x218 = ((uintptr_t)((x217)<(x216)))+(x215);
  x219 = (x218)+(x213);
  x220 = (((uintptr_t)((x218)<(x215)))+((uintptr_t)((x219)<(x213))))+(x214);
  x221 = (x220)+(x211);
  x222 = (((uintptr_t)((x220)<(x214)))+((uintptr_t)((x221)<(x211))))+(x212);
  x223 = (x222)+(x209);
  x224 = (((uintptr_t)((x222)<(x212)))+((uintptr_t)((x223)<(x209))))+(x210);
  x225 = (x224)+(x207);
  x226 = ((uintptr_t)((x224)<(x210)))+((uintptr_t)((x225)<(x207)));
  x227 = ((uintptr_t)(((x194)+((x206)*((uintptr_t)4294967295ULL)))<(x194)))+(x196);
  x228 = (x227)+(x217);
  x229 = (((uintptr_t)((x227)<(x196)))+((uintptr_t)((x228)<(x217))))+(x198);
  x230 = (x229)+(x219);
  x231 = (((uintptr_t)((x229)<(x198)))+((uintptr_t)((x230)<(x219))))+(x200);
  x232 = (x231)+(x221);
  x233 = (((uintptr_t)((x231)<(x200)))+((uintptr_t)((x232)<(x221))))+(x202);
  x234 = (x233)+(x223);
  x235 = (((uintptr_t)((x233)<(x202)))+((uintptr_t)((x234)<(x223))))+(x204);
  x236 = (x235)+(x225);
  x237 = (((uintptr_t)((x235)<(x204)))+((uintptr_t)((x236)<(x225))))+((x205)+(x179));
  x238 = (x237)+((x226)+(x208));
  x239 = ((uintptr_t)((x237)<((x205)+(x179))))+((uintptr_t)((x238)<((x226)+(x208))));
  x240 = (x9)*((uintptr_t)8589934592ULL);
  x241 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)8589934592ULL))>>64);
  x242 = (x9)*((uintptr_t)18446744065119617024ULL);
  x243 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)18446744065119617024ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)18446744065119617024ULL))>>64);
  x244 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)8589934592ULL))>>64);
  x245 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x9)*((uintptr_t)18446744065119617025ULL))>>32 : ((__uint128_t)(x9)*((uintptr_t)18446744065119617025ULL))>>64);
  x246 = (x245)+((x9)*((uintptr_t)8589934592ULL));
  x247 = ((uintptr_t)((x246)<(x245)))+(x244);
  x248 = (x247)+(x242);
  x249 = (((uintptr_t)((x247)<(x244)))+((uintptr_t)((x248)<(x242))))+(x243);
  x250 = (x249)+(x240);
  x251 = (((uintptr_t)((x249)<(x243)))+((uintptr_t)((x250)<(x240))))+(x241);
  x252 = (x251)+(x9);
  x253 = ((uintptr_t)((x251)<(x241)))+((uintptr_t)((x252)<(x9)));
  x254 = (x228)+((x9)*((uintptr_t)18446744065119617025ULL));
  x255 = ((uintptr_t)((x254)<(x228)))+(x230);
  x256 = (x255)+(x246);
  x257 = (((uintptr_t)((x255)<(x230)))+((uintptr_t)((x256)<(x246))))+(x232);
  x258 = (x257)+(x248);
  x259 = (((uintptr_t)((x257)<(x232)))+((uintptr_t)((x258)<(x248))))+(x234);
  x260 = (x259)+(x250);
  x261 = (((uintptr_t)((x259)<(x234)))+((uintptr_t)((x260)<(x250))))+(x236);
  x262 = (x261)+(x252);
  x263 = (((uintptr_t)((x261)<(x236)))+((uintptr_t)((x262)<(x252))))+(x238);
  x264 = (x263)+(x253);
  x265 = ((uintptr_t)((x263)<(x238)))+((uintptr_t)((x264)<(x253)));
  x266 = (x254)*((uintptr_t)4294967297ULL);
  x267 = (x266)*((uintptr_t)18446744073709551615ULL);
  x268 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x266)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x266)*((uintptr_t)18446744073709551615ULL))>>64);
  x269 = (x266)*((uintptr_t)18446744073709551615ULL);
  x270 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x266)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x266)*((uintptr_t)18446744073709551615ULL))>>64);
  x271 = (x266)*((uintptr_t)18446744073709551615ULL);
  x272 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x266)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x266)*((uintptr_t)18446744073709551615ULL))>>64);
  x273 = (x266)*((uintptr_t)18446744073709551614ULL);
  x274 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x266)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x266)*((uintptr_t)18446744073709551614ULL))>>64);
  x275 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x266)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x266)*((uintptr_t)18446744069414584320ULL))>>64);
  x276 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x266)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x266)*((uintptr_t)4294967295ULL))>>64);
  x277 = (x276)+((x266)*((uintptr_t)18446744069414584320ULL));
  x278 = ((uintptr_t)((x277)<(x276)))+(x275);
  x279 = (x278)+(x273);
  x280 = (((uintptr_t)((x278)<(x275)))+((uintptr_t)((x279)<(x273))))+(x274);
  x281 = (x280)+(x271);
  x282 = (((uintptr_t)((x280)<(x274)))+((uintptr_t)((x281)<(x271))))+(x272);
  x283 = (x282)+(x269);
  x284 = (((uintptr_t)((x282)<(x272)))+((uintptr_t)((x283)<(x269))))+(x270);
  x285 = (x284)+(x267);
  x286 = ((uintptr_t)((x284)<(x270)))+((uintptr_t)((x285)<(x267)));
  x287 = ((uintptr_t)(((x254)+((x266)*((uintptr_t)4294967295ULL)))<(x254)))+(x256);
  x288 = (x287)+(x277);
  x289 = (((uintptr_t)((x287)<(x256)))+((uintptr_t)((x288)<(x277))))+(x258);
  x290 = (x289)+(x279);
  x291 = (((uintptr_t)((x289)<(x258)))+((uintptr_t)((x290)<(x279))))+(x260);
  x292 = (x291)+(x281);
  x293 = (((uintptr_t)((x291)<(x260)))+((uintptr_t)((x292)<(x281))))+(x262);
  x294 = (x293)+(x283);
  x295 = (((uintptr_t)((x293)<(x262)))+((uintptr_t)((x294)<(x283))))+(x264);
  x296 = (x295)+(x285);
  x297 = (((uintptr_t)((x295)<(x264)))+((uintptr_t)((x296)<(x285))))+((x265)+(x239));
  x298 = (x297)+((x286)+(x268));
  x299 = ((uintptr_t)((x297)<((x265)+(x239))))+((uintptr_t)((x298)<((x286)+(x268))));
  x300 = (x10)*((uintptr_t)8589934592ULL);
  x301 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)8589934592ULL))>>64);
  x302 = (x10)*((uintptr_t)18446744065119617024ULL);
  x303 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)18446744065119617024ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)18446744065119617024ULL))>>64);
  x304 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)8589934592ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)8589934592ULL))>>64);
  x305 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x10)*((uintptr_t)18446744065119617025ULL))>>32 : ((__uint128_t)(x10)*((uintptr_t)18446744065119617025ULL))>>64);
  x306 = (x305)+((x10)*((uintptr_t)8589934592ULL));
  x307 = ((uintptr_t)((x306)<(x305)))+(x304);
  x308 = (x307)+(x302);
  x309 = (((uintptr_t)((x307)<(x304)))+((uintptr_t)((x308)<(x302))))+(x303);
  x310 = (x309)+(x300);
  x311 = (((uintptr_t)((x309)<(x303)))+((uintptr_t)((x310)<(x300))))+(x301);
  x312 = (x311)+(x10);
  x313 = ((uintptr_t)((x311)<(x301)))+((uintptr_t)((x312)<(x10)));
  x314 = (x288)+((x10)*((uintptr_t)18446744065119617025ULL));
  x315 = ((uintptr_t)((x314)<(x288)))+(x290);
  x316 = (x315)+(x306);
  x317 = (((uintptr_t)((x315)<(x290)))+((uintptr_t)((x316)<(x306))))+(x292);
  x318 = (x317)+(x308);
  x319 = (((uintptr_t)((x317)<(x292)))+((uintptr_t)((x318)<(x308))))+(x294);
  x320 = (x319)+(x310);
  x321 = (((uintptr_t)((x319)<(x294)))+((uintptr_t)((x320)<(x310))))+(x296);
  x322 = (x321)+(x312);
  x323 = (((uintptr_t)((x321)<(x296)))+((uintptr_t)((x322)<(x312))))+(x298);
  x324 = (x323)+(x313);
  x325 = ((uintptr_t)((x323)<(x298)))+((uintptr_t)((x324)<(x313)));
  x326 = (x314)*((uintptr_t)4294967297ULL);
  x327 = (x326)*((uintptr_t)18446744073709551615ULL);
  x328 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x326)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x326)*((uintptr_t)18446744073709551615ULL))>>64);
  x329 = (x326)*((uintptr_t)18446744073709551615ULL);
  x330 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x326)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x326)*((uintptr_t)18446744073709551615ULL))>>64);
  x331 = (x326)*((uintptr_t)18446744073709551615ULL);
  x332 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x326)*((uintptr_t)18446744073709551615ULL))>>32 : ((__uint128_t)(x326)*((uintptr_t)18446744073709551615ULL))>>64);
  x333 = (x326)*((uintptr_t)18446744073709551614ULL);
  x334 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x326)*((uintptr_t)18446744073709551614ULL))>>32 : ((__uint128_t)(x326)*((uintptr_t)18446744073709551614ULL))>>64);
  x335 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x326)*((uintptr_t)18446744069414584320ULL))>>32 : ((__uint128_t)(x326)*((uintptr_t)18446744069414584320ULL))>>64);
  x336 = (uintptr_t)(sizeof(intptr_t) == 4 ? ((uint64_t)(x326)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x326)*((uintptr_t)4294967295ULL))>>64);
  x337 = (x336)+((x326)*((uintptr_t)18446744069414584320ULL));
  x338 = ((uintptr_t)((x337)<(x336)))+(x335);
  x339 = (x338)+(x333);
  x340 = (((uintptr_t)((x338)<(x335)))+((uintptr_t)((x339)<(x333))))+(x334);
  x341 = (x340)+(x331);
  x342 = (((uintptr_t)((x340)<(x334)))+((uintptr_t)((x341)<(x331))))+(x332);
  x343 = (x342)+(x329);
  x344 = (((uintptr_t)((x342)<(x332)))+((uintptr_t)((x343)<(x329))))+(x330);
  x345 = (x344)+(x327);
  x346 = ((uintptr_t)((x344)<(x330)))+((uintptr_t)((x345)<(x327)));
  x347 = ((uintptr_t)(((x314)+((x326)*((uintptr_t)4294967295ULL)))<(x314)))+(x316);
  x348 = (x347)+(x337);
  x349 = (((uintptr_t)((x347)<(x316)))+((uintptr_t)((x348)<(x337))))+(x318);
  x350 = (x349)+(x339);
  x351 = (((uintptr_t)((x349)<(x318)))+((uintptr_t)((x350)<(x339))))+(x320);
  x352 = (x351)+(x341);
  x353 = (((uintptr_t)((x351)<(x320)))+((uintptr_t)((x352)<(x341))))+(x322);
  x354 = (x353)+(x343);
  x355 = (((uintptr_t)((x353)<(x322)))+((uintptr_t)((x354)<(x343))))+(x324);
  x356 = (x355)+(x345);
  x357 = (((uintptr_t)((x355)<(x324)))+((uintptr_t)((x356)<(x345))))+((x325)+(x299));
  x358 = (x357)+((x346)+(x328));
  x359 = ((uintptr_t)((x357)<((x325)+(x299))))+((uintptr_t)((x358)<((x346)+(x328))));
  x360 = (x348)-((uintptr_t)4294967295ULL);
  x361 = (x350)-((uintptr_t)18446744069414584320ULL);
  x362 = (x361)-((uintptr_t)((x348)<(x360)));
  x363 = (x352)-((uintptr_t)18446744073709551614ULL);
  x364 = (x363)-(((uintptr_t)((x350)<(x361)))+((uintptr_t)((x361)<(x362))));
  x365 = (x354)-((uintptr_t)18446744073709551615ULL);
  x366 = (x365)-(((uintptr_t)((x352)<(x363)))+((uintptr_t)((x363)<(x364))));
  x367 = (x356)-((uintptr_t)18446744073709551615ULL);
  x368 = (x367)-(((uintptr_t)((x354)<(x365)))+((uintptr_t)((x365)<(x366))));
  x369 = (x358)-((uintptr_t)18446744073709551615ULL);
  x370 = (x369)-(((uintptr_t)((x356)<(x367)))+((uintptr_t)((x367)<(x368))));
  x371 = (uintptr_t)((x359)<((x359)-(((uintptr_t)((x358)<(x369)))+((uintptr_t)((x369)<(x370))))));
  x372 = ((uintptr_t)-1ULL)+((uintptr_t)((x371)==((uintptr_t)0ULL)));
  x373 = (x372)^((uintptr_t)18446744073709551615ULL);
  x374 = ((x348)&(x372))|((x360)&(x373));
  x375 = ((uintptr_t)-1ULL)+((uintptr_t)((x371)==((uintptr_t)0ULL)));
  x376 = (x375)^((uintptr_t)18446744073709551615ULL);
  x377 = ((x350)&(x375))|((x362)&(x376));
  x378 = ((uintptr_t)-1ULL)+((uintptr_t)((x371)==((uintptr_t)0ULL)));
  x379 = (x378)^((uintptr_t)18446744073709551615ULL);
  x380 = ((x352)&(x378))|((x364)&(x379));
  x381 = ((uintptr_t)-1ULL)+((uintptr_t)((x371)==((uintptr_t)0ULL)));
  x382 = (x381)^((uintptr_t)18446744073709551615ULL);
  x383 = ((x354)&(x381))|((x366)&(x382));
  x384 = ((uintptr_t)-1ULL)+((uintptr_t)((x371)==((uintptr_t)0ULL)));
  x385 = (x384)^((uintptr_t)18446744073709551615ULL);
  x386 = ((x356)&(x384))|((x368)&(x385));
  x387 = ((uintptr_t)-1ULL)+((uintptr_t)((x371)==((uintptr_t)0ULL)));
  x388 = (x387)^((uintptr_t)18446744073709551615ULL);
  x389 = ((x358)&(x387))|((x370)&(x388));
  x390 = x374;
  x391 = x377;
  x392 = x380;
  x393 = x383;
  x394 = x386;
  x395 = x389;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x390, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x391, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x392, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x393, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x394, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x395, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_to_montgomery(uint64_t out1[6], const uint64_t arg1[6]) {
  internal_fiat_p384_to_montgomery((uintptr_t)out1, (uintptr_t)arg1);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [0x0 ~> 0xffffffffffffffff]
 */
static
uintptr_t internal_fiat_p384_nonzero(uintptr_t in0) {
  uintptr_t x0, x1, x2, x3, x4, x5, x6, out0, x7;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x6 = (x0)|((x1)|((x2)|((x3)|((x4)|(x5)))));
  x7 = x6;
  out0 = x7;
  return out0;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_nonzero(uint64_t* out1, const uint64_t arg1[6]) {
  *out1 = (uint64_t)internal_fiat_p384_nonzero((uintptr_t)arg1);
}


/*
 * Input Bounds:
 *   in0: [0x0 ~> 0x1]
 *   in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_selectznz(uintptr_t out0, uintptr_t in0, uintptr_t in1, uintptr_t in2) {
  uintptr_t x6, x12, x0, x13, x7, x15, x1, x16, x8, x18, x2, x19, x9, x21, x3, x22, x10, x24, x4, x25, x11, x27, x5, x28, x14, x17, x20, x23, x26, x29, x30, x31, x32, x33, x34, x35;
  /*skip*/
  x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  x6 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x7 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x8 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x9 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x10 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x11 = _br2_load((in2)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x12 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL)));
  x13 = (x12)^((uintptr_t)18446744073709551615ULL);
  x14 = ((x6)&(x12))|((x0)&(x13));
  x15 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL)));
  x16 = (x15)^((uintptr_t)18446744073709551615ULL);
  x17 = ((x7)&(x15))|((x1)&(x16));
  x18 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL)));
  x19 = (x18)^((uintptr_t)18446744073709551615ULL);
  x20 = ((x8)&(x18))|((x2)&(x19));
  x21 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL)));
  x22 = (x21)^((uintptr_t)18446744073709551615ULL);
  x23 = ((x9)&(x21))|((x3)&(x22));
  x24 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL)));
  x25 = (x24)^((uintptr_t)18446744073709551615ULL);
  x26 = ((x10)&(x24))|((x4)&(x25));
  x27 = ((uintptr_t)-1ULL)+((uintptr_t)((in0)==((uintptr_t)0ULL)));
  x28 = (x27)^((uintptr_t)18446744073709551615ULL);
  x29 = ((x11)&(x27))|((x5)&(x28));
  x30 = x14;
  x31 = x17;
  x32 = x20;
  x33 = x23;
  x34 = x26;
  x35 = x29;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x30, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x31, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x32, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x33, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x34, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x35, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_selectznz(uint64_t out1[6], uint8_t arg1, const uint64_t arg2[6], const uint64_t arg3[6]) {
  internal_fiat_p384_selectznz((uintptr_t)out1, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
 */
static
void internal_fiat_p384_to_bytes(uintptr_t out0, uintptr_t in0) {
  uintptr_t x5, x4, x3, x2, x1, x0, x11, x13, x15, x17, x19, x21, x23, x10, x27, x29, x31, x33, x35, x37, x9, x41, x43, x45, x47, x49, x51, x8, x55, x57, x59, x61, x63, x65, x7, x69, x71, x73, x75, x77, x79, x6, x83, x85, x87, x89, x91, x93, x12, x14, x16, x18, x20, x22, x24, x25, x26, x28, x30, x32, x34, x36, x38, x39, x40, x42, x44, x46, x48, x50, x52, x53, x54, x56, x58, x60, x62, x64, x66, x67, x68, x70, x72, x74, x76, x78, x80, x81, x82, x84, x86, x88, x90, x92, x94, x95, x96, x97, x98, x99, x100, x101, x102, x103, x104, x105, x106, x107, x108, x109, x110, x111, x112, x113, x114, x115, x116, x117, x118, x119, x120, x121, x122, x123, x124, x125, x126, x127, x128, x129, x130, x131, x132, x133, x134, x135, x136, x137, x138, x139, x140, x141, x142, x143;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in0)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in0)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in0)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in0)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in0)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x6 = x5;
  x7 = x4;
  x8 = x3;
  x9 = x2;
  x10 = x1;
  x11 = x0;
  x12 = (x11)&((uintptr_t)255ULL);
  x13 = (x11)>>((uintptr_t)8ULL);
  x14 = (x13)&((uintptr_t)255ULL);
  x15 = (x13)>>((uintptr_t)8ULL);
  x16 = (x15)&((uintptr_t)255ULL);
  x17 = (x15)>>((uintptr_t)8ULL);
  x18 = (x17)&((uintptr_t)255ULL);
  x19 = (x17)>>((uintptr_t)8ULL);
  x20 = (x19)&((uintptr_t)255ULL);
  x21 = (x19)>>((uintptr_t)8ULL);
  x22 = (x21)&((uintptr_t)255ULL);
  x23 = (x21)>>((uintptr_t)8ULL);
  x24 = (x23)&((uintptr_t)255ULL);
  x25 = (x23)>>((uintptr_t)8ULL);
  x26 = (x10)&((uintptr_t)255ULL);
  x27 = (x10)>>((uintptr_t)8ULL);
  x28 = (x27)&((uintptr_t)255ULL);
  x29 = (x27)>>((uintptr_t)8ULL);
  x30 = (x29)&((uintptr_t)255ULL);
  x31 = (x29)>>((uintptr_t)8ULL);
  x32 = (x31)&((uintptr_t)255ULL);
  x33 = (x31)>>((uintptr_t)8ULL);
  x34 = (x33)&((uintptr_t)255ULL);
  x35 = (x33)>>((uintptr_t)8ULL);
  x36 = (x35)&((uintptr_t)255ULL);
  x37 = (x35)>>((uintptr_t)8ULL);
  x38 = (x37)&((uintptr_t)255ULL);
  x39 = (x37)>>((uintptr_t)8ULL);
  x40 = (x9)&((uintptr_t)255ULL);
  x41 = (x9)>>((uintptr_t)8ULL);
  x42 = (x41)&((uintptr_t)255ULL);
  x43 = (x41)>>((uintptr_t)8ULL);
  x44 = (x43)&((uintptr_t)255ULL);
  x45 = (x43)>>((uintptr_t)8ULL);
  x46 = (x45)&((uintptr_t)255ULL);
  x47 = (x45)>>((uintptr_t)8ULL);
  x48 = (x47)&((uintptr_t)255ULL);
  x49 = (x47)>>((uintptr_t)8ULL);
  x50 = (x49)&((uintptr_t)255ULL);
  x51 = (x49)>>((uintptr_t)8ULL);
  x52 = (x51)&((uintptr_t)255ULL);
  x53 = (x51)>>((uintptr_t)8ULL);
  x54 = (x8)&((uintptr_t)255ULL);
  x55 = (x8)>>((uintptr_t)8ULL);
  x56 = (x55)&((uintptr_t)255ULL);
  x57 = (x55)>>((uintptr_t)8ULL);
  x58 = (x57)&((uintptr_t)255ULL);
  x59 = (x57)>>((uintptr_t)8ULL);
  x60 = (x59)&((uintptr_t)255ULL);
  x61 = (x59)>>((uintptr_t)8ULL);
  x62 = (x61)&((uintptr_t)255ULL);
  x63 = (x61)>>((uintptr_t)8ULL);
  x64 = (x63)&((uintptr_t)255ULL);
  x65 = (x63)>>((uintptr_t)8ULL);
  x66 = (x65)&((uintptr_t)255ULL);
  x67 = (x65)>>((uintptr_t)8ULL);
  x68 = (x7)&((uintptr_t)255ULL);
  x69 = (x7)>>((uintptr_t)8ULL);
  x70 = (x69)&((uintptr_t)255ULL);
  x71 = (x69)>>((uintptr_t)8ULL);
  x72 = (x71)&((uintptr_t)255ULL);
  x73 = (x71)>>((uintptr_t)8ULL);
  x74 = (x73)&((uintptr_t)255ULL);
  x75 = (x73)>>((uintptr_t)8ULL);
  x76 = (x75)&((uintptr_t)255ULL);
  x77 = (x75)>>((uintptr_t)8ULL);
  x78 = (x77)&((uintptr_t)255ULL);
  x79 = (x77)>>((uintptr_t)8ULL);
  x80 = (x79)&((uintptr_t)255ULL);
  x81 = (x79)>>((uintptr_t)8ULL);
  x82 = (x6)&((uintptr_t)255ULL);
  x83 = (x6)>>((uintptr_t)8ULL);
  x84 = (x83)&((uintptr_t)255ULL);
  x85 = (x83)>>((uintptr_t)8ULL);
  x86 = (x85)&((uintptr_t)255ULL);
  x87 = (x85)>>((uintptr_t)8ULL);
  x88 = (x87)&((uintptr_t)255ULL);
  x89 = (x87)>>((uintptr_t)8ULL);
  x90 = (x89)&((uintptr_t)255ULL);
  x91 = (x89)>>((uintptr_t)8ULL);
  x92 = (x91)&((uintptr_t)255ULL);
  x93 = (x91)>>((uintptr_t)8ULL);
  x94 = (x93)&((uintptr_t)255ULL);
  x95 = (x93)>>((uintptr_t)8ULL);
  x96 = x12;
  x97 = x14;
  x98 = x16;
  x99 = x18;
  x100 = x20;
  x101 = x22;
  x102 = x24;
  x103 = x25;
  x104 = x26;
  x105 = x28;
  x106 = x30;
  x107 = x32;
  x108 = x34;
  x109 = x36;
  x110 = x38;
  x111 = x39;
  x112 = x40;
  x113 = x42;
  x114 = x44;
  x115 = x46;
  x116 = x48;
  x117 = x50;
  x118 = x52;
  x119 = x53;
  x120 = x54;
  x121 = x56;
  x122 = x58;
  x123 = x60;
  x124 = x62;
  x125 = x64;
  x126 = x66;
  x127 = x67;
  x128 = x68;
  x129 = x70;
  x130 = x72;
  x131 = x74;
  x132 = x76;
  x133 = x78;
  x134 = x80;
  x135 = x81;
  x136 = x82;
  x137 = x84;
  x138 = x86;
  x139 = x88;
  x140 = x90;
  x141 = x92;
  x142 = x94;
  x143 = x95;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x96, 1);
  _br2_store((out0)+((uintptr_t)1ULL), x97, 1);
  _br2_store((out0)+((uintptr_t)2ULL), x98, 1);
  _br2_store((out0)+((uintptr_t)3ULL), x99, 1);
  _br2_store((out0)+((uintptr_t)4ULL), x100, 1);
  _br2_store((out0)+((uintptr_t)5ULL), x101, 1);
  _br2_store((out0)+((uintptr_t)6ULL), x102, 1);
  _br2_store((out0)+((uintptr_t)7ULL), x103, 1);
  _br2_store((out0)+((uintptr_t)8ULL), x104, 1);
  _br2_store((out0)+((uintptr_t)9ULL), x105, 1);
  _br2_store((out0)+((uintptr_t)10ULL), x106, 1);
  _br2_store((out0)+((uintptr_t)11ULL), x107, 1);
  _br2_store((out0)+((uintptr_t)12ULL), x108, 1);
  _br2_store((out0)+((uintptr_t)13ULL), x109, 1);
  _br2_store((out0)+((uintptr_t)14ULL), x110, 1);
  _br2_store((out0)+((uintptr_t)15ULL), x111, 1);
  _br2_store((out0)+((uintptr_t)16ULL), x112, 1);
  _br2_store((out0)+((uintptr_t)17ULL), x113, 1);
  _br2_store((out0)+((uintptr_t)18ULL), x114, 1);
  _br2_store((out0)+((uintptr_t)19ULL), x115, 1);
  _br2_store((out0)+((uintptr_t)20ULL), x116, 1);
  _br2_store((out0)+((uintptr_t)21ULL), x117, 1);
  _br2_store((out0)+((uintptr_t)22ULL), x118, 1);
  _br2_store((out0)+((uintptr_t)23ULL), x119, 1);
  _br2_store((out0)+((uintptr_t)24ULL), x120, 1);
  _br2_store((out0)+((uintptr_t)25ULL), x121, 1);
  _br2_store((out0)+((uintptr_t)26ULL), x122, 1);
  _br2_store((out0)+((uintptr_t)27ULL), x123, 1);
  _br2_store((out0)+((uintptr_t)28ULL), x124, 1);
  _br2_store((out0)+((uintptr_t)29ULL), x125, 1);
  _br2_store((out0)+((uintptr_t)30ULL), x126, 1);
  _br2_store((out0)+((uintptr_t)31ULL), x127, 1);
  _br2_store((out0)+((uintptr_t)32ULL), x128, 1);
  _br2_store((out0)+((uintptr_t)33ULL), x129, 1);
  _br2_store((out0)+((uintptr_t)34ULL), x130, 1);
  _br2_store((out0)+((uintptr_t)35ULL), x131, 1);
  _br2_store((out0)+((uintptr_t)36ULL), x132, 1);
  _br2_store((out0)+((uintptr_t)37ULL), x133, 1);
  _br2_store((out0)+((uintptr_t)38ULL), x134, 1);
  _br2_store((out0)+((uintptr_t)39ULL), x135, 1);
  _br2_store((out0)+((uintptr_t)40ULL), x136, 1);
  _br2_store((out0)+((uintptr_t)41ULL), x137, 1);
  _br2_store((out0)+((uintptr_t)42ULL), x138, 1);
  _br2_store((out0)+((uintptr_t)43ULL), x139, 1);
  _br2_store((out0)+((uintptr_t)44ULL), x140, 1);
  _br2_store((out0)+((uintptr_t)45ULL), x141, 1);
  _br2_store((out0)+((uintptr_t)46ULL), x142, 1);
  _br2_store((out0)+((uintptr_t)47ULL), x143, 1);
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_to_bytes(uint8_t out1[48], const uint64_t arg1[6]) {
  internal_fiat_p384_to_bytes((uintptr_t)out1, (uintptr_t)arg1);
}


/*
 * Input Bounds:
 *   in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_from_bytes(uintptr_t out0, uintptr_t in0) {
  uintptr_t x47, x46, x45, x44, x43, x42, x41, x40, x39, x38, x37, x36, x35, x34, x33, x32, x31, x30, x29, x28, x27, x26, x25, x24, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x12, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x94, x95, x93, x96, x92, x97, x91, x98, x90, x99, x89, x100, x88, x101, x86, x87, x85, x103, x84, x104, x83, x105, x82, x106, x81, x107, x80, x108, x78, x79, x77, x110, x76, x111, x75, x112, x74, x113, x73, x114, x72, x115, x70, x71, x69, x117, x68, x118, x67, x119, x66, x120, x65, x121, x64, x122, x62, x63, x61, x124, x60, x125, x59, x126, x58, x127, x57, x128, x56, x129, x54, x55, x53, x131, x52, x132, x51, x133, x50, x134, x49, x135, x48, x136, x102, x109, x116, x123, x130, x137, x138, x139, x140, x141, x142, x143;
  x0 = _br2_load((in0)+((uintptr_t)0ULL), 1);
  x1 = _br2_load((in0)+((uintptr_t)1ULL), 1);
  x2 = _br2_load((in0)+((uintptr_t)2ULL), 1);
  x3 = _br2_load((in0)+((uintptr_t)3ULL), 1);
  x4 = _br2_load((in0)+((uintptr_t)4ULL), 1);
  x5 = _br2_load((in0)+((uintptr_t)5ULL), 1);
  x6 = _br2_load((in0)+((uintptr_t)6ULL), 1);
  x7 = _br2_load((in0)+((uintptr_t)7ULL), 1);
  x8 = _br2_load((in0)+((uintptr_t)8ULL), 1);
  x9 = _br2_load((in0)+((uintptr_t)9ULL), 1);
  x10 = _br2_load((in0)+((uintptr_t)10ULL), 1);
  x11 = _br2_load((in0)+((uintptr_t)11ULL), 1);
  x12 = _br2_load((in0)+((uintptr_t)12ULL), 1);
  x13 = _br2_load((in0)+((uintptr_t)13ULL), 1);
  x14 = _br2_load((in0)+((uintptr_t)14ULL), 1);
  x15 = _br2_load((in0)+((uintptr_t)15ULL), 1);
  x16 = _br2_load((in0)+((uintptr_t)16ULL), 1);
  x17 = _br2_load((in0)+((uintptr_t)17ULL), 1);
  x18 = _br2_load((in0)+((uintptr_t)18ULL), 1);
  x19 = _br2_load((in0)+((uintptr_t)19ULL), 1);
  x20 = _br2_load((in0)+((uintptr_t)20ULL), 1);
  x21 = _br2_load((in0)+((uintptr_t)21ULL), 1);
  x22 = _br2_load((in0)+((uintptr_t)22ULL), 1);
  x23 = _br2_load((in0)+((uintptr_t)23ULL), 1);
  x24 = _br2_load((in0)+((uintptr_t)24ULL), 1);
  x25 = _br2_load((in0)+((uintptr_t)25ULL), 1);
  x26 = _br2_load((in0)+((uintptr_t)26ULL), 1);
  x27 = _br2_load((in0)+((uintptr_t)27ULL), 1);
  x28 = _br2_load((in0)+((uintptr_t)28ULL), 1);
  x29 = _br2_load((in0)+((uintptr_t)29ULL), 1);
  x30 = _br2_load((in0)+((uintptr_t)30ULL), 1);
  x31 = _br2_load((in0)+((uintptr_t)31ULL), 1);
  x32 = _br2_load((in0)+((uintptr_t)32ULL), 1);
  x33 = _br2_load((in0)+((uintptr_t)33ULL), 1);
  x34 = _br2_load((in0)+((uintptr_t)34ULL), 1);
  x35 = _br2_load((in0)+((uintptr_t)35ULL), 1);
  x36 = _br2_load((in0)+((uintptr_t)36ULL), 1);
  x37 = _br2_load((in0)+((uintptr_t)37ULL), 1);
  x38 = _br2_load((in0)+((uintptr_t)38ULL), 1);
  x39 = _br2_load((in0)+((uintptr_t)39ULL), 1);
  x40 = _br2_load((in0)+((uintptr_t)40ULL), 1);
  x41 = _br2_load((in0)+((uintptr_t)41ULL), 1);
  x42 = _br2_load((in0)+((uintptr_t)42ULL), 1);
  x43 = _br2_load((in0)+((uintptr_t)43ULL), 1);
  x44 = _br2_load((in0)+((uintptr_t)44ULL), 1);
  x45 = _br2_load((in0)+((uintptr_t)45ULL), 1);
  x46 = _br2_load((in0)+((uintptr_t)46ULL), 1);
  x47 = _br2_load((in0)+((uintptr_t)47ULL), 1);
  /*skip*/
  /*skip*/
  x48 = (x47)<<((uintptr_t)56ULL);
  x49 = (x46)<<((uintptr_t)48ULL);
  x50 = (x45)<<((uintptr_t)40ULL);
  x51 = (x44)<<((uintptr_t)32ULL);
  x52 = (x43)<<((uintptr_t)24ULL);
  x53 = (x42)<<((uintptr_t)16ULL);
  x54 = (x41)<<((uintptr_t)8ULL);
  x55 = x40;
  x56 = (x39)<<((uintptr_t)56ULL);
  x57 = (x38)<<((uintptr_t)48ULL);
  x58 = (x37)<<((uintptr_t)40ULL);
  x59 = (x36)<<((uintptr_t)32ULL);
  x60 = (x35)<<((uintptr_t)24ULL);
  x61 = (x34)<<((uintptr_t)16ULL);
  x62 = (x33)<<((uintptr_t)8ULL);
  x63 = x32;
  x64 = (x31)<<((uintptr_t)56ULL);
  x65 = (x30)<<((uintptr_t)48ULL);
  x66 = (x29)<<((uintptr_t)40ULL);
  x67 = (x28)<<((uintptr_t)32ULL);
  x68 = (x27)<<((uintptr_t)24ULL);
  x69 = (x26)<<((uintptr_t)16ULL);
  x70 = (x25)<<((uintptr_t)8ULL);
  x71 = x24;
  x72 = (x23)<<((uintptr_t)56ULL);
  x73 = (x22)<<((uintptr_t)48ULL);
  x74 = (x21)<<((uintptr_t)40ULL);
  x75 = (x20)<<((uintptr_t)32ULL);
  x76 = (x19)<<((uintptr_t)24ULL);
  x77 = (x18)<<((uintptr_t)16ULL);
  x78 = (x17)<<((uintptr_t)8ULL);
  x79 = x16;
  x80 = (x15)<<((uintptr_t)56ULL);
  x81 = (x14)<<((uintptr_t)48ULL);
  x82 = (x13)<<((uintptr_t)40ULL);
  x83 = (x12)<<((uintptr_t)32ULL);
  x84 = (x11)<<((uintptr_t)24ULL);
  x85 = (x10)<<((uintptr_t)16ULL);
  x86 = (x9)<<((uintptr_t)8ULL);
  x87 = x8;
  x88 = (x7)<<((uintptr_t)56ULL);
  x89 = (x6)<<((uintptr_t)48ULL);
  x90 = (x5)<<((uintptr_t)40ULL);
  x91 = (x4)<<((uintptr_t)32ULL);
  x92 = (x3)<<((uintptr_t)24ULL);
  x93 = (x2)<<((uintptr_t)16ULL);
  x94 = (x1)<<((uintptr_t)8ULL);
  x95 = x0;
  x96 = (x94)+(x95);
  x97 = (x93)+(x96);
  x98 = (x92)+(x97);
  x99 = (x91)+(x98);
  x100 = (x90)+(x99);
  x101 = (x89)+(x100);
  x102 = (x88)+(x101);
  x103 = (x86)+(x87);
  x104 = (x85)+(x103);
  x105 = (x84)+(x104);
  x106 = (x83)+(x105);
  x107 = (x82)+(x106);
  x108 = (x81)+(x107);
  x109 = (x80)+(x108);
  x110 = (x78)+(x79);
  x111 = (x77)+(x110);
  x112 = (x76)+(x111);
  x113 = (x75)+(x112);
  x114 = (x74)+(x113);
  x115 = (x73)+(x114);
  x116 = (x72)+(x115);
  x117 = (x70)+(x71);
  x118 = (x69)+(x117);
  x119 = (x68)+(x118);
  x120 = (x67)+(x119);
  x121 = (x66)+(x120);
  x122 = (x65)+(x121);
  x123 = (x64)+(x122);
  x124 = (x62)+(x63);
  x125 = (x61)+(x124);
  x126 = (x60)+(x125);
  x127 = (x59)+(x126);
  x128 = (x58)+(x127);
  x129 = (x57)+(x128);
  x130 = (x56)+(x129);
  x131 = (x54)+(x55);
  x132 = (x53)+(x131);
  x133 = (x52)+(x132);
  x134 = (x51)+(x133);
  x135 = (x50)+(x134);
  x136 = (x49)+(x135);
  x137 = (x48)+(x136);
  x138 = x102;
  x139 = x109;
  x140 = x116;
  x141 = x123;
  x142 = x130;
  x143 = x137;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x138, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x139, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x140, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x141, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x142, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x143, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_from_bytes(uint64_t out1[6], const uint8_t arg1[48]) {
  internal_fiat_p384_from_bytes((uintptr_t)out1, (uintptr_t)arg1);
}


/*
 * Input Bounds:
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_set_one(uintptr_t out0) {
  uintptr_t x0, x1, x2, x3, x4, x5;
  /*skip*/
  x0 = (uintptr_t)18446744069414584321ULL;
  x1 = (uintptr_t)4294967295ULL;
  x2 = (uintptr_t)1ULL;
  x3 = (uintptr_t)0ULL;
  x4 = (uintptr_t)0ULL;
  x5 = (uintptr_t)0ULL;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x5, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_set_one(uint64_t out1[6]) {
  internal_fiat_p384_set_one((uintptr_t)out1);
}


/*
 * Input Bounds:
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_msat(uintptr_t out0) {
  uintptr_t x0, x1, x2, x3, x4, x5, x6;
  /*skip*/
  x0 = (uintptr_t)4294967295ULL;
  x1 = (uintptr_t)18446744069414584320ULL;
  x2 = (uintptr_t)18446744073709551614ULL;
  x3 = (uintptr_t)18446744073709551615ULL;
  x4 = (uintptr_t)18446744073709551615ULL;
  x5 = (uintptr_t)18446744073709551615ULL;
  x6 = (uintptr_t)0ULL;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x5, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)48ULL), x6, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_msat(uint64_t out1[7]) {
  internal_fiat_p384_msat((uintptr_t)out1);
}


/*
 * Input Bounds:
 *   in0: [0x0 ~> 0xffffffffffffffff]
 *   in1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   in2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   in3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   in4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 * Output Bounds:
 *   out0: [0x0 ~> 0xffffffffffffffff]
 *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   out2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   out3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 *   out4: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
uintptr_t internal_fiat_p384_divstep(uintptr_t out1, uintptr_t out2, uintptr_t out3, uintptr_t out4, uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t in3, uintptr_t in4) {
  uintptr_t x26, x28, x29, x30, x32, x33, x35, x36, x38, x39, x41, x42, x44, x45, x47, x48, x50, x51, x0, x54, x1, x56, x2, x58, x3, x60, x4, x62, x5, x64, x6, x53, x66, x7, x67, x55, x69, x8, x70, x57, x72, x9, x73, x59, x75, x10, x76, x61, x78, x11, x79, x63, x81, x12, x82, x65, x84, x13, x85, x87, x88, x90, x91, x93, x94, x96, x97, x99, x100, x102, x103, x106, x107, x108, x110, x111, x112, x113, x115, x116, x117, x118, x120, x121, x122, x123, x125, x126, x127, x128, x130, x133, x134, x135, x137, x138, x139, x140, x142, x143, x144, x145, x147, x148, x149, x150, x152, x153, x154, x155, x157, x158, x131, x159, x19, x18, x17, x16, x15, x14, x167, x165, x168, x170, x171, x164, x172, x174, x175, x163, x176, x178, x179, x162, x180, x182, x183, x161, x184, x186, x187, x166, x190, x169, x191, x192, x194, x195, x173, x196, x197, x199, x200, x177, x201, x202, x204, x205, x181, x206, x207, x209, x210, x185, x211, x188, x189, x213, x20, x214, x193, x216, x21, x217, x198, x219, x22, x220, x203, x222, x23, x223, x208, x225, x24, x226, x27, x212, x228, x25, x229, x232, x233, x235, x236, x238, x239, x241, x242, x244, x245, x247, x248, x250, x251, x234, x68, x254, x71, x255, x237, x256, x258, x259, x74, x260, x240, x261, x263, x264, x77, x265, x243, x266, x268, x269, x80, x270, x246, x271, x273, x274, x83, x275, x249, x276, x278, x279, x86, x280, x252, x89, x282, x283, x92, x285, x286, x95, x288, x289, x98, x291, x292, x101, x294, x295, x231, x104, x297, x298, x284, x215, x301, x218, x302, x287, x303, x305, x306, x221, x307, x290, x308, x310, x311, x224, x312, x293, x313, x315, x316, x227, x317, x296, x318, x320, x321, x230, x322, x299, x323, x325, x328, x329, x330, x332, x333, x334, x335, x337, x338, x339, x340, x342, x343, x344, x345, x347, x348, x349, x350, x352, x353, x326, x354, x31, x253, x257, x262, x267, x272, x277, x281, x105, x364, x132, x365, x109, x367, x136, x368, x114, x370, x141, x371, x119, x373, x146, x374, x124, x376, x151, x377, x160, x129, x379, x156, x380, x300, x382, x327, x383, x304, x385, x331, x386, x309, x388, x336, x389, x314, x391, x341, x392, x319, x394, x346, x395, x355, x324, x397, x351, x398, x356, x34, x37, x40, x43, x46, x49, x52, x357, x358, x359, x360, x361, x362, x363, x366, x369, x372, x375, x378, x381, x384, x387, x390, x393, x396, x399, out0, x400, x401, x402, x403, x404, x405, x406, x407, x408, x409, x410, x411, x412, x413, x414, x415, x416, x417, x418, x419, x420, x421, x422, x423, x424, x425, x426;
  /*skip*/
  x0 = _br2_load((in1)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x1 = _br2_load((in1)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x2 = _br2_load((in1)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x3 = _br2_load((in1)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x4 = _br2_load((in1)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x5 = _br2_load((in1)+((uintptr_t)40ULL), sizeof(uintptr_t));
  x6 = _br2_load((in1)+((uintptr_t)48ULL), sizeof(uintptr_t));
  /*skip*/
  x7 = _br2_load((in2)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x8 = _br2_load((in2)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x9 = _br2_load((in2)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x10 = _br2_load((in2)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x11 = _br2_load((in2)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x12 = _br2_load((in2)+((uintptr_t)40ULL), sizeof(uintptr_t));
  x13 = _br2_load((in2)+((uintptr_t)48ULL), sizeof(uintptr_t));
  /*skip*/
  x14 = _br2_load((in3)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x15 = _br2_load((in3)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x16 = _br2_load((in3)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x17 = _br2_load((in3)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x18 = _br2_load((in3)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x19 = _br2_load((in3)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  x20 = _br2_load((in4)+((uintptr_t)0ULL), sizeof(uintptr_t));
  x21 = _br2_load((in4)+((uintptr_t)8ULL), sizeof(uintptr_t));
  x22 = _br2_load((in4)+((uintptr_t)16ULL), sizeof(uintptr_t));
  x23 = _br2_load((in4)+((uintptr_t)24ULL), sizeof(uintptr_t));
  x24 = _br2_load((in4)+((uintptr_t)32ULL), sizeof(uintptr_t));
  x25 = _br2_load((in4)+((uintptr_t)40ULL), sizeof(uintptr_t));
  /*skip*/
  /*skip*/
  x26 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL);
  x27 = ((x26)>>((uintptr_t)63ULL))&((x7)&((uintptr_t)1ULL));
  x28 = ((in0)^((uintptr_t)18446744073709551615ULL))+((uintptr_t)1ULL);
  x29 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x30 = (x29)^((uintptr_t)18446744073709551615ULL);
  x31 = ((x28)&(x29))|((in0)&(x30));
  x32 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x33 = (x32)^((uintptr_t)18446744073709551615ULL);
  x34 = ((x7)&(x32))|((x0)&(x33));
  x35 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x36 = (x35)^((uintptr_t)18446744073709551615ULL);
  x37 = ((x8)&(x35))|((x1)&(x36));
  x38 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x39 = (x38)^((uintptr_t)18446744073709551615ULL);
  x40 = ((x9)&(x38))|((x2)&(x39));
  x41 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x42 = (x41)^((uintptr_t)18446744073709551615ULL);
  x43 = ((x10)&(x41))|((x3)&(x42));
  x44 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x45 = (x44)^((uintptr_t)18446744073709551615ULL);
  x46 = ((x11)&(x44))|((x4)&(x45));
  x47 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x48 = (x47)^((uintptr_t)18446744073709551615ULL);
  x49 = ((x12)&(x47))|((x5)&(x48));
  x50 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x51 = (x50)^((uintptr_t)18446744073709551615ULL);
  x52 = ((x13)&(x50))|((x6)&(x51));
  x53 = ((uintptr_t)1ULL)+((x0)^((uintptr_t)18446744073709551615ULL));
  x54 = (uintptr_t)((x53)<((uintptr_t)1ULL));
  x55 = (x54)+((x1)^((uintptr_t)18446744073709551615ULL));
  x56 = (uintptr_t)((x55)<((x1)^((uintptr_t)18446744073709551615ULL)));
  x57 = (x56)+((x2)^((uintptr_t)18446744073709551615ULL));
  x58 = (uintptr_t)((x57)<((x2)^((uintptr_t)18446744073709551615ULL)));
  x59 = (x58)+((x3)^((uintptr_t)18446744073709551615ULL));
  x60 = (uintptr_t)((x59)<((x3)^((uintptr_t)18446744073709551615ULL)));
  x61 = (x60)+((x4)^((uintptr_t)18446744073709551615ULL));
  x62 = (uintptr_t)((x61)<((x4)^((uintptr_t)18446744073709551615ULL)));
  x63 = (x62)+((x5)^((uintptr_t)18446744073709551615ULL));
  x64 = (uintptr_t)((x63)<((x5)^((uintptr_t)18446744073709551615ULL)));
  x65 = (x64)+((x6)^((uintptr_t)18446744073709551615ULL));
  x66 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x67 = (x66)^((uintptr_t)18446744073709551615ULL);
  x68 = ((x53)&(x66))|((x7)&(x67));
  x69 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x70 = (x69)^((uintptr_t)18446744073709551615ULL);
  x71 = ((x55)&(x69))|((x8)&(x70));
  x72 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x73 = (x72)^((uintptr_t)18446744073709551615ULL);
  x74 = ((x57)&(x72))|((x9)&(x73));
  x75 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x76 = (x75)^((uintptr_t)18446744073709551615ULL);
  x77 = ((x59)&(x75))|((x10)&(x76));
  x78 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x79 = (x78)^((uintptr_t)18446744073709551615ULL);
  x80 = ((x61)&(x78))|((x11)&(x79));
  x81 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x82 = (x81)^((uintptr_t)18446744073709551615ULL);
  x83 = ((x63)&(x81))|((x12)&(x82));
  x84 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x85 = (x84)^((uintptr_t)18446744073709551615ULL);
  x86 = ((x65)&(x84))|((x13)&(x85));
  x87 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x88 = (x87)^((uintptr_t)18446744073709551615ULL);
  x89 = ((x20)&(x87))|((x14)&(x88));
  x90 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x91 = (x90)^((uintptr_t)18446744073709551615ULL);
  x92 = ((x21)&(x90))|((x15)&(x91));
  x93 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x94 = (x93)^((uintptr_t)18446744073709551615ULL);
  x95 = ((x22)&(x93))|((x16)&(x94));
  x96 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x97 = (x96)^((uintptr_t)18446744073709551615ULL);
  x98 = ((x23)&(x96))|((x17)&(x97));
  x99 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x100 = (x99)^((uintptr_t)18446744073709551615ULL);
  x101 = ((x24)&(x99))|((x18)&(x100));
  x102 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x103 = (x102)^((uintptr_t)18446744073709551615ULL);
  x104 = ((x25)&(x102))|((x19)&(x103));
  x105 = (x89)+(x89);
  x106 = (uintptr_t)((x105)<(x89));
  x107 = (x106)+(x92);
  x108 = (uintptr_t)((x107)<(x92));
  x109 = (x107)+(x92);
  x110 = (uintptr_t)((x109)<(x92));
  x111 = (x108)+(x110);
  x112 = (x111)+(x95);
  x113 = (uintptr_t)((x112)<(x95));
  x114 = (x112)+(x95);
  x115 = (uintptr_t)((x114)<(x95));
  x116 = (x113)+(x115);
  x117 = (x116)+(x98);
  x118 = (uintptr_t)((x117)<(x98));
  x119 = (x117)+(x98);
  x120 = (uintptr_t)((x119)<(x98));
  x121 = (x118)+(x120);
  x122 = (x121)+(x101);
  x123 = (uintptr_t)((x122)<(x101));
  x124 = (x122)+(x101);
  x125 = (uintptr_t)((x124)<(x101));
  x126 = (x123)+(x125);
  x127 = (x126)+(x104);
  x128 = (uintptr_t)((x127)<(x104));
  x129 = (x127)+(x104);
  x130 = (uintptr_t)((x129)<(x104));
  x131 = (x128)+(x130);
  x132 = (x105)-((uintptr_t)4294967295ULL);
  x133 = (uintptr_t)((x105)<(x132));
  x134 = (x109)-((uintptr_t)18446744069414584320ULL);
  x135 = (uintptr_t)((x109)<(x134));
  x136 = (x134)-(x133);
  x137 = (uintptr_t)((x134)<(x136));
  x138 = (x135)+(x137);
  x139 = (x114)-((uintptr_t)18446744073709551614ULL);
  x140 = (uintptr_t)((x114)<(x139));
  x141 = (x139)-(x138);
  x142 = (uintptr_t)((x139)<(x141));
  x143 = (x140)+(x142);
  x144 = (x119)-((uintptr_t)18446744073709551615ULL);
  x145 = (uintptr_t)((x119)<(x144));
  x146 = (x144)-(x143);
  x147 = (uintptr_t)((x144)<(x146));
  x148 = (x145)+(x147);
  x149 = (x124)-((uintptr_t)18446744073709551615ULL);
  x150 = (uintptr_t)((x124)<(x149));
  x151 = (x149)-(x148);
  x152 = (uintptr_t)((x149)<(x151));
  x153 = (x150)+(x152);
  x154 = (x129)-((uintptr_t)18446744073709551615ULL);
  x155 = (uintptr_t)((x129)<(x154));
  x156 = (x154)-(x153);
  x157 = (uintptr_t)((x154)<(x156));
  x158 = (x155)+(x157);
  x159 = (x131)-(x158);
  x160 = (uintptr_t)((x131)<(x159));
  x161 = x19;
  x162 = x18;
  x163 = x17;
  x164 = x16;
  x165 = x15;
  x166 = x14;
  x167 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x166)));
  x168 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x165)));
  x169 = (((uintptr_t)0ULL)-(x165))-(x167);
  x170 = (uintptr_t)((((uintptr_t)0ULL)-(x165))<(x169));
  x171 = (x168)+(x170);
  x172 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x164)));
  x173 = (((uintptr_t)0ULL)-(x164))-(x171);
  x174 = (uintptr_t)((((uintptr_t)0ULL)-(x164))<(x173));
  x175 = (x172)+(x174);
  x176 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x163)));
  x177 = (((uintptr_t)0ULL)-(x163))-(x175);
  x178 = (uintptr_t)((((uintptr_t)0ULL)-(x163))<(x177));
  x179 = (x176)+(x178);
  x180 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x162)));
  x181 = (((uintptr_t)0ULL)-(x162))-(x179);
  x182 = (uintptr_t)((((uintptr_t)0ULL)-(x162))<(x181));
  x183 = (x180)+(x182);
  x184 = (uintptr_t)(((uintptr_t)0ULL)<(((uintptr_t)0ULL)-(x161)));
  x185 = (((uintptr_t)0ULL)-(x161))-(x183);
  x186 = (uintptr_t)((((uintptr_t)0ULL)-(x161))<(x185));
  x187 = (x184)+(x186);
  x188 = ((uintptr_t)-1ULL)+((uintptr_t)((x187)==((uintptr_t)0ULL)));
  x189 = (((uintptr_t)0ULL)-(x166))+((x188)&((uintptr_t)4294967295ULL));
  x190 = (uintptr_t)((x189)<(((uintptr_t)0ULL)-(x166)));
  x191 = (x190)+(x169);
  x192 = (uintptr_t)((x191)<(x169));
  x193 = (x191)+((x188)&((uintptr_t)18446744069414584320ULL));
  x194 = (uintptr_t)((x193)<((x188)&((uintptr_t)18446744069414584320ULL)));
  x195 = (x192)+(x194);
  x196 = (x195)+(x173);
  x197 = (uintptr_t)((x196)<(x173));
  x198 = (x196)+((x188)&((uintptr_t)18446744073709551614ULL));
  x199 = (uintptr_t)((x198)<((x188)&((uintptr_t)18446744073709551614ULL)));
  x200 = (x197)+(x199);
  x201 = (x200)+(x177);
  x202 = (uintptr_t)((x201)<(x177));
  x203 = (x201)+(x188);
  x204 = (uintptr_t)((x203)<(x188));
  x205 = (x202)+(x204);
  x206 = (x205)+(x181);
  x207 = (uintptr_t)((x206)<(x181));
  x208 = (x206)+(x188);
  x209 = (uintptr_t)((x208)<(x188));
  x210 = (x207)+(x209);
  x211 = (x210)+(x185);
  x212 = (x211)+(x188);
  x213 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x214 = (x213)^((uintptr_t)18446744073709551615ULL);
  x215 = ((x189)&(x213))|((x20)&(x214));
  x216 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x217 = (x216)^((uintptr_t)18446744073709551615ULL);
  x218 = ((x193)&(x216))|((x21)&(x217));
  x219 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x220 = (x219)^((uintptr_t)18446744073709551615ULL);
  x221 = ((x198)&(x219))|((x22)&(x220));
  x222 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x223 = (x222)^((uintptr_t)18446744073709551615ULL);
  x224 = ((x203)&(x222))|((x23)&(x223));
  x225 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x226 = (x225)^((uintptr_t)18446744073709551615ULL);
  x227 = ((x208)&(x225))|((x24)&(x226));
  x228 = ((uintptr_t)-1ULL)+((uintptr_t)((x27)==((uintptr_t)0ULL)));
  x229 = (x228)^((uintptr_t)18446744073709551615ULL);
  x230 = ((x212)&(x228))|((x25)&(x229));
  x231 = (x68)&((uintptr_t)1ULL);
  x232 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x233 = (x232)^((uintptr_t)18446744073709551615ULL);
  x234 = ((x34)&(x232))|(((uintptr_t)0ULL)&(x233));
  x235 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x236 = (x235)^((uintptr_t)18446744073709551615ULL);
  x237 = ((x37)&(x235))|(((uintptr_t)0ULL)&(x236));
  x238 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x239 = (x238)^((uintptr_t)18446744073709551615ULL);
  x240 = ((x40)&(x238))|(((uintptr_t)0ULL)&(x239));
  x241 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x242 = (x241)^((uintptr_t)18446744073709551615ULL);
  x243 = ((x43)&(x241))|(((uintptr_t)0ULL)&(x242));
  x244 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x245 = (x244)^((uintptr_t)18446744073709551615ULL);
  x246 = ((x46)&(x244))|(((uintptr_t)0ULL)&(x245));
  x247 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x248 = (x247)^((uintptr_t)18446744073709551615ULL);
  x249 = ((x49)&(x247))|(((uintptr_t)0ULL)&(x248));
  x250 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x251 = (x250)^((uintptr_t)18446744073709551615ULL);
  x252 = ((x52)&(x250))|(((uintptr_t)0ULL)&(x251));
  x253 = (x68)+(x234);
  x254 = (uintptr_t)((x253)<(x68));
  x255 = (x254)+(x71);
  x256 = (uintptr_t)((x255)<(x71));
  x257 = (x255)+(x237);
  x258 = (uintptr_t)((x257)<(x237));
  x259 = (x256)+(x258);
  x260 = (x259)+(x74);
  x261 = (uintptr_t)((x260)<(x74));
  x262 = (x260)+(x240);
  x263 = (uintptr_t)((x262)<(x240));
  x264 = (x261)+(x263);
  x265 = (x264)+(x77);
  x266 = (uintptr_t)((x265)<(x77));
  x267 = (x265)+(x243);
  x268 = (uintptr_t)((x267)<(x243));
  x269 = (x266)+(x268);
  x270 = (x269)+(x80);
  x271 = (uintptr_t)((x270)<(x80));
  x272 = (x270)+(x246);
  x273 = (uintptr_t)((x272)<(x246));
  x274 = (x271)+(x273);
  x275 = (x274)+(x83);
  x276 = (uintptr_t)((x275)<(x83));
  x277 = (x275)+(x249);
  x278 = (uintptr_t)((x277)<(x249));
  x279 = (x276)+(x278);
  x280 = (x279)+(x86);
  x281 = (x280)+(x252);
  x282 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x283 = (x282)^((uintptr_t)18446744073709551615ULL);
  x284 = ((x89)&(x282))|(((uintptr_t)0ULL)&(x283));
  x285 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x286 = (x285)^((uintptr_t)18446744073709551615ULL);
  x287 = ((x92)&(x285))|(((uintptr_t)0ULL)&(x286));
  x288 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x289 = (x288)^((uintptr_t)18446744073709551615ULL);
  x290 = ((x95)&(x288))|(((uintptr_t)0ULL)&(x289));
  x291 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x292 = (x291)^((uintptr_t)18446744073709551615ULL);
  x293 = ((x98)&(x291))|(((uintptr_t)0ULL)&(x292));
  x294 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x295 = (x294)^((uintptr_t)18446744073709551615ULL);
  x296 = ((x101)&(x294))|(((uintptr_t)0ULL)&(x295));
  x297 = ((uintptr_t)-1ULL)+((uintptr_t)((x231)==((uintptr_t)0ULL)));
  x298 = (x297)^((uintptr_t)18446744073709551615ULL);
  x299 = ((x104)&(x297))|(((uintptr_t)0ULL)&(x298));
  x300 = (x215)+(x284);
  x301 = (uintptr_t)((x300)<(x215));
  x302 = (x301)+(x218);
  x303 = (uintptr_t)((x302)<(x218));
  x304 = (x302)+(x287);
  x305 = (uintptr_t)((x304)<(x287));
  x306 = (x303)+(x305);
  x307 = (x306)+(x221);
  x308 = (uintptr_t)((x307)<(x221));
  x309 = (x307)+(x290);
  x310 = (uintptr_t)((x309)<(x290));
  x311 = (x308)+(x310);
  x312 = (x311)+(x224);
  x313 = (uintptr_t)((x312)<(x224));
  x314 = (x312)+(x293);
  x315 = (uintptr_t)((x314)<(x293));
  x316 = (x313)+(x315);
  x317 = (x316)+(x227);
  x318 = (uintptr_t)((x317)<(x227));
  x319 = (x317)+(x296);
  x320 = (uintptr_t)((x319)<(x296));
  x321 = (x318)+(x320);
  x322 = (x321)+(x230);
  x323 = (uintptr_t)((x322)<(x230));
  x324 = (x322)+(x299);
  x325 = (uintptr_t)((x324)<(x299));
  x326 = (x323)+(x325);
  x327 = (x300)-((uintptr_t)4294967295ULL);
  x328 = (uintptr_t)((x300)<(x327));
  x329 = (x304)-((uintptr_t)18446744069414584320ULL);
  x330 = (uintptr_t)((x304)<(x329));
  x331 = (x329)-(x328);
  x332 = (uintptr_t)((x329)<(x331));
  x333 = (x330)+(x332);
  x334 = (x309)-((uintptr_t)18446744073709551614ULL);
  x335 = (uintptr_t)((x309)<(x334));
  x336 = (x334)-(x333);
  x337 = (uintptr_t)((x334)<(x336));
  x338 = (x335)+(x337);
  x339 = (x314)-((uintptr_t)18446744073709551615ULL);
  x340 = (uintptr_t)((x314)<(x339));
  x341 = (x339)-(x338);
  x342 = (uintptr_t)((x339)<(x341));
  x343 = (x340)+(x342);
  x344 = (x319)-((uintptr_t)18446744073709551615ULL);
  x345 = (uintptr_t)((x319)<(x344));
  x346 = (x344)-(x343);
  x347 = (uintptr_t)((x344)<(x346));
  x348 = (x345)+(x347);
  x349 = (x324)-((uintptr_t)18446744073709551615ULL);
  x350 = (uintptr_t)((x324)<(x349));
  x351 = (x349)-(x348);
  x352 = (uintptr_t)((x349)<(x351));
  x353 = (x350)+(x352);
  x354 = (x326)-(x353);
  x355 = (uintptr_t)((x326)<(x354));
  x356 = (x31)+((uintptr_t)1ULL);
  x357 = ((x253)>>((uintptr_t)1ULL))|((x257)<<((uintptr_t)63ULL));
  x358 = ((x257)>>((uintptr_t)1ULL))|((x262)<<((uintptr_t)63ULL));
  x359 = ((x262)>>((uintptr_t)1ULL))|((x267)<<((uintptr_t)63ULL));
  x360 = ((x267)>>((uintptr_t)1ULL))|((x272)<<((uintptr_t)63ULL));
  x361 = ((x272)>>((uintptr_t)1ULL))|((x277)<<((uintptr_t)63ULL));
  x362 = ((x277)>>((uintptr_t)1ULL))|((x281)<<((uintptr_t)63ULL));
  x363 = ((x281)&((uintptr_t)9223372036854775808ULL))|((x281)>>((uintptr_t)1ULL));
  x364 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL)));
  x365 = (x364)^((uintptr_t)18446744073709551615ULL);
  x366 = ((x105)&(x364))|((x132)&(x365));
  x367 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL)));
  x368 = (x367)^((uintptr_t)18446744073709551615ULL);
  x369 = ((x109)&(x367))|((x136)&(x368));
  x370 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL)));
  x371 = (x370)^((uintptr_t)18446744073709551615ULL);
  x372 = ((x114)&(x370))|((x141)&(x371));
  x373 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL)));
  x374 = (x373)^((uintptr_t)18446744073709551615ULL);
  x375 = ((x119)&(x373))|((x146)&(x374));
  x376 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL)));
  x377 = (x376)^((uintptr_t)18446744073709551615ULL);
  x378 = ((x124)&(x376))|((x151)&(x377));
  x379 = ((uintptr_t)-1ULL)+((uintptr_t)((x160)==((uintptr_t)0ULL)));
  x380 = (x379)^((uintptr_t)18446744073709551615ULL);
  x381 = ((x129)&(x379))|((x156)&(x380));
  x382 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL)));
  x383 = (x382)^((uintptr_t)18446744073709551615ULL);
  x384 = ((x300)&(x382))|((x327)&(x383));
  x385 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL)));
  x386 = (x385)^((uintptr_t)18446744073709551615ULL);
  x387 = ((x304)&(x385))|((x331)&(x386));
  x388 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL)));
  x389 = (x388)^((uintptr_t)18446744073709551615ULL);
  x390 = ((x309)&(x388))|((x336)&(x389));
  x391 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL)));
  x392 = (x391)^((uintptr_t)18446744073709551615ULL);
  x393 = ((x314)&(x391))|((x341)&(x392));
  x394 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL)));
  x395 = (x394)^((uintptr_t)18446744073709551615ULL);
  x396 = ((x319)&(x394))|((x346)&(x395));
  x397 = ((uintptr_t)-1ULL)+((uintptr_t)((x355)==((uintptr_t)0ULL)));
  x398 = (x397)^((uintptr_t)18446744073709551615ULL);
  x399 = ((x324)&(x397))|((x351)&(x398));
  x400 = x356;
  x401 = x34;
  x402 = x37;
  x403 = x40;
  x404 = x43;
  x405 = x46;
  x406 = x49;
  x407 = x52;
  /*skip*/
  x408 = x357;
  x409 = x358;
  x410 = x359;
  x411 = x360;
  x412 = x361;
  x413 = x362;
  x414 = x363;
  /*skip*/
  x415 = x366;
  x416 = x369;
  x417 = x372;
  x418 = x375;
  x419 = x378;
  x420 = x381;
  /*skip*/
  x421 = x384;
  x422 = x387;
  x423 = x390;
  x424 = x393;
  x425 = x396;
  x426 = x399;
  /*skip*/
  out0 = x400;
  _br2_store((out1)+((uintptr_t)0ULL), x401, sizeof(uintptr_t));
  _br2_store((out1)+((uintptr_t)8ULL), x402, sizeof(uintptr_t));
  _br2_store((out1)+((uintptr_t)16ULL), x403, sizeof(uintptr_t));
  _br2_store((out1)+((uintptr_t)24ULL), x404, sizeof(uintptr_t));
  _br2_store((out1)+((uintptr_t)32ULL), x405, sizeof(uintptr_t));
  _br2_store((out1)+((uintptr_t)40ULL), x406, sizeof(uintptr_t));
  _br2_store((out1)+((uintptr_t)48ULL), x407, sizeof(uintptr_t));
  /*skip*/
  _br2_store((out2)+((uintptr_t)0ULL), x408, sizeof(uintptr_t));
  _br2_store((out2)+((uintptr_t)8ULL), x409, sizeof(uintptr_t));
  _br2_store((out2)+((uintptr_t)16ULL), x410, sizeof(uintptr_t));
  _br2_store((out2)+((uintptr_t)24ULL), x411, sizeof(uintptr_t));
  _br2_store((out2)+((uintptr_t)32ULL), x412, sizeof(uintptr_t));
  _br2_store((out2)+((uintptr_t)40ULL), x413, sizeof(uintptr_t));
  _br2_store((out2)+((uintptr_t)48ULL), x414, sizeof(uintptr_t));
  /*skip*/
  _br2_store((out3)+((uintptr_t)0ULL), x415, sizeof(uintptr_t));
  _br2_store((out3)+((uintptr_t)8ULL), x416, sizeof(uintptr_t));
  _br2_store((out3)+((uintptr_t)16ULL), x417, sizeof(uintptr_t));
  _br2_store((out3)+((uintptr_t)24ULL), x418, sizeof(uintptr_t));
  _br2_store((out3)+((uintptr_t)32ULL), x419, sizeof(uintptr_t));
  _br2_store((out3)+((uintptr_t)40ULL), x420, sizeof(uintptr_t));
  /*skip*/
  _br2_store((out4)+((uintptr_t)0ULL), x421, sizeof(uintptr_t));
  _br2_store((out4)+((uintptr_t)8ULL), x422, sizeof(uintptr_t));
  _br2_store((out4)+((uintptr_t)16ULL), x423, sizeof(uintptr_t));
  _br2_store((out4)+((uintptr_t)24ULL), x424, sizeof(uintptr_t));
  _br2_store((out4)+((uintptr_t)32ULL), x425, sizeof(uintptr_t));
  _br2_store((out4)+((uintptr_t)40ULL), x426, sizeof(uintptr_t));
  /*skip*/
  return out0;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_divstep(uint64_t* out1, uint64_t out2[7], uint64_t out3[7], uint64_t out4[6], uint64_t out5[6], uint64_t arg1, const uint64_t arg2[7], const uint64_t arg3[7], const uint64_t arg4[6], const uint64_t arg5[6]) {
  *out1 = (uint64_t)internal_fiat_p384_divstep((uintptr_t)out2, (uintptr_t)out3, (uintptr_t)out4, (uintptr_t)out5, (uintptr_t)arg1, (uintptr_t)arg2, (uintptr_t)arg3, (uintptr_t)arg4, (uintptr_t)arg5);
}


/*
 * Input Bounds:
 * Output Bounds:
 *   out0: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
 */
static
void internal_fiat_p384_divstep_precomp(uintptr_t out0) {
  uintptr_t x0, x1, x2, x3, x4, x5;
  /*skip*/
  x0 = (uintptr_t)18444092055957377023ULL;
  x1 = (uintptr_t)765255797953535ULL;
  x2 = (uintptr_t)18446423016314148863ULL;
  x3 = (uintptr_t)708085488300031ULL;
  x4 = (uintptr_t)1693247907103744ULL;
  x5 = (uintptr_t)18445697338640138240ULL;
  /*skip*/
  _br2_store((out0)+((uintptr_t)0ULL), x0, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)8ULL), x1, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)16ULL), x2, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)24ULL), x3, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)32ULL), x4, sizeof(uintptr_t));
  _br2_store((out0)+((uintptr_t)40ULL), x5, sizeof(uintptr_t));
  /*skip*/
  return;
}

/* NOTE: The following wrapper function is not covered by Coq proofs */
static void fiat_p384_divstep_precomp(uint64_t out1[6]) {
  internal_fiat_p384_divstep_precomp((uintptr_t)out1);
}