λ x x0 : word64 * word64 * word64 * word64 * word64 * word64 * word64, Interp-η (λ var : Syntax.base_type → Type, λ '(x14, x15, x13, x11, x9, x7, x5, (x26, x27, x25, x23, x21, x19, x17))%core, uint64_t x29, uint64_t x30 = mulx_u64(x5, x17); uint64_t x32, uint64_t x33 = mulx_u64(x5, x19); uint64_t x35, uint64_t x36 = mulx_u64(x5, x21); uint64_t x38, uint64_t x39 = mulx_u64(x5, x23); uint64_t x41, uint64_t x42 = mulx_u64(x5, x25); uint64_t x44, uint64_t x45 = mulx_u64(x5, x27); uint64_t x47, uint64_t x48 = mulx_u64(x5, x26); uint64_t x50, uint8_t x51 = addcarryx_u64(0x0, x30, x32); uint64_t x53, uint8_t x54 = addcarryx_u64(x51, x33, x35); uint64_t x56, uint8_t x57 = addcarryx_u64(x54, x36, x38); uint64_t x59, uint8_t x60 = addcarryx_u64(x57, x39, x41); uint64_t x62, uint8_t x63 = addcarryx_u64(x60, x42, x44); uint64_t x65, uint8_t x66 = addcarryx_u64(x63, x45, x47); uint64_t x68, uint8_t _ = addcarryx_u64(0x0, x66, x48); uint64_t x71, uint64_t _ = mulx_u64(x29, 0xcf3cf3cf3cf3cf3dL); uint64_t x74, uint64_t x75 = mulx_u64(x71, 0xffffffffffffffebL); uint64_t x77, uint64_t x78 = mulx_u64(x71, 0xffffffffffffffffL); uint64_t x80, uint64_t x81 = mulx_u64(x71, 0xffffffffffffffffL); uint64_t x83, uint64_t x84 = mulx_u64(x71, 0xffffffffffffffffL); uint64_t x86, uint64_t x87 = mulx_u64(x71, 0xffffffffffffffffL); uint64_t x89, uint64_t x90 = mulx_u64(x71, 0xffffffffffffffffL); uint64_t x92, uint8_t x93 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x71, 0x1f); uint64_t x95, uint8_t x96 = addcarryx_u64(0x0, x75, x77); uint64_t x98, uint8_t x99 = addcarryx_u64(x96, x78, x80); uint64_t x101, uint8_t x102 = addcarryx_u64(x99, x81, x83); uint64_t x104, uint8_t x105 = addcarryx_u64(x102, x84, x86); uint64_t x107, uint8_t x108 = addcarryx_u64(x105, x87, x89); uint64_t x110, uint8_t x111 = addcarryx_u64(x108, x90, x92); uint8_t x112 = (x111 + x93); uint64_t _, uint8_t x115 = addcarryx_u64(0x0, x29, x74); uint64_t x117, uint8_t x118 = addcarryx_u64(x115, x50, x95); uint64_t x120, uint8_t x121 = addcarryx_u64(x118, x53, x98); uint64_t x123, uint8_t x124 = addcarryx_u64(x121, x56, x101); uint64_t x126, uint8_t x127 = addcarryx_u64(x124, x59, x104); uint64_t x129, uint8_t x130 = addcarryx_u64(x127, x62, x107); uint64_t x132, uint8_t x133 = addcarryx_u64(x130, x65, x110); uint64_t x135, uint8_t x136 = addcarryx_u64(x133, x68, x112); uint64_t x138, uint64_t x139 = mulx_u64(x7, x17); uint64_t x141, uint64_t x142 = mulx_u64(x7, x19); uint64_t x144, uint64_t x145 = mulx_u64(x7, x21); uint64_t x147, uint64_t x148 = mulx_u64(x7, x23); uint64_t x150, uint64_t x151 = mulx_u64(x7, x25); uint64_t x153, uint64_t x154 = mulx_u64(x7, x27); uint64_t x156, uint64_t x157 = mulx_u64(x7, x26); uint64_t x159, uint8_t x160 = addcarryx_u64(0x0, x139, x141); uint64_t x162, uint8_t x163 = addcarryx_u64(x160, x142, x144); uint64_t x165, uint8_t x166 = addcarryx_u64(x163, x145, x147); uint64_t x168, uint8_t x169 = addcarryx_u64(x166, x148, x150); uint64_t x171, uint8_t x172 = addcarryx_u64(x169, x151, x153); uint64_t x174, uint8_t x175 = addcarryx_u64(x172, x154, x156); uint64_t x177, uint8_t _ = addcarryx_u64(0x0, x175, x157); uint64_t x180, uint8_t x181 = addcarryx_u64(0x0, x117, x138); uint64_t x183, uint8_t x184 = addcarryx_u64(x181, x120, x159); uint64_t x186, uint8_t x187 = addcarryx_u64(x184, x123, x162); uint64_t x189, uint8_t x190 = addcarryx_u64(x187, x126, x165); uint64_t x192, uint8_t x193 = addcarryx_u64(x190, x129, x168); uint64_t x195, uint8_t x196 = addcarryx_u64(x193, x132, x171); uint64_t x198, uint8_t x199 = addcarryx_u64(x196, x135, x174); uint64_t x201, uint8_t x202 = addcarryx_u64(x199, x136, x177); uint64_t x204, uint64_t _ = mulx_u64(x180, 0xcf3cf3cf3cf3cf3dL); uint64_t x207, uint64_t x208 = mulx_u64(x204, 0xffffffffffffffebL); uint64_t x210, uint64_t x211 = mulx_u64(x204, 0xffffffffffffffffL); uint64_t x213, uint64_t x214 = mulx_u64(x204, 0xffffffffffffffffL); uint64_t x216, uint64_t x217 = mulx_u64(x204, 0xffffffffffffffffL); uint64_t x219, uint64_t x220 = mulx_u64(x204, 0xffffffffffffffffL); uint64_t x222, uint64_t x223 = mulx_u64(x204, 0xffffffffffffffffL); uint64_t x225, uint8_t x226 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x204, 0x1f); uint64_t x228, uint8_t x229 = addcarryx_u64(0x0, x208, x210); uint64_t x231, uint8_t x232 = addcarryx_u64(x229, x211, x213); uint64_t x234, uint8_t x235 = addcarryx_u64(x232, x214, x216); uint64_t x237, uint8_t x238 = addcarryx_u64(x235, x217, x219); uint64_t x240, uint8_t x241 = addcarryx_u64(x238, x220, x222); uint64_t x243, uint8_t x244 = addcarryx_u64(x241, x223, x225); uint8_t x245 = (x244 + x226); uint64_t _, uint8_t x248 = addcarryx_u64(0x0, x180, x207); uint64_t x250, uint8_t x251 = addcarryx_u64(x248, x183, x228); uint64_t x253, uint8_t x254 = addcarryx_u64(x251, x186, x231); uint64_t x256, uint8_t x257 = addcarryx_u64(x254, x189, x234); uint64_t x259, uint8_t x260 = addcarryx_u64(x257, x192, x237); uint64_t x262, uint8_t x263 = addcarryx_u64(x260, x195, x240); uint64_t x265, uint8_t x266 = addcarryx_u64(x263, x198, x243); uint64_t x268, uint8_t x269 = addcarryx_u64(x266, x201, x245); uint8_t x270 = (x269 + x202); uint64_t x272, uint64_t x273 = mulx_u64(x9, x17); uint64_t x275, uint64_t x276 = mulx_u64(x9, x19); uint64_t x278, uint64_t x279 = mulx_u64(x9, x21); uint64_t x281, uint64_t x282 = mulx_u64(x9, x23); uint64_t x284, uint64_t x285 = mulx_u64(x9, x25); uint64_t x287, uint64_t x288 = mulx_u64(x9, x27); uint64_t x290, uint64_t x291 = mulx_u64(x9, x26); uint64_t x293, uint8_t x294 = addcarryx_u64(0x0, x273, x275); uint64_t x296, uint8_t x297 = addcarryx_u64(x294, x276, x278); uint64_t x299, uint8_t x300 = addcarryx_u64(x297, x279, x281); uint64_t x302, uint8_t x303 = addcarryx_u64(x300, x282, x284); uint64_t x305, uint8_t x306 = addcarryx_u64(x303, x285, x287); uint64_t x308, uint8_t x309 = addcarryx_u64(x306, x288, x290); uint64_t x311, uint8_t _ = addcarryx_u64(0x0, x309, x291); uint64_t x314, uint8_t x315 = addcarryx_u64(0x0, x250, x272); uint64_t x317, uint8_t x318 = addcarryx_u64(x315, x253, x293); uint64_t x320, uint8_t x321 = addcarryx_u64(x318, x256, x296); uint64_t x323, uint8_t x324 = addcarryx_u64(x321, x259, x299); uint64_t x326, uint8_t x327 = addcarryx_u64(x324, x262, x302); uint64_t x329, uint8_t x330 = addcarryx_u64(x327, x265, x305); uint64_t x332, uint8_t x333 = addcarryx_u64(x330, x268, x308); uint64_t x335, uint8_t x336 = addcarryx_u64(x333, x270, x311); uint64_t x338, uint64_t _ = mulx_u64(x314, 0xcf3cf3cf3cf3cf3dL); uint64_t x341, uint64_t x342 = mulx_u64(x338, 0xffffffffffffffebL); uint64_t x344, uint64_t x345 = mulx_u64(x338, 0xffffffffffffffffL); uint64_t x347, uint64_t x348 = mulx_u64(x338, 0xffffffffffffffffL); uint64_t x350, uint64_t x351 = mulx_u64(x338, 0xffffffffffffffffL); uint64_t x353, uint64_t x354 = mulx_u64(x338, 0xffffffffffffffffL); uint64_t x356, uint64_t x357 = mulx_u64(x338, 0xffffffffffffffffL); uint64_t x359, uint8_t x360 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x338, 0x1f); uint64_t x362, uint8_t x363 = addcarryx_u64(0x0, x342, x344); uint64_t x365, uint8_t x366 = addcarryx_u64(x363, x345, x347); uint64_t x368, uint8_t x369 = addcarryx_u64(x366, x348, x350); uint64_t x371, uint8_t x372 = addcarryx_u64(x369, x351, x353); uint64_t x374, uint8_t x375 = addcarryx_u64(x372, x354, x356); uint64_t x377, uint8_t x378 = addcarryx_u64(x375, x357, x359); uint8_t x379 = (x378 + x360); uint64_t _, uint8_t x382 = addcarryx_u64(0x0, x314, x341); uint64_t x384, uint8_t x385 = addcarryx_u64(x382, x317, x362); uint64_t x387, uint8_t x388 = addcarryx_u64(x385, x320, x365); uint64_t x390, uint8_t x391 = addcarryx_u64(x388, x323, x368); uint64_t x393, uint8_t x394 = addcarryx_u64(x391, x326, x371); uint64_t x396, uint8_t x397 = addcarryx_u64(x394, x329, x374); uint64_t x399, uint8_t x400 = addcarryx_u64(x397, x332, x377); uint64_t x402, uint8_t x403 = addcarryx_u64(x400, x335, x379); uint8_t x404 = (x403 + x336); uint64_t x406, uint64_t x407 = mulx_u64(x11, x17); uint64_t x409, uint64_t x410 = mulx_u64(x11, x19); uint64_t x412, uint64_t x413 = mulx_u64(x11, x21); uint64_t x415, uint64_t x416 = mulx_u64(x11, x23); uint64_t x418, uint64_t x419 = mulx_u64(x11, x25); uint64_t x421, uint64_t x422 = mulx_u64(x11, x27); uint64_t x424, uint64_t x425 = mulx_u64(x11, x26); uint64_t x427, uint8_t x428 = addcarryx_u64(0x0, x407, x409); uint64_t x430, uint8_t x431 = addcarryx_u64(x428, x410, x412); uint64_t x433, uint8_t x434 = addcarryx_u64(x431, x413, x415); uint64_t x436, uint8_t x437 = addcarryx_u64(x434, x416, x418); uint64_t x439, uint8_t x440 = addcarryx_u64(x437, x419, x421); uint64_t x442, uint8_t x443 = addcarryx_u64(x440, x422, x424); uint64_t x445, uint8_t _ = addcarryx_u64(0x0, x443, x425); uint64_t x448, uint8_t x449 = addcarryx_u64(0x0, x384, x406); uint64_t x451, uint8_t x452 = addcarryx_u64(x449, x387, x427); uint64_t x454, uint8_t x455 = addcarryx_u64(x452, x390, x430); uint64_t x457, uint8_t x458 = addcarryx_u64(x455, x393, x433); uint64_t x460, uint8_t x461 = addcarryx_u64(x458, x396, x436); uint64_t x463, uint8_t x464 = addcarryx_u64(x461, x399, x439); uint64_t x466, uint8_t x467 = addcarryx_u64(x464, x402, x442); uint64_t x469, uint8_t x470 = addcarryx_u64(x467, x404, x445); uint64_t x472, uint64_t _ = mulx_u64(x448, 0xcf3cf3cf3cf3cf3dL); uint64_t x475, uint64_t x476 = mulx_u64(x472, 0xffffffffffffffebL); uint64_t x478, uint64_t x479 = mulx_u64(x472, 0xffffffffffffffffL); uint64_t x481, uint64_t x482 = mulx_u64(x472, 0xffffffffffffffffL); uint64_t x484, uint64_t x485 = mulx_u64(x472, 0xffffffffffffffffL); uint64_t x487, uint64_t x488 = mulx_u64(x472, 0xffffffffffffffffL); uint64_t x490, uint64_t x491 = mulx_u64(x472, 0xffffffffffffffffL); uint64_t x493, uint8_t x494 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x472, 0x1f); uint64_t x496, uint8_t x497 = addcarryx_u64(0x0, x476, x478); uint64_t x499, uint8_t x500 = addcarryx_u64(x497, x479, x481); uint64_t x502, uint8_t x503 = addcarryx_u64(x500, x482, x484); uint64_t x505, uint8_t x506 = addcarryx_u64(x503, x485, x487); uint64_t x508, uint8_t x509 = addcarryx_u64(x506, x488, x490); uint64_t x511, uint8_t x512 = addcarryx_u64(x509, x491, x493); uint8_t x513 = (x512 + x494); uint64_t _, uint8_t x516 = addcarryx_u64(0x0, x448, x475); uint64_t x518, uint8_t x519 = addcarryx_u64(x516, x451, x496); uint64_t x521, uint8_t x522 = addcarryx_u64(x519, x454, x499); uint64_t x524, uint8_t x525 = addcarryx_u64(x522, x457, x502); uint64_t x527, uint8_t x528 = addcarryx_u64(x525, x460, x505); uint64_t x530, uint8_t x531 = addcarryx_u64(x528, x463, x508); uint64_t x533, uint8_t x534 = addcarryx_u64(x531, x466, x511); uint64_t x536, uint8_t x537 = addcarryx_u64(x534, x469, x513); uint8_t x538 = (x537 + x470); uint64_t x540, uint64_t x541 = mulx_u64(x13, x17); uint64_t x543, uint64_t x544 = mulx_u64(x13, x19); uint64_t x546, uint64_t x547 = mulx_u64(x13, x21); uint64_t x549, uint64_t x550 = mulx_u64(x13, x23); uint64_t x552, uint64_t x553 = mulx_u64(x13, x25); uint64_t x555, uint64_t x556 = mulx_u64(x13, x27); uint64_t x558, uint64_t x559 = mulx_u64(x13, x26); uint64_t x561, uint8_t x562 = addcarryx_u64(0x0, x541, x543); uint64_t x564, uint8_t x565 = addcarryx_u64(x562, x544, x546); uint64_t x567, uint8_t x568 = addcarryx_u64(x565, x547, x549); uint64_t x570, uint8_t x571 = addcarryx_u64(x568, x550, x552); uint64_t x573, uint8_t x574 = addcarryx_u64(x571, x553, x555); uint64_t x576, uint8_t x577 = addcarryx_u64(x574, x556, x558); uint64_t x579, uint8_t _ = addcarryx_u64(0x0, x577, x559); uint64_t x582, uint8_t x583 = addcarryx_u64(0x0, x518, x540); uint64_t x585, uint8_t x586 = addcarryx_u64(x583, x521, x561); uint64_t x588, uint8_t x589 = addcarryx_u64(x586, x524, x564); uint64_t x591, uint8_t x592 = addcarryx_u64(x589, x527, x567); uint64_t x594, uint8_t x595 = addcarryx_u64(x592, x530, x570); uint64_t x597, uint8_t x598 = addcarryx_u64(x595, x533, x573); uint64_t x600, uint8_t x601 = addcarryx_u64(x598, x536, x576); uint64_t x603, uint8_t x604 = addcarryx_u64(x601, x538, x579); uint64_t x606, uint64_t _ = mulx_u64(x582, 0xcf3cf3cf3cf3cf3dL); uint64_t x609, uint64_t x610 = mulx_u64(x606, 0xffffffffffffffebL); uint64_t x612, uint64_t x613 = mulx_u64(x606, 0xffffffffffffffffL); uint64_t x615, uint64_t x616 = mulx_u64(x606, 0xffffffffffffffffL); uint64_t x618, uint64_t x619 = mulx_u64(x606, 0xffffffffffffffffL); uint64_t x621, uint64_t x622 = mulx_u64(x606, 0xffffffffffffffffL); uint64_t x624, uint64_t x625 = mulx_u64(x606, 0xffffffffffffffffL); uint64_t x627, uint8_t x628 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x606, 0x1f); uint64_t x630, uint8_t x631 = addcarryx_u64(0x0, x610, x612); uint64_t x633, uint8_t x634 = addcarryx_u64(x631, x613, x615); uint64_t x636, uint8_t x637 = addcarryx_u64(x634, x616, x618); uint64_t x639, uint8_t x640 = addcarryx_u64(x637, x619, x621); uint64_t x642, uint8_t x643 = addcarryx_u64(x640, x622, x624); uint64_t x645, uint8_t x646 = addcarryx_u64(x643, x625, x627); uint8_t x647 = (x646 + x628); uint64_t _, uint8_t x650 = addcarryx_u64(0x0, x582, x609); uint64_t x652, uint8_t x653 = addcarryx_u64(x650, x585, x630); uint64_t x655, uint8_t x656 = addcarryx_u64(x653, x588, x633); uint64_t x658, uint8_t x659 = addcarryx_u64(x656, x591, x636); uint64_t x661, uint8_t x662 = addcarryx_u64(x659, x594, x639); uint64_t x664, uint8_t x665 = addcarryx_u64(x662, x597, x642); uint64_t x667, uint8_t x668 = addcarryx_u64(x665, x600, x645); uint64_t x670, uint8_t x671 = addcarryx_u64(x668, x603, x647); uint8_t x672 = (x671 + x604); uint64_t x674, uint64_t x675 = mulx_u64(x15, x17); uint64_t x677, uint64_t x678 = mulx_u64(x15, x19); uint64_t x680, uint64_t x681 = mulx_u64(x15, x21); uint64_t x683, uint64_t x684 = mulx_u64(x15, x23); uint64_t x686, uint64_t x687 = mulx_u64(x15, x25); uint64_t x689, uint64_t x690 = mulx_u64(x15, x27); uint64_t x692, uint64_t x693 = mulx_u64(x15, x26); uint64_t x695, uint8_t x696 = addcarryx_u64(0x0, x675, x677); uint64_t x698, uint8_t x699 = addcarryx_u64(x696, x678, x680); uint64_t x701, uint8_t x702 = addcarryx_u64(x699, x681, x683); uint64_t x704, uint8_t x705 = addcarryx_u64(x702, x684, x686); uint64_t x707, uint8_t x708 = addcarryx_u64(x705, x687, x689); uint64_t x710, uint8_t x711 = addcarryx_u64(x708, x690, x692); uint64_t x713, uint8_t _ = addcarryx_u64(0x0, x711, x693); uint64_t x716, uint8_t x717 = addcarryx_u64(0x0, x652, x674); uint64_t x719, uint8_t x720 = addcarryx_u64(x717, x655, x695); uint64_t x722, uint8_t x723 = addcarryx_u64(x720, x658, x698); uint64_t x725, uint8_t x726 = addcarryx_u64(x723, x661, x701); uint64_t x728, uint8_t x729 = addcarryx_u64(x726, x664, x704); uint64_t x731, uint8_t x732 = addcarryx_u64(x729, x667, x707); uint64_t x734, uint8_t x735 = addcarryx_u64(x732, x670, x710); uint64_t x737, uint8_t x738 = addcarryx_u64(x735, x672, x713); uint64_t x740, uint64_t _ = mulx_u64(x716, 0xcf3cf3cf3cf3cf3dL); uint64_t x743, uint64_t x744 = mulx_u64(x740, 0xffffffffffffffebL); uint64_t x746, uint64_t x747 = mulx_u64(x740, 0xffffffffffffffffL); uint64_t x749, uint64_t x750 = mulx_u64(x740, 0xffffffffffffffffL); uint64_t x752, uint64_t x753 = mulx_u64(x740, 0xffffffffffffffffL); uint64_t x755, uint64_t x756 = mulx_u64(x740, 0xffffffffffffffffL); uint64_t x758, uint64_t x759 = mulx_u64(x740, 0xffffffffffffffffL); uint64_t x761, uint8_t x762 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x740, 0x1f); uint64_t x764, uint8_t x765 = addcarryx_u64(0x0, x744, x746); uint64_t x767, uint8_t x768 = addcarryx_u64(x765, x747, x749); uint64_t x770, uint8_t x771 = addcarryx_u64(x768, x750, x752); uint64_t x773, uint8_t x774 = addcarryx_u64(x771, x753, x755); uint64_t x776, uint8_t x777 = addcarryx_u64(x774, x756, x758); uint64_t x779, uint8_t x780 = addcarryx_u64(x777, x759, x761); uint8_t x781 = (x780 + x762); uint64_t _, uint8_t x784 = addcarryx_u64(0x0, x716, x743); uint64_t x786, uint8_t x787 = addcarryx_u64(x784, x719, x764); uint64_t x789, uint8_t x790 = addcarryx_u64(x787, x722, x767); uint64_t x792, uint8_t x793 = addcarryx_u64(x790, x725, x770); uint64_t x795, uint8_t x796 = addcarryx_u64(x793, x728, x773); uint64_t x798, uint8_t x799 = addcarryx_u64(x796, x731, x776); uint64_t x801, uint8_t x802 = addcarryx_u64(x799, x734, x779); uint64_t x804, uint8_t x805 = addcarryx_u64(x802, x737, x781); uint8_t x806 = (x805 + x738); uint64_t x808, uint64_t x809 = mulx_u64(x14, x17); uint64_t x811, uint64_t x812 = mulx_u64(x14, x19); uint64_t x814, uint64_t x815 = mulx_u64(x14, x21); uint64_t x817, uint64_t x818 = mulx_u64(x14, x23); uint64_t x820, uint64_t x821 = mulx_u64(x14, x25); uint64_t x823, uint64_t x824 = mulx_u64(x14, x27); uint64_t x826, uint64_t x827 = mulx_u64(x14, x26); uint64_t x829, uint8_t x830 = addcarryx_u64(0x0, x809, x811); uint64_t x832, uint8_t x833 = addcarryx_u64(x830, x812, x814); uint64_t x835, uint8_t x836 = addcarryx_u64(x833, x815, x817); uint64_t x838, uint8_t x839 = addcarryx_u64(x836, x818, x820); uint64_t x841, uint8_t x842 = addcarryx_u64(x839, x821, x823); uint64_t x844, uint8_t x845 = addcarryx_u64(x842, x824, x826); uint64_t x847, uint8_t _ = addcarryx_u64(0x0, x845, x827); uint64_t x850, uint8_t x851 = addcarryx_u64(0x0, x786, x808); uint64_t x853, uint8_t x854 = addcarryx_u64(x851, x789, x829); uint64_t x856, uint8_t x857 = addcarryx_u64(x854, x792, x832); uint64_t x859, uint8_t x860 = addcarryx_u64(x857, x795, x835); uint64_t x862, uint8_t x863 = addcarryx_u64(x860, x798, x838); uint64_t x865, uint8_t x866 = addcarryx_u64(x863, x801, x841); uint64_t x868, uint8_t x869 = addcarryx_u64(x866, x804, x844); uint64_t x871, uint8_t x872 = addcarryx_u64(x869, x806, x847); uint64_t x874, uint64_t _ = mulx_u64(x850, 0xcf3cf3cf3cf3cf3dL); uint64_t x877, uint64_t x878 = mulx_u64(x874, 0xffffffffffffffebL); uint64_t x880, uint64_t x881 = mulx_u64(x874, 0xffffffffffffffffL); uint64_t x883, uint64_t x884 = mulx_u64(x874, 0xffffffffffffffffL); uint64_t x886, uint64_t x887 = mulx_u64(x874, 0xffffffffffffffffL); uint64_t x889, uint64_t x890 = mulx_u64(x874, 0xffffffffffffffffL); uint64_t x892, uint64_t x893 = mulx_u64(x874, 0xffffffffffffffffL); uint64_t x895, uint8_t x896 = Op (Syntax.MulSplit 64 (Syntax.TWord 6) (Syntax.TWord 3) (Syntax.TWord 6) (Syntax.TWord 3)) (Return x874, 0x1f); uint64_t x898, uint8_t x899 = addcarryx_u64(0x0, x878, x880); uint64_t x901, uint8_t x902 = addcarryx_u64(x899, x881, x883); uint64_t x904, uint8_t x905 = addcarryx_u64(x902, x884, x886); uint64_t x907, uint8_t x908 = addcarryx_u64(x905, x887, x889); uint64_t x910, uint8_t x911 = addcarryx_u64(x908, x890, x892); uint64_t x913, uint8_t x914 = addcarryx_u64(x911, x893, x895); uint8_t x915 = (x914 + x896); uint64_t _, uint8_t x918 = addcarryx_u64(0x0, x850, x877); uint64_t x920, uint8_t x921 = addcarryx_u64(x918, x853, x898); uint64_t x923, uint8_t x924 = addcarryx_u64(x921, x856, x901); uint64_t x926, uint8_t x927 = addcarryx_u64(x924, x859, x904); uint64_t x929, uint8_t x930 = addcarryx_u64(x927, x862, x907); uint64_t x932, uint8_t x933 = addcarryx_u64(x930, x865, x910); uint64_t x935, uint8_t x936 = addcarryx_u64(x933, x868, x913); uint64_t x938, uint8_t x939 = addcarryx_u64(x936, x871, x915); uint8_t x940 = (x939 + x872); uint64_t x942, uint8_t x943 = subborrow_u64(0x0, x920, 0xffffffffffffffebL); uint64_t x945, uint8_t x946 = subborrow_u64(x943, x923, 0xffffffffffffffffL); uint64_t x948, uint8_t x949 = subborrow_u64(x946, x926, 0xffffffffffffffffL); uint64_t x951, uint8_t x952 = subborrow_u64(x949, x929, 0xffffffffffffffffL); uint64_t x954, uint8_t x955 = subborrow_u64(x952, x932, 0xffffffffffffffffL); uint64_t x957, uint8_t x958 = subborrow_u64(x955, x935, 0xffffffffffffffffL); uint64_t x960, uint8_t x961 = subborrow_u64(x958, x938, 0x1f); uint64_t _, uint8_t x964 = subborrow_u64(x961, x940, 0x0); uint64_t x965 = cmovznz(x964, x960, x938); uint64_t x966 = cmovznz(x964, x957, x935); uint64_t x967 = cmovznz(x964, x954, x932); uint64_t x968 = cmovznz(x964, x951, x929); uint64_t x969 = cmovznz(x964, x948, x926); uint64_t x970 = cmovznz(x964, x945, x923); uint64_t x971 = cmovznz(x964, x942, x920); return (x965, x966, x967, x968, x969, x970, x971)) (x, x0)%core : word64 * word64 * word64 * word64 * word64 * word64 * word64 → word64 * word64 * word64 * word64 * word64 * word64 * word64 → ReturnType (uint64_t * uint64_t * uint64_t * uint64_t * uint64_t * uint64_t * uint64_t)