file
stringlengths 18
26
| data
stringlengths 2
1.05M
|
|---|---|
the_stack_data/36076117.c | // Membros em ordem alfabética:
// Gustavo T. Mastrobuono NUSP 10734411,
// Henrique de S. Q. dos Santos NUSP 10819029,
// Jhordan P. V. Pesantes NUSP 11733353,
// Witor M. A. de Oliveira NUSP 10692190 e
// Yorvin A. R. Carrion NUSP 11733332
#include <stdio.h>
#include <omp.h>
#define T 4 // numero de threads
int main(){
int i = 0, n = 0, pos = 0;
// Esse scanf assume que os valores estão dispostos linha por linha
// como no arquivo input.txt deixado como exemplo
scanf("%d\n%d", &n, &pos); // le tamanho do vetor e posição de comparação
int vet[n], menorLocal = 99999, menorGlobal = 99999;
for(int i = 0; i < n; i++)
scanf("%d", &vet[i]); // le e armazena valores no vetor
// Inicializa um loop em paralelo atribuindo n/T iteracoes pra cada
// thread, inicializa menorLocal = 99999 em cada thread localmente
// e compartilha a variavel menorGlobal entre os processos
#pragma omp parallel for firstprivate(menorLocal)\
shared(menorGlobal) schedule(dynamic, n/T)
for(i = 0; i < n; i++){
if((vet[i] > vet[pos]) && (vet[i] < menorLocal))
menorLocal = vet[i];
// Após a computação do menor local no bloco recebido pelo
// processo, efetua a comparação com o menor global
#pragma omp critical
if(menorLocal < menorGlobal)
menorGlobal = menorLocal;
}
if(menorGlobal == 99999)
printf("-1");
else
printf("%d\n", menorGlobal);
return 0;
} |
the_stack_data/45449175.c | #include <stdio.h>
#include <stdint.h>
#include <limits.h>
#define ERROR -1
int safe_multiply(const int number1, const int number2)
{
/* Multiply the int32's into an int they can't overflow */
int64_t test = (int64_t) number1 * number2;
/* check if they would overflow a standard int32 */
if (test >= (int64_t) INT_MIN && test <= (int64_t) INT_MAX ) {
/* If they don't overflow, send the result back */
return number1 * number2;
}
else {
/* If they overflow, send an error */
return ERROR;
}
}
int main()
{
#ifdef UNIT_TEST
/* Initalize Unit Test Variables */
int test;
#endif //UNIT_TEST
#ifdef UNIT_TEST
/* Unit Test Case 1: Two positives */
test = 0;
test = safe_multiply(20,30);
if(test != 600) {
printf("Unit Test 1: Two positives failed! Result: %d\n\n", test );
} else {
printf("Unit Test 1: Two positives successful!\n\n");
}
#endif //UNIT_TEST
#ifdef UNIT_TEST
/* Unit Test Case 2: Two negatives */
test = 0;
test = safe_multiply(-20,-30);
if(test != 600) {
printf("Unit Test 2: Two negatives failed! Result: %d\n\n", test );
} else {
printf("Unit Test 2: Two negatives successful!\n\n");
}
#endif //UNIT_TEST
#ifdef UNIT_TEST
/* Unit Test Case 3: First negative, then positive */
test = 0;
test = safe_multiply(-20,30);
if(test != -600) {
printf("Unit Test 3: First negative, then positive failed! Result: %d\n\n", test );
} else {
printf("Unit Test 3: First negative, then positive successful!\n\n");
}
#endif //UNIT_TEST
#ifdef UNIT_TEST
/* Unit Test Case 4: First negative, then positive */
test = 0;
test = safe_multiply(20,-30);
if(test != -600) {
printf("Unit Test 4: First postive, then negative failed! Result: %d\n\n", test );
} else {
printf("Unit Test 4: First postive, then negative successful!\n\n");
}
#endif //UNIT_TEST
#ifdef UNIT_TEST
/* Unit Test Case 5: Large numbers */
test = 0;
test = safe_multiply(1000000,1000000);
if(test != ERROR) {
printf("Unit Test 5: Large numbers failed! Result: %d\n\n", test );
} else {
printf("Unit Test 5: Large numbers successful!\n\n");
}
#endif //UNIT_TEST
#ifdef UNIT_TEST
/* Unit Test Case 6: Large numbers (Negative) */
test = 0;
test = safe_multiply(-1000000,1000000);
if(test != ERROR) {
printf("Unit Test 6: Large numbers (Negative) failed! Result: %d\n\n", test );
} else {
printf("Unit Test 6: Large numbers (Negative) successful!\n\n");
}
#endif //UNIT_TEST
return 0;
} |
the_stack_data/218892833.c | /* $OpenBSD$ */
/* ====================================================================
* Copyright (c) 2002-2006 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* [email protected].
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
*/
#include <openssl/aes.h>
#include <openssl/modes.h>
/* The input and output encrypted as though 128bit cfb mode is being
* used. The extra state information to record how much of the
* 128bit block we have used is contained in *num;
*/
void
AES_cfb128_encrypt(const unsigned char *in, unsigned char *out, size_t length,
const AES_KEY *key, unsigned char *ivec, int *num, const int enc)
{
CRYPTO_cfb128_encrypt(in, out, length, key, ivec, num, enc,
(block128_f)AES_encrypt);
}
/* N.B. This expects the input to be packed, MS bit first */
void
AES_cfb1_encrypt(const unsigned char *in, unsigned char *out, size_t length,
const AES_KEY *key, unsigned char *ivec, int *num, const int enc)
{
CRYPTO_cfb128_1_encrypt(in, out, length, key, ivec, num, enc,
(block128_f)AES_encrypt);
}
void
AES_cfb8_encrypt(const unsigned char *in, unsigned char *out, size_t length,
const AES_KEY *key, unsigned char *ivec, int *num, const int enc)
{
CRYPTO_cfb128_8_encrypt(in, out, length, key, ivec, num, enc,
(block128_f)AES_encrypt);
}
|
the_stack_data/103266638.c | /*
* Copyright (c) 2013 - Facebook.
* All rights reserved.
*/
void check(int x) {
}
void main() {
int x = 3;
check(x<2);
}
|
the_stack_data/159514239.c | void main()
{
return;
} |
the_stack_data/140766090.c | /* Autogenerated: src/ExtractionOCaml/bedrock2_word_by_word_montgomery --lang bedrock2 --no-wide-int --widen-carry --widen-bytes --split-multiret --no-select p384 32 '2^384 - 2^128 - 2^96 + 2^32 - 1' mul square add sub opp from_montgomery to_montgomery nonzero selectznz to_bytes from_bytes */
/* curve description: p384 */
/* machine_wordsize = 32 (from "32") */
/* requested operations: mul, square, add, sub, opp, from_montgomery, to_montgomery, nonzero, selectznz, to_bytes, from_bytes */
/* 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] << 32) + (z[2] << 64) + (z[3] << 96) + (z[4] << 128) + (z[5] << 160) + (z[6] << 192) + (z[7] << 224) + (z[8] << 256) + (z[9] << 0x120) + (z[10] << 0x140) + (z[11] << 0x160) */
/* bytes_eval z = z[0] + (z[1] << 8) + (z[2] << 16) + (z[3] << 24) + (z[4] << 32) + (z[5] << 40) + (z[6] << 48) + (z[7] << 56) + (z[8] << 64) + (z[9] << 72) + (z[10] << 80) + (z[11] << 88) + (z[12] << 96) + (z[13] << 104) + (z[14] << 112) + (z[15] << 120) + (z[16] << 128) + (z[17] << 136) + (z[18] << 144) + (z[19] << 152) + (z[20] << 160) + (z[21] << 168) + (z[22] << 176) + (z[23] << 184) + (z[24] << 192) + (z[25] << 200) + (z[26] << 208) + (z[27] << 216) + (z[28] << 224) + (z[29] << 232) + (z[30] << 240) + (z[31] << 248) + (z[32] << 256) + (z[33] << 0x108) + (z[34] << 0x110) + (z[35] << 0x118) + (z[36] << 0x120) + (z[37] << 0x128) + (z[38] << 0x130) + (z[39] << 0x138) + (z[40] << 0x140) + (z[41] << 0x148) + (z[42] << 0x150) + (z[43] << 0x158) + (z[44] << 0x160) + (z[45] << 0x168) + (z[46] << 0x170) + (z[47] << 0x178) */
#include <stdint.h>
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_mul(uintptr_t in0, uintptr_t in1, uintptr_t out0) {
uintptr_t x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x0, x35, x56, x59, x61, x57, x62, x54, x63, x65, x66, x55, x67, x52, x68, x70, x71, x53, x72, x50, x73, x75, x76, x51, x77, x48, x78, x80, x81, x49, x82, x46, x83, x85, x86, x47, x87, x44, x88, x90, x91, x45, x92, x42, x93, x95, x96, x43, x97, x40, x98, x100, x101, x41, x102, x38, x103, x105, x106, x39, x107, x36, x108, x110, x111, x37, x127, x130, x134, x128, x135, x125, x136, x138, x139, x126, x140, x123, x141, x143, x144, x124, x145, x121, x146, x148, x149, x122, x150, x119, x151, x153, x154, x120, x155, x117, x156, x158, x159, x118, x160, x115, x161, x163, x164, x116, x165, x113, x166, x168, x169, x114, x131, x171, x58, x172, x60, x173, x132, x174, x176, x177, x64, x179, x69, x180, x129, x181, x183, x184, x74, x185, x133, x186, x188, x189, x79, x190, x137, x191, x193, x194, x84, x195, x142, x196, x198, x199, x89, x200, x147, x201, x203, x204, x94, x205, x152, x206, x208, x209, x99, x210, x157, x211, x213, x214, x104, x215, x162, x216, x218, x219, x109, x220, x167, x221, x223, x224, x112, x225, x170, x226, x228, x24, x250, x253, x255, x251, x256, x248, x257, x259, x260, x249, x261, x246, x262, x264, x265, x247, x266, x244, x267, x269, x270, x245, x271, x242, x272, x274, x275, x243, x276, x240, x277, x279, x280, x241, x281, x238, x282, x284, x285, x239, x286, x236, x287, x289, x290, x237, x291, x234, x292, x294, x295, x235, x296, x232, x297, x299, x300, x233, x301, x230, x302, x304, x305, x231, x252, x175, x308, x178, x309, x254, x310, x312, x313, x182, x314, x258, x315, x317, x318, x187, x319, x263, x320, x322, x323, x192, x324, x268, x325, x327, x328, x197, x329, x273, x330, x332, x333, x202, x334, x278, x335, x337, x338, x207, x339, x283, x340, x342, x343, x212, x344, x288, x345, x347, x348, x217, x349, x293, x350, x352, x353, x222, x354, x298, x355, x357, x358, x227, x359, x303, x360, x362, x363, x229, x364, x306, x365, x367, x383, x386, x390, x384, x391, x381, x392, x394, x395, x382, x396, x379, x397, x399, x400, x380, x401, x377, x402, x404, x405, x378, x406, x375, x407, x409, x410, x376, x411, x373, x412, x414, x415, x374, x416, x371, x417, x419, x420, x372, x421, x369, x422, x424, x425, x370, x387, x427, x307, x428, x311, x429, x388, x430, x432, x433, x316, x435, x321, x436, x385, x437, x439, x440, x326, x441, x389, x442, x444, x445, x331, x446, x393, x447, x449, x450, x336, x451, x398, x452, x454, x455, x341, x456, x403, x457, x459, x460, x346, x461, x408, x462, x464, x465, x351, x466, x413, x467, x469, x470, x356, x471, x418, x472, x474, x475, x361, x476, x423, x477, x479, x480, x366, x481, x426, x482, x484, x485, x368, x25, x507, x510, x512, x508, x513, x505, x514, x516, x517, x506, x518, x503, x519, x521, x522, x504, x523, x501, x524, x526, x527, x502, x528, x499, x529, x531, x532, x500, x533, x497, x534, x536, x537, x498, x538, x495, x539, x541, x542, x496, x543, x493, x544, x546, x547, x494, x548, x491, x549, x551, x552, x492, x553, x489, x554, x556, x557, x490, x558, x487, x559, x561, x562, x488, x509, x431, x565, x434, x566, x511, x567, x569, x570, x438, x571, x515, x572, x574, x575, x443, x576, x520, x577, x579, x580, x448, x581, x525, x582, x584, x585, x453, x586, x530, x587, x589, x590, x458, x591, x535, x592, x594, x595, x463, x596, x540, x597, x599, x600, x468, x601, x545, x602, x604, x605, x473, x606, x550, x607, x609, x610, x478, x611, x555, x612, x614, x615, x483, x616, x560, x617, x619, x620, x486, x621, x563, x622, x624, x640, x643, x647, x641, x648, x638, x649, x651, x652, x639, x653, x636, x654, x656, x657, x637, x658, x634, x659, x661, x662, x635, x663, x632, x664, x666, x667, x633, x668, x630, x669, x671, x672, x631, x673, x628, x674, x676, x677, x629, x678, x626, x679, x681, x682, x627, x644, x684, x564, x685, x568, x686, x645, x687, x689, x690, x573, x692, x578, x693, x642, x694, x696, x697, x583, x698, x646, x699, x701, x702, x588, x703, x650, x704, x706, x707, x593, x708, x655, x709, x711, x712, x598, x713, x660, x714, x716, x717, x603, x718, x665, x719, x721, x722, x608, x723, x670, x724, x726, x727, x613, x728, x675, x729, x731, x732, x618, x733, x680, x734, x736, x737, x623, x738, x683, x739, x741, x742, x625, x26, x764, x767, x769, x765, x770, x762, x771, x773, x774, x763, x775, x760, x776, x778, x779, x761, x780, x758, x781, x783, x784, x759, x785, x756, x786, x788, x789, x757, x790, x754, x791, x793, x794, x755, x795, x752, x796, x798, x799, x753, x800, x750, x801, x803, x804, x751, x805, x748, x806, x808, x809, x749, x810, x746, x811, x813, x814, x747, x815, x744, x816, x818, x819, x745, x766, x688, x822, x691, x823, x768, x824, x826, x827, x695, x828, x772, x829, x831, x832, x700, x833, x777, x834, x836, x837, x705, x838, x782, x839, x841, x842, x710, x843, x787, x844, x846, x847, x715, x848, x792, x849, x851, x852, x720, x853, x797, x854, x856, x857, x725, x858, x802, x859, x861, x862, x730, x863, x807, x864, x866, x867, x735, x868, x812, x869, x871, x872, x740, x873, x817, x874, x876, x877, x743, x878, x820, x879, x881, x897, x900, x904, x898, x905, x895, x906, x908, x909, x896, x910, x893, x911, x913, x914, x894, x915, x891, x916, x918, x919, x892, x920, x889, x921, x923, x924, x890, x925, x887, x926, x928, x929, x888, x930, x885, x931, x933, x934, x886, x935, x883, x936, x938, x939, x884, x901, x941, x821, x942, x825, x943, x902, x944, x946, x947, x830, x949, x835, x950, x899, x951, x953, x954, x840, x955, x903, x956, x958, x959, x845, x960, x907, x961, x963, x964, x850, x965, x912, x966, x968, x969, x855, x970, x917, x971, x973, x974, x860, x975, x922, x976, x978, x979, x865, x980, x927, x981, x983, x984, x870, x985, x932, x986, x988, x989, x875, x990, x937, x991, x993, x994, x880, x995, x940, x996, x998, x999, x882, x27, x1021, x1024, x1026, x1022, x1027, x1019, x1028, x1030, x1031, x1020, x1032, x1017, x1033, x1035, x1036, x1018, x1037, x1015, x1038, x1040, x1041, x1016, x1042, x1013, x1043, x1045, x1046, x1014, x1047, x1011, x1048, x1050, x1051, x1012, x1052, x1009, x1053, x1055, x1056, x1010, x1057, x1007, x1058, x1060, x1061, x1008, x1062, x1005, x1063, x1065, x1066, x1006, x1067, x1003, x1068, x1070, x1071, x1004, x1072, x1001, x1073, x1075, x1076, x1002, x1023, x945, x1079, x948, x1080, x1025, x1081, x1083, x1084, x952, x1085, x1029, x1086, x1088, x1089, x957, x1090, x1034, x1091, x1093, x1094, x962, x1095, x1039, x1096, x1098, x1099, x967, x1100, x1044, x1101, x1103, x1104, x972, x1105, x1049, x1106, x1108, x1109, x977, x1110, x1054, x1111, x1113, x1114, x982, x1115, x1059, x1116, x1118, x1119, x987, x1120, x1064, x1121, x1123, x1124, x992, x1125, x1069, x1126, x1128, x1129, x997, x1130, x1074, x1131, x1133, x1134, x1000, x1135, x1077, x1136, x1138, x1154, x1157, x1161, x1155, x1162, x1152, x1163, x1165, x1166, x1153, x1167, x1150, x1168, x1170, x1171, x1151, x1172, x1148, x1173, x1175, x1176, x1149, x1177, x1146, x1178, x1180, x1181, x1147, x1182, x1144, x1183, x1185, x1186, x1145, x1187, x1142, x1188, x1190, x1191, x1143, x1192, x1140, x1193, x1195, x1196, x1141, x1158, x1198, x1078, x1199, x1082, x1200, x1159, x1201, x1203, x1204, x1087, x1206, x1092, x1207, x1156, x1208, x1210, x1211, x1097, x1212, x1160, x1213, x1215, x1216, x1102, x1217, x1164, x1218, x1220, x1221, x1107, x1222, x1169, x1223, x1225, x1226, x1112, x1227, x1174, x1228, x1230, x1231, x1117, x1232, x1179, x1233, x1235, x1236, x1122, x1237, x1184, x1238, x1240, x1241, x1127, x1242, x1189, x1243, x1245, x1246, x1132, x1247, x1194, x1248, x1250, x1251, x1137, x1252, x1197, x1253, x1255, x1256, x1139, x28, x1278, x1281, x1283, x1279, x1284, x1276, x1285, x1287, x1288, x1277, x1289, x1274, x1290, x1292, x1293, x1275, x1294, x1272, x1295, x1297, x1298, x1273, x1299, x1270, x1300, x1302, x1303, x1271, x1304, x1268, x1305, x1307, x1308, x1269, x1309, x1266, x1310, x1312, x1313, x1267, x1314, x1264, x1315, x1317, x1318, x1265, x1319, x1262, x1320, x1322, x1323, x1263, x1324, x1260, x1325, x1327, x1328, x1261, x1329, x1258, x1330, x1332, x1333, x1259, x1280, x1202, x1336, x1205, x1337, x1282, x1338, x1340, x1341, x1209, x1342, x1286, x1343, x1345, x1346, x1214, x1347, x1291, x1348, x1350, x1351, x1219, x1352, x1296, x1353, x1355, x1356, x1224, x1357, x1301, x1358, x1360, x1361, x1229, x1362, x1306, x1363, x1365, x1366, x1234, x1367, x1311, x1368, x1370, x1371, x1239, x1372, x1316, x1373, x1375, x1376, x1244, x1377, x1321, x1378, x1380, x1381, x1249, x1382, x1326, x1383, x1385, x1386, x1254, x1387, x1331, x1388, x1390, x1391, x1257, x1392, x1334, x1393, x1395, x1411, x1414, x1418, x1412, x1419, x1409, x1420, x1422, x1423, x1410, x1424, x1407, x1425, x1427, x1428, x1408, x1429, x1405, x1430, x1432, x1433, x1406, x1434, x1403, x1435, x1437, x1438, x1404, x1439, x1401, x1440, x1442, x1443, x1402, x1444, x1399, x1445, x1447, x1448, x1400, x1449, x1397, x1450, x1452, x1453, x1398, x1415, x1455, x1335, x1456, x1339, x1457, x1416, x1458, x1460, x1461, x1344, x1463, x1349, x1464, x1413, x1465, x1467, x1468, x1354, x1469, x1417, x1470, x1472, x1473, x1359, x1474, x1421, x1475, x1477, x1478, x1364, x1479, x1426, x1480, x1482, x1483, x1369, x1484, x1431, x1485, x1487, x1488, x1374, x1489, x1436, x1490, x1492, x1493, x1379, x1494, x1441, x1495, x1497, x1498, x1384, x1499, x1446, x1500, x1502, x1503, x1389, x1504, x1451, x1505, x1507, x1508, x1394, x1509, x1454, x1510, x1512, x1513, x1396, x29, x1535, x1538, x1540, x1536, x1541, x1533, x1542, x1544, x1545, x1534, x1546, x1531, x1547, x1549, x1550, x1532, x1551, x1529, x1552, x1554, x1555, x1530, x1556, x1527, x1557, x1559, x1560, x1528, x1561, x1525, x1562, x1564, x1565, x1526, x1566, x1523, x1567, x1569, x1570, x1524, x1571, x1521, x1572, x1574, x1575, x1522, x1576, x1519, x1577, x1579, x1580, x1520, x1581, x1517, x1582, x1584, x1585, x1518, x1586, x1515, x1587, x1589, x1590, x1516, x1537, x1459, x1593, x1462, x1594, x1539, x1595, x1597, x1598, x1466, x1599, x1543, x1600, x1602, x1603, x1471, x1604, x1548, x1605, x1607, x1608, x1476, x1609, x1553, x1610, x1612, x1613, x1481, x1614, x1558, x1615, x1617, x1618, x1486, x1619, x1563, x1620, x1622, x1623, x1491, x1624, x1568, x1625, x1627, x1628, x1496, x1629, x1573, x1630, x1632, x1633, x1501, x1634, x1578, x1635, x1637, x1638, x1506, x1639, x1583, x1640, x1642, x1643, x1511, x1644, x1588, x1645, x1647, x1648, x1514, x1649, x1591, x1650, x1652, x1668, x1671, x1675, x1669, x1676, x1666, x1677, x1679, x1680, x1667, x1681, x1664, x1682, x1684, x1685, x1665, x1686, x1662, x1687, x1689, x1690, x1663, x1691, x1660, x1692, x1694, x1695, x1661, x1696, x1658, x1697, x1699, x1700, x1659, x1701, x1656, x1702, x1704, x1705, x1657, x1706, x1654, x1707, x1709, x1710, x1655, x1672, x1712, x1592, x1713, x1596, x1714, x1673, x1715, x1717, x1718, x1601, x1720, x1606, x1721, x1670, x1722, x1724, x1725, x1611, x1726, x1674, x1727, x1729, x1730, x1616, x1731, x1678, x1732, x1734, x1735, x1621, x1736, x1683, x1737, x1739, x1740, x1626, x1741, x1688, x1742, x1744, x1745, x1631, x1746, x1693, x1747, x1749, x1750, x1636, x1751, x1698, x1752, x1754, x1755, x1641, x1756, x1703, x1757, x1759, x1760, x1646, x1761, x1708, x1762, x1764, x1765, x1651, x1766, x1711, x1767, x1769, x1770, x1653, x30, x1792, x1795, x1797, x1793, x1798, x1790, x1799, x1801, x1802, x1791, x1803, x1788, x1804, x1806, x1807, x1789, x1808, x1786, x1809, x1811, x1812, x1787, x1813, x1784, x1814, x1816, x1817, x1785, x1818, x1782, x1819, x1821, x1822, x1783, x1823, x1780, x1824, x1826, x1827, x1781, x1828, x1778, x1829, x1831, x1832, x1779, x1833, x1776, x1834, x1836, x1837, x1777, x1838, x1774, x1839, x1841, x1842, x1775, x1843, x1772, x1844, x1846, x1847, x1773, x1794, x1716, x1850, x1719, x1851, x1796, x1852, x1854, x1855, x1723, x1856, x1800, x1857, x1859, x1860, x1728, x1861, x1805, x1862, x1864, x1865, x1733, x1866, x1810, x1867, x1869, x1870, x1738, x1871, x1815, x1872, x1874, x1875, x1743, x1876, x1820, x1877, x1879, x1880, x1748, x1881, x1825, x1882, x1884, x1885, x1753, x1886, x1830, x1887, x1889, x1890, x1758, x1891, x1835, x1892, x1894, x1895, x1763, x1896, x1840, x1897, x1899, x1900, x1768, x1901, x1845, x1902, x1904, x1905, x1771, x1906, x1848, x1907, x1909, x1925, x1928, x1932, x1926, x1933, x1923, x1934, x1936, x1937, x1924, x1938, x1921, x1939, x1941, x1942, x1922, x1943, x1919, x1944, x1946, x1947, x1920, x1948, x1917, x1949, x1951, x1952, x1918, x1953, x1915, x1954, x1956, x1957, x1916, x1958, x1913, x1959, x1961, x1962, x1914, x1963, x1911, x1964, x1966, x1967, x1912, x1929, x1969, x1849, x1970, x1853, x1971, x1930, x1972, x1974, x1975, x1858, x1977, x1863, x1978, x1927, x1979, x1981, x1982, x1868, x1983, x1931, x1984, x1986, x1987, x1873, x1988, x1935, x1989, x1991, x1992, x1878, x1993, x1940, x1994, x1996, x1997, x1883, x1998, x1945, x1999, x2001, x2002, x1888, x2003, x1950, x2004, x2006, x2007, x1893, x2008, x1955, x2009, x2011, x2012, x1898, x2013, x1960, x2014, x2016, x2017, x1903, x2018, x1965, x2019, x2021, x2022, x1908, x2023, x1968, x2024, x2026, x2027, x1910, x31, x2049, x2052, x2054, x2050, x2055, x2047, x2056, x2058, x2059, x2048, x2060, x2045, x2061, x2063, x2064, x2046, x2065, x2043, x2066, x2068, x2069, x2044, x2070, x2041, x2071, x2073, x2074, x2042, x2075, x2039, x2076, x2078, x2079, x2040, x2080, x2037, x2081, x2083, x2084, x2038, x2085, x2035, x2086, x2088, x2089, x2036, x2090, x2033, x2091, x2093, x2094, x2034, x2095, x2031, x2096, x2098, x2099, x2032, x2100, x2029, x2101, x2103, x2104, x2030, x2051, x1973, x2107, x1976, x2108, x2053, x2109, x2111, x2112, x1980, x2113, x2057, x2114, x2116, x2117, x1985, x2118, x2062, x2119, x2121, x2122, x1990, x2123, x2067, x2124, x2126, x2127, x1995, x2128, x2072, x2129, x2131, x2132, x2000, x2133, x2077, x2134, x2136, x2137, x2005, x2138, x2082, x2139, x2141, x2142, x2010, x2143, x2087, x2144, x2146, x2147, x2015, x2148, x2092, x2149, x2151, x2152, x2020, x2153, x2097, x2154, x2156, x2157, x2025, x2158, x2102, x2159, x2161, x2162, x2028, x2163, x2105, x2164, x2166, x2182, x2185, x2189, x2183, x2190, x2180, x2191, x2193, x2194, x2181, x2195, x2178, x2196, x2198, x2199, x2179, x2200, x2176, x2201, x2203, x2204, x2177, x2205, x2174, x2206, x2208, x2209, x2175, x2210, x2172, x2211, x2213, x2214, x2173, x2215, x2170, x2216, x2218, x2219, x2171, x2220, x2168, x2221, x2223, x2224, x2169, x2186, x2226, x2106, x2227, x2110, x2228, x2187, x2229, x2231, x2232, x2115, x2234, x2120, x2235, x2184, x2236, x2238, x2239, x2125, x2240, x2188, x2241, x2243, x2244, x2130, x2245, x2192, x2246, x2248, x2249, x2135, x2250, x2197, x2251, x2253, x2254, x2140, x2255, x2202, x2256, x2258, x2259, x2145, x2260, x2207, x2261, x2263, x2264, x2150, x2265, x2212, x2266, x2268, x2269, x2155, x2270, x2217, x2271, x2273, x2274, x2160, x2275, x2222, x2276, x2278, x2279, x2165, x2280, x2225, x2281, x2283, x2284, x2167, x32, x2306, x2309, x2311, x2307, x2312, x2304, x2313, x2315, x2316, x2305, x2317, x2302, x2318, x2320, x2321, x2303, x2322, x2300, x2323, x2325, x2326, x2301, x2327, x2298, x2328, x2330, x2331, x2299, x2332, x2296, x2333, x2335, x2336, x2297, x2337, x2294, x2338, x2340, x2341, x2295, x2342, x2292, x2343, x2345, x2346, x2293, x2347, x2290, x2348, x2350, x2351, x2291, x2352, x2288, x2353, x2355, x2356, x2289, x2357, x2286, x2358, x2360, x2361, x2287, x2308, x2230, x2364, x2233, x2365, x2310, x2366, x2368, x2369, x2237, x2370, x2314, x2371, x2373, x2374, x2242, x2375, x2319, x2376, x2378, x2379, x2247, x2380, x2324, x2381, x2383, x2384, x2252, x2385, x2329, x2386, x2388, x2389, x2257, x2390, x2334, x2391, x2393, x2394, x2262, x2395, x2339, x2396, x2398, x2399, x2267, x2400, x2344, x2401, x2403, x2404, x2272, x2405, x2349, x2406, x2408, x2409, x2277, x2410, x2354, x2411, x2413, x2414, x2282, x2415, x2359, x2416, x2418, x2419, x2285, x2420, x2362, x2421, x2423, x2439, x2442, x2446, x2440, x2447, x2437, x2448, x2450, x2451, x2438, x2452, x2435, x2453, x2455, x2456, x2436, x2457, x2433, x2458, x2460, x2461, x2434, x2462, x2431, x2463, x2465, x2466, x2432, x2467, x2429, x2468, x2470, x2471, x2430, x2472, x2427, x2473, x2475, x2476, x2428, x2477, x2425, x2478, x2480, x2481, x2426, x2443, x2483, x2363, x2484, x2367, x2485, x2444, x2486, x2488, x2489, x2372, x2491, x2377, x2492, x2441, x2493, x2495, x2496, x2382, x2497, x2445, x2498, x2500, x2501, x2387, x2502, x2449, x2503, x2505, x2506, x2392, x2507, x2454, x2508, x2510, x2511, x2397, x2512, x2459, x2513, x2515, x2516, x2402, x2517, x2464, x2518, x2520, x2521, x2407, x2522, x2469, x2523, x2525, x2526, x2412, x2527, x2474, x2528, x2530, x2531, x2417, x2532, x2479, x2533, x2535, x2536, x2422, x2537, x2482, x2538, x2540, x2541, x2424, x33, x2563, x2566, x2568, x2564, x2569, x2561, x2570, x2572, x2573, x2562, x2574, x2559, x2575, x2577, x2578, x2560, x2579, x2557, x2580, x2582, x2583, x2558, x2584, x2555, x2585, x2587, x2588, x2556, x2589, x2553, x2590, x2592, x2593, x2554, x2594, x2551, x2595, x2597, x2598, x2552, x2599, x2549, x2600, x2602, x2603, x2550, x2604, x2547, x2605, x2607, x2608, x2548, x2609, x2545, x2610, x2612, x2613, x2546, x2614, x2543, x2615, x2617, x2618, x2544, x2565, x2487, x2621, x2490, x2622, x2567, x2623, x2625, x2626, x2494, x2627, x2571, x2628, x2630, x2631, x2499, x2632, x2576, x2633, x2635, x2636, x2504, x2637, x2581, x2638, x2640, x2641, x2509, x2642, x2586, x2643, x2645, x2646, x2514, x2647, x2591, x2648, x2650, x2651, x2519, x2652, x2596, x2653, x2655, x2656, x2524, x2657, x2601, x2658, x2660, x2661, x2529, x2662, x2606, x2663, x2665, x2666, x2534, x2667, x2611, x2668, x2670, x2671, x2539, x2672, x2616, x2673, x2675, x2676, x2542, x2677, x2619, x2678, x2680, x2696, x2699, x2703, x2697, x2704, x2694, x2705, x2707, x2708, x2695, x2709, x2692, x2710, x2712, x2713, x2693, x2714, x2690, x2715, x2717, x2718, x2691, x2719, x2688, x2720, x2722, x2723, x2689, x2724, x2686, x2725, x2727, x2728, x2687, x2729, x2684, x2730, x2732, x2733, x2685, x2734, x2682, x2735, x2737, x2738, x2683, x2700, x2740, x2620, x2741, x2624, x2742, x2701, x2743, x2745, x2746, x2629, x2748, x2634, x2749, x2698, x2750, x2752, x2753, x2639, x2754, x2702, x2755, x2757, x2758, x2644, x2759, x2706, x2760, x2762, x2763, x2649, x2764, x2711, x2765, x2767, x2768, x2654, x2769, x2716, x2770, x2772, x2773, x2659, x2774, x2721, x2775, x2777, x2778, x2664, x2779, x2726, x2780, x2782, x2783, x2669, x2784, x2731, x2785, x2787, x2788, x2674, x2789, x2736, x2790, x2792, x2793, x2679, x2794, x2739, x2795, x2797, x2798, x2681, x23, x22, x21, x20, x19, x18, x17, x16, x15, x14, x13, x34, x12, x2820, x2823, x2825, x2821, x2826, x2818, x2827, x2829, x2830, x2819, x2831, x2816, x2832, x2834, x2835, x2817, x2836, x2814, x2837, x2839, x2840, x2815, x2841, x2812, x2842, x2844, x2845, x2813, x2846, x2810, x2847, x2849, x2850, x2811, x2851, x2808, x2852, x2854, x2855, x2809, x2856, x2806, x2857, x2859, x2860, x2807, x2861, x2804, x2862, x2864, x2865, x2805, x2866, x2802, x2867, x2869, x2870, x2803, x2871, x2800, x2872, x2874, x2875, x2801, x2822, x2744, x2878, x2747, x2879, x2824, x2880, x2882, x2883, x2751, x2884, x2828, x2885, x2887, x2888, x2756, x2889, x2833, x2890, x2892, x2893, x2761, x2894, x2838, x2895, x2897, x2898, x2766, x2899, x2843, x2900, x2902, x2903, x2771, x2904, x2848, x2905, x2907, x2908, x2776, x2909, x2853, x2910, x2912, x2913, x2781, x2914, x2858, x2915, x2917, x2918, x2786, x2919, x2863, x2920, x2922, x2923, x2791, x2924, x2868, x2925, x2927, x2928, x2796, x2929, x2873, x2930, x2932, x2933, x2799, x2934, x2876, x2935, x2937, x2953, x2956, x2960, x2954, x2961, x2951, x2962, x2964, x2965, x2952, x2966, x2949, x2967, x2969, x2970, x2950, x2971, x2947, x2972, x2974, x2975, x2948, x2976, x2945, x2977, x2979, x2980, x2946, x2981, x2943, x2982, x2984, x2985, x2944, x2986, x2941, x2987, x2989, x2990, x2942, x2991, x2939, x2992, x2994, x2995, x2940, x2957, x2997, x2877, x2998, x2881, x2999, x2958, x3000, x3002, x3003, x2886, x3005, x2891, x3006, x2955, x3007, x3009, x3010, x2896, x3011, x2959, x3012, x3014, x3015, x2901, x3016, x2963, x3017, x3019, x3020, x2906, x3021, x2968, x3022, x3024, x3025, x2911, x3026, x2973, x3027, x3029, x3030, x2916, x3031, x2978, x3032, x3034, x3035, x2921, x3036, x2983, x3037, x3039, x3040, x2926, x3041, x2988, x3042, x3044, x3045, x2931, x3046, x2993, x3047, x3049, x3050, x2936, x3051, x2996, x3052, x3054, x3055, x2938, x3058, x3059, x3060, x3061, x3063, x3064, x3065, x3067, x3068, x3069, x3070, x3072, x3073, x3074, x3075, x3077, x3078, x3079, x3080, x3082, x3083, x3084, x3085, x3087, x3088, x3089, x3090, x3092, x3093, x3094, x3095, x3097, x3098, x3099, x3100, x3102, x3103, x3104, x3105, x3107, x3108, x3109, x3110, x3112, x3113, x3056, x3115, x3114, x3116, x3001, x3118, x3057, x3119, x3004, x3121, x3062, x3122, x3008, x3124, x3066, x3125, x3013, x3127, x3071, x3128, x3018, x3130, x3076, x3131, x3023, x3133, x3081, x3134, x3028, x3136, x3086, x3137, x3033, x3139, x3091, x3140, x3038, x3142, x3096, x3143, x3043, x3145, x3101, x3146, x3048, x3148, x3106, x3149, x3117, x3053, x3151, x3111, x3152, x3120, x3123, x3126, x3129, x3132, x3135, x3138, x3141, x3144, x3147, x3150, x3153, x3154, x3155, x3156, x3157, x3158, x3159, x3160, x3161, x3162, x3163, x3164, x3165;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
x12 = *(uintptr_t*)((in1)+((uintptr_t)0ULL));
x13 = *(uintptr_t*)((in1)+((uintptr_t)4ULL));
x14 = *(uintptr_t*)((in1)+((uintptr_t)8ULL));
x15 = *(uintptr_t*)((in1)+((uintptr_t)12ULL));
x16 = *(uintptr_t*)((in1)+((uintptr_t)16ULL));
x17 = *(uintptr_t*)((in1)+((uintptr_t)20ULL));
x18 = *(uintptr_t*)((in1)+((uintptr_t)24ULL));
x19 = *(uintptr_t*)((in1)+((uintptr_t)28ULL));
x20 = *(uintptr_t*)((in1)+((uintptr_t)32ULL));
x21 = *(uintptr_t*)((in1)+((uintptr_t)36ULL));
x22 = *(uintptr_t*)((in1)+((uintptr_t)40ULL));
x23 = *(uintptr_t*)((in1)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x24 = x1;
x25 = x2;
x26 = x3;
x27 = x4;
x28 = x5;
x29 = x6;
x30 = x7;
x31 = x8;
x32 = x9;
x33 = x10;
x34 = x11;
x35 = x0;
x36 = (x35)*(x23);
x37 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x23))>>32 : ((__uint128_t)(x35)*(x23))>>64;
x38 = (x35)*(x22);
x39 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x22))>>32 : ((__uint128_t)(x35)*(x22))>>64;
x40 = (x35)*(x21);
x41 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x21))>>32 : ((__uint128_t)(x35)*(x21))>>64;
x42 = (x35)*(x20);
x43 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x20))>>32 : ((__uint128_t)(x35)*(x20))>>64;
x44 = (x35)*(x19);
x45 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x19))>>32 : ((__uint128_t)(x35)*(x19))>>64;
x46 = (x35)*(x18);
x47 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x18))>>32 : ((__uint128_t)(x35)*(x18))>>64;
x48 = (x35)*(x17);
x49 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x17))>>32 : ((__uint128_t)(x35)*(x17))>>64;
x50 = (x35)*(x16);
x51 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x16))>>32 : ((__uint128_t)(x35)*(x16))>>64;
x52 = (x35)*(x15);
x53 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x15))>>32 : ((__uint128_t)(x35)*(x15))>>64;
x54 = (x35)*(x14);
x55 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x14))>>32 : ((__uint128_t)(x35)*(x14))>>64;
x56 = (x35)*(x13);
x57 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x13))>>32 : ((__uint128_t)(x35)*(x13))>>64;
x58 = (x35)*(x12);
x59 = sizeof(intptr_t) == 4 ? ((uint64_t)(x35)*(x12))>>32 : ((__uint128_t)(x35)*(x12))>>64;
x60 = (x59)+(x56);
x61 = (x60)<(x59);
x62 = (x61)+(x57);
x63 = (x62)<(x57);
x64 = (x62)+(x54);
x65 = (x64)<(x54);
x66 = (x63)+(x65);
x67 = (x66)+(x55);
x68 = (x67)<(x55);
x69 = (x67)+(x52);
x70 = (x69)<(x52);
x71 = (x68)+(x70);
x72 = (x71)+(x53);
x73 = (x72)<(x53);
x74 = (x72)+(x50);
x75 = (x74)<(x50);
x76 = (x73)+(x75);
x77 = (x76)+(x51);
x78 = (x77)<(x51);
x79 = (x77)+(x48);
x80 = (x79)<(x48);
x81 = (x78)+(x80);
x82 = (x81)+(x49);
x83 = (x82)<(x49);
x84 = (x82)+(x46);
x85 = (x84)<(x46);
x86 = (x83)+(x85);
x87 = (x86)+(x47);
x88 = (x87)<(x47);
x89 = (x87)+(x44);
x90 = (x89)<(x44);
x91 = (x88)+(x90);
x92 = (x91)+(x45);
x93 = (x92)<(x45);
x94 = (x92)+(x42);
x95 = (x94)<(x42);
x96 = (x93)+(x95);
x97 = (x96)+(x43);
x98 = (x97)<(x43);
x99 = (x97)+(x40);
x100 = (x99)<(x40);
x101 = (x98)+(x100);
x102 = (x101)+(x41);
x103 = (x102)<(x41);
x104 = (x102)+(x38);
x105 = (x104)<(x38);
x106 = (x103)+(x105);
x107 = (x106)+(x39);
x108 = (x107)<(x39);
x109 = (x107)+(x36);
x110 = (x109)<(x36);
x111 = (x108)+(x110);
x112 = (x111)+(x37);
x113 = (x58)*((uintptr_t)4294967295ULL);
x114 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x115 = (x58)*((uintptr_t)4294967295ULL);
x116 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x117 = (x58)*((uintptr_t)4294967295ULL);
x118 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x119 = (x58)*((uintptr_t)4294967295ULL);
x120 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x121 = (x58)*((uintptr_t)4294967295ULL);
x122 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x123 = (x58)*((uintptr_t)4294967295ULL);
x124 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x125 = (x58)*((uintptr_t)4294967295ULL);
x126 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x127 = (x58)*((uintptr_t)4294967294ULL);
x128 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967294ULL))>>64;
x129 = (x58)*((uintptr_t)4294967295ULL);
x130 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x131 = (x58)*((uintptr_t)4294967295ULL);
x132 = sizeof(intptr_t) == 4 ? ((uint64_t)(x58)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x58)*((uintptr_t)4294967295ULL))>>64;
x133 = (x130)+(x127);
x134 = (x133)<(x130);
x135 = (x134)+(x128);
x136 = (x135)<(x128);
x137 = (x135)+(x125);
x138 = (x137)<(x125);
x139 = (x136)+(x138);
x140 = (x139)+(x126);
x141 = (x140)<(x126);
x142 = (x140)+(x123);
x143 = (x142)<(x123);
x144 = (x141)+(x143);
x145 = (x144)+(x124);
x146 = (x145)<(x124);
x147 = (x145)+(x121);
x148 = (x147)<(x121);
x149 = (x146)+(x148);
x150 = (x149)+(x122);
x151 = (x150)<(x122);
x152 = (x150)+(x119);
x153 = (x152)<(x119);
x154 = (x151)+(x153);
x155 = (x154)+(x120);
x156 = (x155)<(x120);
x157 = (x155)+(x117);
x158 = (x157)<(x117);
x159 = (x156)+(x158);
x160 = (x159)+(x118);
x161 = (x160)<(x118);
x162 = (x160)+(x115);
x163 = (x162)<(x115);
x164 = (x161)+(x163);
x165 = (x164)+(x116);
x166 = (x165)<(x116);
x167 = (x165)+(x113);
x168 = (x167)<(x113);
x169 = (x166)+(x168);
x170 = (x169)+(x114);
x171 = (x58)+(x131);
x172 = (x171)<(x58);
x173 = (x172)+(x60);
x174 = (x173)<(x60);
x175 = (x173)+(x132);
x176 = (x175)<(x132);
x177 = (x174)+(x176);
x178 = (x177)+(x64);
x179 = (x178)<(x64);
x180 = (x179)+(x69);
x181 = (x180)<(x69);
x182 = (x180)+(x129);
x183 = (x182)<(x129);
x184 = (x181)+(x183);
x185 = (x184)+(x74);
x186 = (x185)<(x74);
x187 = (x185)+(x133);
x188 = (x187)<(x133);
x189 = (x186)+(x188);
x190 = (x189)+(x79);
x191 = (x190)<(x79);
x192 = (x190)+(x137);
x193 = (x192)<(x137);
x194 = (x191)+(x193);
x195 = (x194)+(x84);
x196 = (x195)<(x84);
x197 = (x195)+(x142);
x198 = (x197)<(x142);
x199 = (x196)+(x198);
x200 = (x199)+(x89);
x201 = (x200)<(x89);
x202 = (x200)+(x147);
x203 = (x202)<(x147);
x204 = (x201)+(x203);
x205 = (x204)+(x94);
x206 = (x205)<(x94);
x207 = (x205)+(x152);
x208 = (x207)<(x152);
x209 = (x206)+(x208);
x210 = (x209)+(x99);
x211 = (x210)<(x99);
x212 = (x210)+(x157);
x213 = (x212)<(x157);
x214 = (x211)+(x213);
x215 = (x214)+(x104);
x216 = (x215)<(x104);
x217 = (x215)+(x162);
x218 = (x217)<(x162);
x219 = (x216)+(x218);
x220 = (x219)+(x109);
x221 = (x220)<(x109);
x222 = (x220)+(x167);
x223 = (x222)<(x167);
x224 = (x221)+(x223);
x225 = (x224)+(x112);
x226 = (x225)<(x112);
x227 = (x225)+(x170);
x228 = (x227)<(x170);
x229 = (x226)+(x228);
x230 = (x24)*(x23);
x231 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x23))>>32 : ((__uint128_t)(x24)*(x23))>>64;
x232 = (x24)*(x22);
x233 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x22))>>32 : ((__uint128_t)(x24)*(x22))>>64;
x234 = (x24)*(x21);
x235 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x21))>>32 : ((__uint128_t)(x24)*(x21))>>64;
x236 = (x24)*(x20);
x237 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x20))>>32 : ((__uint128_t)(x24)*(x20))>>64;
x238 = (x24)*(x19);
x239 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x19))>>32 : ((__uint128_t)(x24)*(x19))>>64;
x240 = (x24)*(x18);
x241 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x18))>>32 : ((__uint128_t)(x24)*(x18))>>64;
x242 = (x24)*(x17);
x243 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x17))>>32 : ((__uint128_t)(x24)*(x17))>>64;
x244 = (x24)*(x16);
x245 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x16))>>32 : ((__uint128_t)(x24)*(x16))>>64;
x246 = (x24)*(x15);
x247 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x15))>>32 : ((__uint128_t)(x24)*(x15))>>64;
x248 = (x24)*(x14);
x249 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x14))>>32 : ((__uint128_t)(x24)*(x14))>>64;
x250 = (x24)*(x13);
x251 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x13))>>32 : ((__uint128_t)(x24)*(x13))>>64;
x252 = (x24)*(x12);
x253 = sizeof(intptr_t) == 4 ? ((uint64_t)(x24)*(x12))>>32 : ((__uint128_t)(x24)*(x12))>>64;
x254 = (x253)+(x250);
x255 = (x254)<(x253);
x256 = (x255)+(x251);
x257 = (x256)<(x251);
x258 = (x256)+(x248);
x259 = (x258)<(x248);
x260 = (x257)+(x259);
x261 = (x260)+(x249);
x262 = (x261)<(x249);
x263 = (x261)+(x246);
x264 = (x263)<(x246);
x265 = (x262)+(x264);
x266 = (x265)+(x247);
x267 = (x266)<(x247);
x268 = (x266)+(x244);
x269 = (x268)<(x244);
x270 = (x267)+(x269);
x271 = (x270)+(x245);
x272 = (x271)<(x245);
x273 = (x271)+(x242);
x274 = (x273)<(x242);
x275 = (x272)+(x274);
x276 = (x275)+(x243);
x277 = (x276)<(x243);
x278 = (x276)+(x240);
x279 = (x278)<(x240);
x280 = (x277)+(x279);
x281 = (x280)+(x241);
x282 = (x281)<(x241);
x283 = (x281)+(x238);
x284 = (x283)<(x238);
x285 = (x282)+(x284);
x286 = (x285)+(x239);
x287 = (x286)<(x239);
x288 = (x286)+(x236);
x289 = (x288)<(x236);
x290 = (x287)+(x289);
x291 = (x290)+(x237);
x292 = (x291)<(x237);
x293 = (x291)+(x234);
x294 = (x293)<(x234);
x295 = (x292)+(x294);
x296 = (x295)+(x235);
x297 = (x296)<(x235);
x298 = (x296)+(x232);
x299 = (x298)<(x232);
x300 = (x297)+(x299);
x301 = (x300)+(x233);
x302 = (x301)<(x233);
x303 = (x301)+(x230);
x304 = (x303)<(x230);
x305 = (x302)+(x304);
x306 = (x305)+(x231);
x307 = (x175)+(x252);
x308 = (x307)<(x175);
x309 = (x308)+(x178);
x310 = (x309)<(x178);
x311 = (x309)+(x254);
x312 = (x311)<(x254);
x313 = (x310)+(x312);
x314 = (x313)+(x182);
x315 = (x314)<(x182);
x316 = (x314)+(x258);
x317 = (x316)<(x258);
x318 = (x315)+(x317);
x319 = (x318)+(x187);
x320 = (x319)<(x187);
x321 = (x319)+(x263);
x322 = (x321)<(x263);
x323 = (x320)+(x322);
x324 = (x323)+(x192);
x325 = (x324)<(x192);
x326 = (x324)+(x268);
x327 = (x326)<(x268);
x328 = (x325)+(x327);
x329 = (x328)+(x197);
x330 = (x329)<(x197);
x331 = (x329)+(x273);
x332 = (x331)<(x273);
x333 = (x330)+(x332);
x334 = (x333)+(x202);
x335 = (x334)<(x202);
x336 = (x334)+(x278);
x337 = (x336)<(x278);
x338 = (x335)+(x337);
x339 = (x338)+(x207);
x340 = (x339)<(x207);
x341 = (x339)+(x283);
x342 = (x341)<(x283);
x343 = (x340)+(x342);
x344 = (x343)+(x212);
x345 = (x344)<(x212);
x346 = (x344)+(x288);
x347 = (x346)<(x288);
x348 = (x345)+(x347);
x349 = (x348)+(x217);
x350 = (x349)<(x217);
x351 = (x349)+(x293);
x352 = (x351)<(x293);
x353 = (x350)+(x352);
x354 = (x353)+(x222);
x355 = (x354)<(x222);
x356 = (x354)+(x298);
x357 = (x356)<(x298);
x358 = (x355)+(x357);
x359 = (x358)+(x227);
x360 = (x359)<(x227);
x361 = (x359)+(x303);
x362 = (x361)<(x303);
x363 = (x360)+(x362);
x364 = (x363)+(x229);
x365 = (x364)<(x229);
x366 = (x364)+(x306);
x367 = (x366)<(x306);
x368 = (x365)+(x367);
x369 = (x307)*((uintptr_t)4294967295ULL);
x370 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x371 = (x307)*((uintptr_t)4294967295ULL);
x372 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x373 = (x307)*((uintptr_t)4294967295ULL);
x374 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x375 = (x307)*((uintptr_t)4294967295ULL);
x376 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x377 = (x307)*((uintptr_t)4294967295ULL);
x378 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x379 = (x307)*((uintptr_t)4294967295ULL);
x380 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x381 = (x307)*((uintptr_t)4294967295ULL);
x382 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x383 = (x307)*((uintptr_t)4294967294ULL);
x384 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967294ULL))>>64;
x385 = (x307)*((uintptr_t)4294967295ULL);
x386 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x387 = (x307)*((uintptr_t)4294967295ULL);
x388 = sizeof(intptr_t) == 4 ? ((uint64_t)(x307)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x307)*((uintptr_t)4294967295ULL))>>64;
x389 = (x386)+(x383);
x390 = (x389)<(x386);
x391 = (x390)+(x384);
x392 = (x391)<(x384);
x393 = (x391)+(x381);
x394 = (x393)<(x381);
x395 = (x392)+(x394);
x396 = (x395)+(x382);
x397 = (x396)<(x382);
x398 = (x396)+(x379);
x399 = (x398)<(x379);
x400 = (x397)+(x399);
x401 = (x400)+(x380);
x402 = (x401)<(x380);
x403 = (x401)+(x377);
x404 = (x403)<(x377);
x405 = (x402)+(x404);
x406 = (x405)+(x378);
x407 = (x406)<(x378);
x408 = (x406)+(x375);
x409 = (x408)<(x375);
x410 = (x407)+(x409);
x411 = (x410)+(x376);
x412 = (x411)<(x376);
x413 = (x411)+(x373);
x414 = (x413)<(x373);
x415 = (x412)+(x414);
x416 = (x415)+(x374);
x417 = (x416)<(x374);
x418 = (x416)+(x371);
x419 = (x418)<(x371);
x420 = (x417)+(x419);
x421 = (x420)+(x372);
x422 = (x421)<(x372);
x423 = (x421)+(x369);
x424 = (x423)<(x369);
x425 = (x422)+(x424);
x426 = (x425)+(x370);
x427 = (x307)+(x387);
x428 = (x427)<(x307);
x429 = (x428)+(x311);
x430 = (x429)<(x311);
x431 = (x429)+(x388);
x432 = (x431)<(x388);
x433 = (x430)+(x432);
x434 = (x433)+(x316);
x435 = (x434)<(x316);
x436 = (x435)+(x321);
x437 = (x436)<(x321);
x438 = (x436)+(x385);
x439 = (x438)<(x385);
x440 = (x437)+(x439);
x441 = (x440)+(x326);
x442 = (x441)<(x326);
x443 = (x441)+(x389);
x444 = (x443)<(x389);
x445 = (x442)+(x444);
x446 = (x445)+(x331);
x447 = (x446)<(x331);
x448 = (x446)+(x393);
x449 = (x448)<(x393);
x450 = (x447)+(x449);
x451 = (x450)+(x336);
x452 = (x451)<(x336);
x453 = (x451)+(x398);
x454 = (x453)<(x398);
x455 = (x452)+(x454);
x456 = (x455)+(x341);
x457 = (x456)<(x341);
x458 = (x456)+(x403);
x459 = (x458)<(x403);
x460 = (x457)+(x459);
x461 = (x460)+(x346);
x462 = (x461)<(x346);
x463 = (x461)+(x408);
x464 = (x463)<(x408);
x465 = (x462)+(x464);
x466 = (x465)+(x351);
x467 = (x466)<(x351);
x468 = (x466)+(x413);
x469 = (x468)<(x413);
x470 = (x467)+(x469);
x471 = (x470)+(x356);
x472 = (x471)<(x356);
x473 = (x471)+(x418);
x474 = (x473)<(x418);
x475 = (x472)+(x474);
x476 = (x475)+(x361);
x477 = (x476)<(x361);
x478 = (x476)+(x423);
x479 = (x478)<(x423);
x480 = (x477)+(x479);
x481 = (x480)+(x366);
x482 = (x481)<(x366);
x483 = (x481)+(x426);
x484 = (x483)<(x426);
x485 = (x482)+(x484);
x486 = (x485)+(x368);
x487 = (x25)*(x23);
x488 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x23))>>32 : ((__uint128_t)(x25)*(x23))>>64;
x489 = (x25)*(x22);
x490 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x22))>>32 : ((__uint128_t)(x25)*(x22))>>64;
x491 = (x25)*(x21);
x492 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x21))>>32 : ((__uint128_t)(x25)*(x21))>>64;
x493 = (x25)*(x20);
x494 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x20))>>32 : ((__uint128_t)(x25)*(x20))>>64;
x495 = (x25)*(x19);
x496 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x19))>>32 : ((__uint128_t)(x25)*(x19))>>64;
x497 = (x25)*(x18);
x498 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x18))>>32 : ((__uint128_t)(x25)*(x18))>>64;
x499 = (x25)*(x17);
x500 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x17))>>32 : ((__uint128_t)(x25)*(x17))>>64;
x501 = (x25)*(x16);
x502 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x16))>>32 : ((__uint128_t)(x25)*(x16))>>64;
x503 = (x25)*(x15);
x504 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x15))>>32 : ((__uint128_t)(x25)*(x15))>>64;
x505 = (x25)*(x14);
x506 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x14))>>32 : ((__uint128_t)(x25)*(x14))>>64;
x507 = (x25)*(x13);
x508 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x13))>>32 : ((__uint128_t)(x25)*(x13))>>64;
x509 = (x25)*(x12);
x510 = sizeof(intptr_t) == 4 ? ((uint64_t)(x25)*(x12))>>32 : ((__uint128_t)(x25)*(x12))>>64;
x511 = (x510)+(x507);
x512 = (x511)<(x510);
x513 = (x512)+(x508);
x514 = (x513)<(x508);
x515 = (x513)+(x505);
x516 = (x515)<(x505);
x517 = (x514)+(x516);
x518 = (x517)+(x506);
x519 = (x518)<(x506);
x520 = (x518)+(x503);
x521 = (x520)<(x503);
x522 = (x519)+(x521);
x523 = (x522)+(x504);
x524 = (x523)<(x504);
x525 = (x523)+(x501);
x526 = (x525)<(x501);
x527 = (x524)+(x526);
x528 = (x527)+(x502);
x529 = (x528)<(x502);
x530 = (x528)+(x499);
x531 = (x530)<(x499);
x532 = (x529)+(x531);
x533 = (x532)+(x500);
x534 = (x533)<(x500);
x535 = (x533)+(x497);
x536 = (x535)<(x497);
x537 = (x534)+(x536);
x538 = (x537)+(x498);
x539 = (x538)<(x498);
x540 = (x538)+(x495);
x541 = (x540)<(x495);
x542 = (x539)+(x541);
x543 = (x542)+(x496);
x544 = (x543)<(x496);
x545 = (x543)+(x493);
x546 = (x545)<(x493);
x547 = (x544)+(x546);
x548 = (x547)+(x494);
x549 = (x548)<(x494);
x550 = (x548)+(x491);
x551 = (x550)<(x491);
x552 = (x549)+(x551);
x553 = (x552)+(x492);
x554 = (x553)<(x492);
x555 = (x553)+(x489);
x556 = (x555)<(x489);
x557 = (x554)+(x556);
x558 = (x557)+(x490);
x559 = (x558)<(x490);
x560 = (x558)+(x487);
x561 = (x560)<(x487);
x562 = (x559)+(x561);
x563 = (x562)+(x488);
x564 = (x431)+(x509);
x565 = (x564)<(x431);
x566 = (x565)+(x434);
x567 = (x566)<(x434);
x568 = (x566)+(x511);
x569 = (x568)<(x511);
x570 = (x567)+(x569);
x571 = (x570)+(x438);
x572 = (x571)<(x438);
x573 = (x571)+(x515);
x574 = (x573)<(x515);
x575 = (x572)+(x574);
x576 = (x575)+(x443);
x577 = (x576)<(x443);
x578 = (x576)+(x520);
x579 = (x578)<(x520);
x580 = (x577)+(x579);
x581 = (x580)+(x448);
x582 = (x581)<(x448);
x583 = (x581)+(x525);
x584 = (x583)<(x525);
x585 = (x582)+(x584);
x586 = (x585)+(x453);
x587 = (x586)<(x453);
x588 = (x586)+(x530);
x589 = (x588)<(x530);
x590 = (x587)+(x589);
x591 = (x590)+(x458);
x592 = (x591)<(x458);
x593 = (x591)+(x535);
x594 = (x593)<(x535);
x595 = (x592)+(x594);
x596 = (x595)+(x463);
x597 = (x596)<(x463);
x598 = (x596)+(x540);
x599 = (x598)<(x540);
x600 = (x597)+(x599);
x601 = (x600)+(x468);
x602 = (x601)<(x468);
x603 = (x601)+(x545);
x604 = (x603)<(x545);
x605 = (x602)+(x604);
x606 = (x605)+(x473);
x607 = (x606)<(x473);
x608 = (x606)+(x550);
x609 = (x608)<(x550);
x610 = (x607)+(x609);
x611 = (x610)+(x478);
x612 = (x611)<(x478);
x613 = (x611)+(x555);
x614 = (x613)<(x555);
x615 = (x612)+(x614);
x616 = (x615)+(x483);
x617 = (x616)<(x483);
x618 = (x616)+(x560);
x619 = (x618)<(x560);
x620 = (x617)+(x619);
x621 = (x620)+(x486);
x622 = (x621)<(x486);
x623 = (x621)+(x563);
x624 = (x623)<(x563);
x625 = (x622)+(x624);
x626 = (x564)*((uintptr_t)4294967295ULL);
x627 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x628 = (x564)*((uintptr_t)4294967295ULL);
x629 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x630 = (x564)*((uintptr_t)4294967295ULL);
x631 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x632 = (x564)*((uintptr_t)4294967295ULL);
x633 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x634 = (x564)*((uintptr_t)4294967295ULL);
x635 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x636 = (x564)*((uintptr_t)4294967295ULL);
x637 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x638 = (x564)*((uintptr_t)4294967295ULL);
x639 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x640 = (x564)*((uintptr_t)4294967294ULL);
x641 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967294ULL))>>64;
x642 = (x564)*((uintptr_t)4294967295ULL);
x643 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x644 = (x564)*((uintptr_t)4294967295ULL);
x645 = sizeof(intptr_t) == 4 ? ((uint64_t)(x564)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x564)*((uintptr_t)4294967295ULL))>>64;
x646 = (x643)+(x640);
x647 = (x646)<(x643);
x648 = (x647)+(x641);
x649 = (x648)<(x641);
x650 = (x648)+(x638);
x651 = (x650)<(x638);
x652 = (x649)+(x651);
x653 = (x652)+(x639);
x654 = (x653)<(x639);
x655 = (x653)+(x636);
x656 = (x655)<(x636);
x657 = (x654)+(x656);
x658 = (x657)+(x637);
x659 = (x658)<(x637);
x660 = (x658)+(x634);
x661 = (x660)<(x634);
x662 = (x659)+(x661);
x663 = (x662)+(x635);
x664 = (x663)<(x635);
x665 = (x663)+(x632);
x666 = (x665)<(x632);
x667 = (x664)+(x666);
x668 = (x667)+(x633);
x669 = (x668)<(x633);
x670 = (x668)+(x630);
x671 = (x670)<(x630);
x672 = (x669)+(x671);
x673 = (x672)+(x631);
x674 = (x673)<(x631);
x675 = (x673)+(x628);
x676 = (x675)<(x628);
x677 = (x674)+(x676);
x678 = (x677)+(x629);
x679 = (x678)<(x629);
x680 = (x678)+(x626);
x681 = (x680)<(x626);
x682 = (x679)+(x681);
x683 = (x682)+(x627);
x684 = (x564)+(x644);
x685 = (x684)<(x564);
x686 = (x685)+(x568);
x687 = (x686)<(x568);
x688 = (x686)+(x645);
x689 = (x688)<(x645);
x690 = (x687)+(x689);
x691 = (x690)+(x573);
x692 = (x691)<(x573);
x693 = (x692)+(x578);
x694 = (x693)<(x578);
x695 = (x693)+(x642);
x696 = (x695)<(x642);
x697 = (x694)+(x696);
x698 = (x697)+(x583);
x699 = (x698)<(x583);
x700 = (x698)+(x646);
x701 = (x700)<(x646);
x702 = (x699)+(x701);
x703 = (x702)+(x588);
x704 = (x703)<(x588);
x705 = (x703)+(x650);
x706 = (x705)<(x650);
x707 = (x704)+(x706);
x708 = (x707)+(x593);
x709 = (x708)<(x593);
x710 = (x708)+(x655);
x711 = (x710)<(x655);
x712 = (x709)+(x711);
x713 = (x712)+(x598);
x714 = (x713)<(x598);
x715 = (x713)+(x660);
x716 = (x715)<(x660);
x717 = (x714)+(x716);
x718 = (x717)+(x603);
x719 = (x718)<(x603);
x720 = (x718)+(x665);
x721 = (x720)<(x665);
x722 = (x719)+(x721);
x723 = (x722)+(x608);
x724 = (x723)<(x608);
x725 = (x723)+(x670);
x726 = (x725)<(x670);
x727 = (x724)+(x726);
x728 = (x727)+(x613);
x729 = (x728)<(x613);
x730 = (x728)+(x675);
x731 = (x730)<(x675);
x732 = (x729)+(x731);
x733 = (x732)+(x618);
x734 = (x733)<(x618);
x735 = (x733)+(x680);
x736 = (x735)<(x680);
x737 = (x734)+(x736);
x738 = (x737)+(x623);
x739 = (x738)<(x623);
x740 = (x738)+(x683);
x741 = (x740)<(x683);
x742 = (x739)+(x741);
x743 = (x742)+(x625);
x744 = (x26)*(x23);
x745 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x23))>>32 : ((__uint128_t)(x26)*(x23))>>64;
x746 = (x26)*(x22);
x747 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x22))>>32 : ((__uint128_t)(x26)*(x22))>>64;
x748 = (x26)*(x21);
x749 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x21))>>32 : ((__uint128_t)(x26)*(x21))>>64;
x750 = (x26)*(x20);
x751 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x20))>>32 : ((__uint128_t)(x26)*(x20))>>64;
x752 = (x26)*(x19);
x753 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x19))>>32 : ((__uint128_t)(x26)*(x19))>>64;
x754 = (x26)*(x18);
x755 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x18))>>32 : ((__uint128_t)(x26)*(x18))>>64;
x756 = (x26)*(x17);
x757 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x17))>>32 : ((__uint128_t)(x26)*(x17))>>64;
x758 = (x26)*(x16);
x759 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x16))>>32 : ((__uint128_t)(x26)*(x16))>>64;
x760 = (x26)*(x15);
x761 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x15))>>32 : ((__uint128_t)(x26)*(x15))>>64;
x762 = (x26)*(x14);
x763 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x14))>>32 : ((__uint128_t)(x26)*(x14))>>64;
x764 = (x26)*(x13);
x765 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x13))>>32 : ((__uint128_t)(x26)*(x13))>>64;
x766 = (x26)*(x12);
x767 = sizeof(intptr_t) == 4 ? ((uint64_t)(x26)*(x12))>>32 : ((__uint128_t)(x26)*(x12))>>64;
x768 = (x767)+(x764);
x769 = (x768)<(x767);
x770 = (x769)+(x765);
x771 = (x770)<(x765);
x772 = (x770)+(x762);
x773 = (x772)<(x762);
x774 = (x771)+(x773);
x775 = (x774)+(x763);
x776 = (x775)<(x763);
x777 = (x775)+(x760);
x778 = (x777)<(x760);
x779 = (x776)+(x778);
x780 = (x779)+(x761);
x781 = (x780)<(x761);
x782 = (x780)+(x758);
x783 = (x782)<(x758);
x784 = (x781)+(x783);
x785 = (x784)+(x759);
x786 = (x785)<(x759);
x787 = (x785)+(x756);
x788 = (x787)<(x756);
x789 = (x786)+(x788);
x790 = (x789)+(x757);
x791 = (x790)<(x757);
x792 = (x790)+(x754);
x793 = (x792)<(x754);
x794 = (x791)+(x793);
x795 = (x794)+(x755);
x796 = (x795)<(x755);
x797 = (x795)+(x752);
x798 = (x797)<(x752);
x799 = (x796)+(x798);
x800 = (x799)+(x753);
x801 = (x800)<(x753);
x802 = (x800)+(x750);
x803 = (x802)<(x750);
x804 = (x801)+(x803);
x805 = (x804)+(x751);
x806 = (x805)<(x751);
x807 = (x805)+(x748);
x808 = (x807)<(x748);
x809 = (x806)+(x808);
x810 = (x809)+(x749);
x811 = (x810)<(x749);
x812 = (x810)+(x746);
x813 = (x812)<(x746);
x814 = (x811)+(x813);
x815 = (x814)+(x747);
x816 = (x815)<(x747);
x817 = (x815)+(x744);
x818 = (x817)<(x744);
x819 = (x816)+(x818);
x820 = (x819)+(x745);
x821 = (x688)+(x766);
x822 = (x821)<(x688);
x823 = (x822)+(x691);
x824 = (x823)<(x691);
x825 = (x823)+(x768);
x826 = (x825)<(x768);
x827 = (x824)+(x826);
x828 = (x827)+(x695);
x829 = (x828)<(x695);
x830 = (x828)+(x772);
x831 = (x830)<(x772);
x832 = (x829)+(x831);
x833 = (x832)+(x700);
x834 = (x833)<(x700);
x835 = (x833)+(x777);
x836 = (x835)<(x777);
x837 = (x834)+(x836);
x838 = (x837)+(x705);
x839 = (x838)<(x705);
x840 = (x838)+(x782);
x841 = (x840)<(x782);
x842 = (x839)+(x841);
x843 = (x842)+(x710);
x844 = (x843)<(x710);
x845 = (x843)+(x787);
x846 = (x845)<(x787);
x847 = (x844)+(x846);
x848 = (x847)+(x715);
x849 = (x848)<(x715);
x850 = (x848)+(x792);
x851 = (x850)<(x792);
x852 = (x849)+(x851);
x853 = (x852)+(x720);
x854 = (x853)<(x720);
x855 = (x853)+(x797);
x856 = (x855)<(x797);
x857 = (x854)+(x856);
x858 = (x857)+(x725);
x859 = (x858)<(x725);
x860 = (x858)+(x802);
x861 = (x860)<(x802);
x862 = (x859)+(x861);
x863 = (x862)+(x730);
x864 = (x863)<(x730);
x865 = (x863)+(x807);
x866 = (x865)<(x807);
x867 = (x864)+(x866);
x868 = (x867)+(x735);
x869 = (x868)<(x735);
x870 = (x868)+(x812);
x871 = (x870)<(x812);
x872 = (x869)+(x871);
x873 = (x872)+(x740);
x874 = (x873)<(x740);
x875 = (x873)+(x817);
x876 = (x875)<(x817);
x877 = (x874)+(x876);
x878 = (x877)+(x743);
x879 = (x878)<(x743);
x880 = (x878)+(x820);
x881 = (x880)<(x820);
x882 = (x879)+(x881);
x883 = (x821)*((uintptr_t)4294967295ULL);
x884 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x885 = (x821)*((uintptr_t)4294967295ULL);
x886 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x887 = (x821)*((uintptr_t)4294967295ULL);
x888 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x889 = (x821)*((uintptr_t)4294967295ULL);
x890 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x891 = (x821)*((uintptr_t)4294967295ULL);
x892 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x893 = (x821)*((uintptr_t)4294967295ULL);
x894 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x895 = (x821)*((uintptr_t)4294967295ULL);
x896 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x897 = (x821)*((uintptr_t)4294967294ULL);
x898 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967294ULL))>>64;
x899 = (x821)*((uintptr_t)4294967295ULL);
x900 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x901 = (x821)*((uintptr_t)4294967295ULL);
x902 = sizeof(intptr_t) == 4 ? ((uint64_t)(x821)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x821)*((uintptr_t)4294967295ULL))>>64;
x903 = (x900)+(x897);
x904 = (x903)<(x900);
x905 = (x904)+(x898);
x906 = (x905)<(x898);
x907 = (x905)+(x895);
x908 = (x907)<(x895);
x909 = (x906)+(x908);
x910 = (x909)+(x896);
x911 = (x910)<(x896);
x912 = (x910)+(x893);
x913 = (x912)<(x893);
x914 = (x911)+(x913);
x915 = (x914)+(x894);
x916 = (x915)<(x894);
x917 = (x915)+(x891);
x918 = (x917)<(x891);
x919 = (x916)+(x918);
x920 = (x919)+(x892);
x921 = (x920)<(x892);
x922 = (x920)+(x889);
x923 = (x922)<(x889);
x924 = (x921)+(x923);
x925 = (x924)+(x890);
x926 = (x925)<(x890);
x927 = (x925)+(x887);
x928 = (x927)<(x887);
x929 = (x926)+(x928);
x930 = (x929)+(x888);
x931 = (x930)<(x888);
x932 = (x930)+(x885);
x933 = (x932)<(x885);
x934 = (x931)+(x933);
x935 = (x934)+(x886);
x936 = (x935)<(x886);
x937 = (x935)+(x883);
x938 = (x937)<(x883);
x939 = (x936)+(x938);
x940 = (x939)+(x884);
x941 = (x821)+(x901);
x942 = (x941)<(x821);
x943 = (x942)+(x825);
x944 = (x943)<(x825);
x945 = (x943)+(x902);
x946 = (x945)<(x902);
x947 = (x944)+(x946);
x948 = (x947)+(x830);
x949 = (x948)<(x830);
x950 = (x949)+(x835);
x951 = (x950)<(x835);
x952 = (x950)+(x899);
x953 = (x952)<(x899);
x954 = (x951)+(x953);
x955 = (x954)+(x840);
x956 = (x955)<(x840);
x957 = (x955)+(x903);
x958 = (x957)<(x903);
x959 = (x956)+(x958);
x960 = (x959)+(x845);
x961 = (x960)<(x845);
x962 = (x960)+(x907);
x963 = (x962)<(x907);
x964 = (x961)+(x963);
x965 = (x964)+(x850);
x966 = (x965)<(x850);
x967 = (x965)+(x912);
x968 = (x967)<(x912);
x969 = (x966)+(x968);
x970 = (x969)+(x855);
x971 = (x970)<(x855);
x972 = (x970)+(x917);
x973 = (x972)<(x917);
x974 = (x971)+(x973);
x975 = (x974)+(x860);
x976 = (x975)<(x860);
x977 = (x975)+(x922);
x978 = (x977)<(x922);
x979 = (x976)+(x978);
x980 = (x979)+(x865);
x981 = (x980)<(x865);
x982 = (x980)+(x927);
x983 = (x982)<(x927);
x984 = (x981)+(x983);
x985 = (x984)+(x870);
x986 = (x985)<(x870);
x987 = (x985)+(x932);
x988 = (x987)<(x932);
x989 = (x986)+(x988);
x990 = (x989)+(x875);
x991 = (x990)<(x875);
x992 = (x990)+(x937);
x993 = (x992)<(x937);
x994 = (x991)+(x993);
x995 = (x994)+(x880);
x996 = (x995)<(x880);
x997 = (x995)+(x940);
x998 = (x997)<(x940);
x999 = (x996)+(x998);
x1000 = (x999)+(x882);
x1001 = (x27)*(x23);
x1002 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x23))>>32 : ((__uint128_t)(x27)*(x23))>>64;
x1003 = (x27)*(x22);
x1004 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x22))>>32 : ((__uint128_t)(x27)*(x22))>>64;
x1005 = (x27)*(x21);
x1006 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x21))>>32 : ((__uint128_t)(x27)*(x21))>>64;
x1007 = (x27)*(x20);
x1008 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x20))>>32 : ((__uint128_t)(x27)*(x20))>>64;
x1009 = (x27)*(x19);
x1010 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x19))>>32 : ((__uint128_t)(x27)*(x19))>>64;
x1011 = (x27)*(x18);
x1012 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x18))>>32 : ((__uint128_t)(x27)*(x18))>>64;
x1013 = (x27)*(x17);
x1014 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x17))>>32 : ((__uint128_t)(x27)*(x17))>>64;
x1015 = (x27)*(x16);
x1016 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x16))>>32 : ((__uint128_t)(x27)*(x16))>>64;
x1017 = (x27)*(x15);
x1018 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x15))>>32 : ((__uint128_t)(x27)*(x15))>>64;
x1019 = (x27)*(x14);
x1020 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x14))>>32 : ((__uint128_t)(x27)*(x14))>>64;
x1021 = (x27)*(x13);
x1022 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x13))>>32 : ((__uint128_t)(x27)*(x13))>>64;
x1023 = (x27)*(x12);
x1024 = sizeof(intptr_t) == 4 ? ((uint64_t)(x27)*(x12))>>32 : ((__uint128_t)(x27)*(x12))>>64;
x1025 = (x1024)+(x1021);
x1026 = (x1025)<(x1024);
x1027 = (x1026)+(x1022);
x1028 = (x1027)<(x1022);
x1029 = (x1027)+(x1019);
x1030 = (x1029)<(x1019);
x1031 = (x1028)+(x1030);
x1032 = (x1031)+(x1020);
x1033 = (x1032)<(x1020);
x1034 = (x1032)+(x1017);
x1035 = (x1034)<(x1017);
x1036 = (x1033)+(x1035);
x1037 = (x1036)+(x1018);
x1038 = (x1037)<(x1018);
x1039 = (x1037)+(x1015);
x1040 = (x1039)<(x1015);
x1041 = (x1038)+(x1040);
x1042 = (x1041)+(x1016);
x1043 = (x1042)<(x1016);
x1044 = (x1042)+(x1013);
x1045 = (x1044)<(x1013);
x1046 = (x1043)+(x1045);
x1047 = (x1046)+(x1014);
x1048 = (x1047)<(x1014);
x1049 = (x1047)+(x1011);
x1050 = (x1049)<(x1011);
x1051 = (x1048)+(x1050);
x1052 = (x1051)+(x1012);
x1053 = (x1052)<(x1012);
x1054 = (x1052)+(x1009);
x1055 = (x1054)<(x1009);
x1056 = (x1053)+(x1055);
x1057 = (x1056)+(x1010);
x1058 = (x1057)<(x1010);
x1059 = (x1057)+(x1007);
x1060 = (x1059)<(x1007);
x1061 = (x1058)+(x1060);
x1062 = (x1061)+(x1008);
x1063 = (x1062)<(x1008);
x1064 = (x1062)+(x1005);
x1065 = (x1064)<(x1005);
x1066 = (x1063)+(x1065);
x1067 = (x1066)+(x1006);
x1068 = (x1067)<(x1006);
x1069 = (x1067)+(x1003);
x1070 = (x1069)<(x1003);
x1071 = (x1068)+(x1070);
x1072 = (x1071)+(x1004);
x1073 = (x1072)<(x1004);
x1074 = (x1072)+(x1001);
x1075 = (x1074)<(x1001);
x1076 = (x1073)+(x1075);
x1077 = (x1076)+(x1002);
x1078 = (x945)+(x1023);
x1079 = (x1078)<(x945);
x1080 = (x1079)+(x948);
x1081 = (x1080)<(x948);
x1082 = (x1080)+(x1025);
x1083 = (x1082)<(x1025);
x1084 = (x1081)+(x1083);
x1085 = (x1084)+(x952);
x1086 = (x1085)<(x952);
x1087 = (x1085)+(x1029);
x1088 = (x1087)<(x1029);
x1089 = (x1086)+(x1088);
x1090 = (x1089)+(x957);
x1091 = (x1090)<(x957);
x1092 = (x1090)+(x1034);
x1093 = (x1092)<(x1034);
x1094 = (x1091)+(x1093);
x1095 = (x1094)+(x962);
x1096 = (x1095)<(x962);
x1097 = (x1095)+(x1039);
x1098 = (x1097)<(x1039);
x1099 = (x1096)+(x1098);
x1100 = (x1099)+(x967);
x1101 = (x1100)<(x967);
x1102 = (x1100)+(x1044);
x1103 = (x1102)<(x1044);
x1104 = (x1101)+(x1103);
x1105 = (x1104)+(x972);
x1106 = (x1105)<(x972);
x1107 = (x1105)+(x1049);
x1108 = (x1107)<(x1049);
x1109 = (x1106)+(x1108);
x1110 = (x1109)+(x977);
x1111 = (x1110)<(x977);
x1112 = (x1110)+(x1054);
x1113 = (x1112)<(x1054);
x1114 = (x1111)+(x1113);
x1115 = (x1114)+(x982);
x1116 = (x1115)<(x982);
x1117 = (x1115)+(x1059);
x1118 = (x1117)<(x1059);
x1119 = (x1116)+(x1118);
x1120 = (x1119)+(x987);
x1121 = (x1120)<(x987);
x1122 = (x1120)+(x1064);
x1123 = (x1122)<(x1064);
x1124 = (x1121)+(x1123);
x1125 = (x1124)+(x992);
x1126 = (x1125)<(x992);
x1127 = (x1125)+(x1069);
x1128 = (x1127)<(x1069);
x1129 = (x1126)+(x1128);
x1130 = (x1129)+(x997);
x1131 = (x1130)<(x997);
x1132 = (x1130)+(x1074);
x1133 = (x1132)<(x1074);
x1134 = (x1131)+(x1133);
x1135 = (x1134)+(x1000);
x1136 = (x1135)<(x1000);
x1137 = (x1135)+(x1077);
x1138 = (x1137)<(x1077);
x1139 = (x1136)+(x1138);
x1140 = (x1078)*((uintptr_t)4294967295ULL);
x1141 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1142 = (x1078)*((uintptr_t)4294967295ULL);
x1143 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1144 = (x1078)*((uintptr_t)4294967295ULL);
x1145 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1146 = (x1078)*((uintptr_t)4294967295ULL);
x1147 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1148 = (x1078)*((uintptr_t)4294967295ULL);
x1149 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1150 = (x1078)*((uintptr_t)4294967295ULL);
x1151 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1152 = (x1078)*((uintptr_t)4294967295ULL);
x1153 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1154 = (x1078)*((uintptr_t)4294967294ULL);
x1155 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967294ULL))>>64;
x1156 = (x1078)*((uintptr_t)4294967295ULL);
x1157 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1158 = (x1078)*((uintptr_t)4294967295ULL);
x1159 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1078)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1078)*((uintptr_t)4294967295ULL))>>64;
x1160 = (x1157)+(x1154);
x1161 = (x1160)<(x1157);
x1162 = (x1161)+(x1155);
x1163 = (x1162)<(x1155);
x1164 = (x1162)+(x1152);
x1165 = (x1164)<(x1152);
x1166 = (x1163)+(x1165);
x1167 = (x1166)+(x1153);
x1168 = (x1167)<(x1153);
x1169 = (x1167)+(x1150);
x1170 = (x1169)<(x1150);
x1171 = (x1168)+(x1170);
x1172 = (x1171)+(x1151);
x1173 = (x1172)<(x1151);
x1174 = (x1172)+(x1148);
x1175 = (x1174)<(x1148);
x1176 = (x1173)+(x1175);
x1177 = (x1176)+(x1149);
x1178 = (x1177)<(x1149);
x1179 = (x1177)+(x1146);
x1180 = (x1179)<(x1146);
x1181 = (x1178)+(x1180);
x1182 = (x1181)+(x1147);
x1183 = (x1182)<(x1147);
x1184 = (x1182)+(x1144);
x1185 = (x1184)<(x1144);
x1186 = (x1183)+(x1185);
x1187 = (x1186)+(x1145);
x1188 = (x1187)<(x1145);
x1189 = (x1187)+(x1142);
x1190 = (x1189)<(x1142);
x1191 = (x1188)+(x1190);
x1192 = (x1191)+(x1143);
x1193 = (x1192)<(x1143);
x1194 = (x1192)+(x1140);
x1195 = (x1194)<(x1140);
x1196 = (x1193)+(x1195);
x1197 = (x1196)+(x1141);
x1198 = (x1078)+(x1158);
x1199 = (x1198)<(x1078);
x1200 = (x1199)+(x1082);
x1201 = (x1200)<(x1082);
x1202 = (x1200)+(x1159);
x1203 = (x1202)<(x1159);
x1204 = (x1201)+(x1203);
x1205 = (x1204)+(x1087);
x1206 = (x1205)<(x1087);
x1207 = (x1206)+(x1092);
x1208 = (x1207)<(x1092);
x1209 = (x1207)+(x1156);
x1210 = (x1209)<(x1156);
x1211 = (x1208)+(x1210);
x1212 = (x1211)+(x1097);
x1213 = (x1212)<(x1097);
x1214 = (x1212)+(x1160);
x1215 = (x1214)<(x1160);
x1216 = (x1213)+(x1215);
x1217 = (x1216)+(x1102);
x1218 = (x1217)<(x1102);
x1219 = (x1217)+(x1164);
x1220 = (x1219)<(x1164);
x1221 = (x1218)+(x1220);
x1222 = (x1221)+(x1107);
x1223 = (x1222)<(x1107);
x1224 = (x1222)+(x1169);
x1225 = (x1224)<(x1169);
x1226 = (x1223)+(x1225);
x1227 = (x1226)+(x1112);
x1228 = (x1227)<(x1112);
x1229 = (x1227)+(x1174);
x1230 = (x1229)<(x1174);
x1231 = (x1228)+(x1230);
x1232 = (x1231)+(x1117);
x1233 = (x1232)<(x1117);
x1234 = (x1232)+(x1179);
x1235 = (x1234)<(x1179);
x1236 = (x1233)+(x1235);
x1237 = (x1236)+(x1122);
x1238 = (x1237)<(x1122);
x1239 = (x1237)+(x1184);
x1240 = (x1239)<(x1184);
x1241 = (x1238)+(x1240);
x1242 = (x1241)+(x1127);
x1243 = (x1242)<(x1127);
x1244 = (x1242)+(x1189);
x1245 = (x1244)<(x1189);
x1246 = (x1243)+(x1245);
x1247 = (x1246)+(x1132);
x1248 = (x1247)<(x1132);
x1249 = (x1247)+(x1194);
x1250 = (x1249)<(x1194);
x1251 = (x1248)+(x1250);
x1252 = (x1251)+(x1137);
x1253 = (x1252)<(x1137);
x1254 = (x1252)+(x1197);
x1255 = (x1254)<(x1197);
x1256 = (x1253)+(x1255);
x1257 = (x1256)+(x1139);
x1258 = (x28)*(x23);
x1259 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x23))>>32 : ((__uint128_t)(x28)*(x23))>>64;
x1260 = (x28)*(x22);
x1261 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x22))>>32 : ((__uint128_t)(x28)*(x22))>>64;
x1262 = (x28)*(x21);
x1263 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x21))>>32 : ((__uint128_t)(x28)*(x21))>>64;
x1264 = (x28)*(x20);
x1265 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x20))>>32 : ((__uint128_t)(x28)*(x20))>>64;
x1266 = (x28)*(x19);
x1267 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x19))>>32 : ((__uint128_t)(x28)*(x19))>>64;
x1268 = (x28)*(x18);
x1269 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x18))>>32 : ((__uint128_t)(x28)*(x18))>>64;
x1270 = (x28)*(x17);
x1271 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x17))>>32 : ((__uint128_t)(x28)*(x17))>>64;
x1272 = (x28)*(x16);
x1273 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x16))>>32 : ((__uint128_t)(x28)*(x16))>>64;
x1274 = (x28)*(x15);
x1275 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x15))>>32 : ((__uint128_t)(x28)*(x15))>>64;
x1276 = (x28)*(x14);
x1277 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x14))>>32 : ((__uint128_t)(x28)*(x14))>>64;
x1278 = (x28)*(x13);
x1279 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x13))>>32 : ((__uint128_t)(x28)*(x13))>>64;
x1280 = (x28)*(x12);
x1281 = sizeof(intptr_t) == 4 ? ((uint64_t)(x28)*(x12))>>32 : ((__uint128_t)(x28)*(x12))>>64;
x1282 = (x1281)+(x1278);
x1283 = (x1282)<(x1281);
x1284 = (x1283)+(x1279);
x1285 = (x1284)<(x1279);
x1286 = (x1284)+(x1276);
x1287 = (x1286)<(x1276);
x1288 = (x1285)+(x1287);
x1289 = (x1288)+(x1277);
x1290 = (x1289)<(x1277);
x1291 = (x1289)+(x1274);
x1292 = (x1291)<(x1274);
x1293 = (x1290)+(x1292);
x1294 = (x1293)+(x1275);
x1295 = (x1294)<(x1275);
x1296 = (x1294)+(x1272);
x1297 = (x1296)<(x1272);
x1298 = (x1295)+(x1297);
x1299 = (x1298)+(x1273);
x1300 = (x1299)<(x1273);
x1301 = (x1299)+(x1270);
x1302 = (x1301)<(x1270);
x1303 = (x1300)+(x1302);
x1304 = (x1303)+(x1271);
x1305 = (x1304)<(x1271);
x1306 = (x1304)+(x1268);
x1307 = (x1306)<(x1268);
x1308 = (x1305)+(x1307);
x1309 = (x1308)+(x1269);
x1310 = (x1309)<(x1269);
x1311 = (x1309)+(x1266);
x1312 = (x1311)<(x1266);
x1313 = (x1310)+(x1312);
x1314 = (x1313)+(x1267);
x1315 = (x1314)<(x1267);
x1316 = (x1314)+(x1264);
x1317 = (x1316)<(x1264);
x1318 = (x1315)+(x1317);
x1319 = (x1318)+(x1265);
x1320 = (x1319)<(x1265);
x1321 = (x1319)+(x1262);
x1322 = (x1321)<(x1262);
x1323 = (x1320)+(x1322);
x1324 = (x1323)+(x1263);
x1325 = (x1324)<(x1263);
x1326 = (x1324)+(x1260);
x1327 = (x1326)<(x1260);
x1328 = (x1325)+(x1327);
x1329 = (x1328)+(x1261);
x1330 = (x1329)<(x1261);
x1331 = (x1329)+(x1258);
x1332 = (x1331)<(x1258);
x1333 = (x1330)+(x1332);
x1334 = (x1333)+(x1259);
x1335 = (x1202)+(x1280);
x1336 = (x1335)<(x1202);
x1337 = (x1336)+(x1205);
x1338 = (x1337)<(x1205);
x1339 = (x1337)+(x1282);
x1340 = (x1339)<(x1282);
x1341 = (x1338)+(x1340);
x1342 = (x1341)+(x1209);
x1343 = (x1342)<(x1209);
x1344 = (x1342)+(x1286);
x1345 = (x1344)<(x1286);
x1346 = (x1343)+(x1345);
x1347 = (x1346)+(x1214);
x1348 = (x1347)<(x1214);
x1349 = (x1347)+(x1291);
x1350 = (x1349)<(x1291);
x1351 = (x1348)+(x1350);
x1352 = (x1351)+(x1219);
x1353 = (x1352)<(x1219);
x1354 = (x1352)+(x1296);
x1355 = (x1354)<(x1296);
x1356 = (x1353)+(x1355);
x1357 = (x1356)+(x1224);
x1358 = (x1357)<(x1224);
x1359 = (x1357)+(x1301);
x1360 = (x1359)<(x1301);
x1361 = (x1358)+(x1360);
x1362 = (x1361)+(x1229);
x1363 = (x1362)<(x1229);
x1364 = (x1362)+(x1306);
x1365 = (x1364)<(x1306);
x1366 = (x1363)+(x1365);
x1367 = (x1366)+(x1234);
x1368 = (x1367)<(x1234);
x1369 = (x1367)+(x1311);
x1370 = (x1369)<(x1311);
x1371 = (x1368)+(x1370);
x1372 = (x1371)+(x1239);
x1373 = (x1372)<(x1239);
x1374 = (x1372)+(x1316);
x1375 = (x1374)<(x1316);
x1376 = (x1373)+(x1375);
x1377 = (x1376)+(x1244);
x1378 = (x1377)<(x1244);
x1379 = (x1377)+(x1321);
x1380 = (x1379)<(x1321);
x1381 = (x1378)+(x1380);
x1382 = (x1381)+(x1249);
x1383 = (x1382)<(x1249);
x1384 = (x1382)+(x1326);
x1385 = (x1384)<(x1326);
x1386 = (x1383)+(x1385);
x1387 = (x1386)+(x1254);
x1388 = (x1387)<(x1254);
x1389 = (x1387)+(x1331);
x1390 = (x1389)<(x1331);
x1391 = (x1388)+(x1390);
x1392 = (x1391)+(x1257);
x1393 = (x1392)<(x1257);
x1394 = (x1392)+(x1334);
x1395 = (x1394)<(x1334);
x1396 = (x1393)+(x1395);
x1397 = (x1335)*((uintptr_t)4294967295ULL);
x1398 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1399 = (x1335)*((uintptr_t)4294967295ULL);
x1400 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1401 = (x1335)*((uintptr_t)4294967295ULL);
x1402 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1403 = (x1335)*((uintptr_t)4294967295ULL);
x1404 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1405 = (x1335)*((uintptr_t)4294967295ULL);
x1406 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1407 = (x1335)*((uintptr_t)4294967295ULL);
x1408 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1409 = (x1335)*((uintptr_t)4294967295ULL);
x1410 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1411 = (x1335)*((uintptr_t)4294967294ULL);
x1412 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967294ULL))>>64;
x1413 = (x1335)*((uintptr_t)4294967295ULL);
x1414 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1415 = (x1335)*((uintptr_t)4294967295ULL);
x1416 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1335)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1335)*((uintptr_t)4294967295ULL))>>64;
x1417 = (x1414)+(x1411);
x1418 = (x1417)<(x1414);
x1419 = (x1418)+(x1412);
x1420 = (x1419)<(x1412);
x1421 = (x1419)+(x1409);
x1422 = (x1421)<(x1409);
x1423 = (x1420)+(x1422);
x1424 = (x1423)+(x1410);
x1425 = (x1424)<(x1410);
x1426 = (x1424)+(x1407);
x1427 = (x1426)<(x1407);
x1428 = (x1425)+(x1427);
x1429 = (x1428)+(x1408);
x1430 = (x1429)<(x1408);
x1431 = (x1429)+(x1405);
x1432 = (x1431)<(x1405);
x1433 = (x1430)+(x1432);
x1434 = (x1433)+(x1406);
x1435 = (x1434)<(x1406);
x1436 = (x1434)+(x1403);
x1437 = (x1436)<(x1403);
x1438 = (x1435)+(x1437);
x1439 = (x1438)+(x1404);
x1440 = (x1439)<(x1404);
x1441 = (x1439)+(x1401);
x1442 = (x1441)<(x1401);
x1443 = (x1440)+(x1442);
x1444 = (x1443)+(x1402);
x1445 = (x1444)<(x1402);
x1446 = (x1444)+(x1399);
x1447 = (x1446)<(x1399);
x1448 = (x1445)+(x1447);
x1449 = (x1448)+(x1400);
x1450 = (x1449)<(x1400);
x1451 = (x1449)+(x1397);
x1452 = (x1451)<(x1397);
x1453 = (x1450)+(x1452);
x1454 = (x1453)+(x1398);
x1455 = (x1335)+(x1415);
x1456 = (x1455)<(x1335);
x1457 = (x1456)+(x1339);
x1458 = (x1457)<(x1339);
x1459 = (x1457)+(x1416);
x1460 = (x1459)<(x1416);
x1461 = (x1458)+(x1460);
x1462 = (x1461)+(x1344);
x1463 = (x1462)<(x1344);
x1464 = (x1463)+(x1349);
x1465 = (x1464)<(x1349);
x1466 = (x1464)+(x1413);
x1467 = (x1466)<(x1413);
x1468 = (x1465)+(x1467);
x1469 = (x1468)+(x1354);
x1470 = (x1469)<(x1354);
x1471 = (x1469)+(x1417);
x1472 = (x1471)<(x1417);
x1473 = (x1470)+(x1472);
x1474 = (x1473)+(x1359);
x1475 = (x1474)<(x1359);
x1476 = (x1474)+(x1421);
x1477 = (x1476)<(x1421);
x1478 = (x1475)+(x1477);
x1479 = (x1478)+(x1364);
x1480 = (x1479)<(x1364);
x1481 = (x1479)+(x1426);
x1482 = (x1481)<(x1426);
x1483 = (x1480)+(x1482);
x1484 = (x1483)+(x1369);
x1485 = (x1484)<(x1369);
x1486 = (x1484)+(x1431);
x1487 = (x1486)<(x1431);
x1488 = (x1485)+(x1487);
x1489 = (x1488)+(x1374);
x1490 = (x1489)<(x1374);
x1491 = (x1489)+(x1436);
x1492 = (x1491)<(x1436);
x1493 = (x1490)+(x1492);
x1494 = (x1493)+(x1379);
x1495 = (x1494)<(x1379);
x1496 = (x1494)+(x1441);
x1497 = (x1496)<(x1441);
x1498 = (x1495)+(x1497);
x1499 = (x1498)+(x1384);
x1500 = (x1499)<(x1384);
x1501 = (x1499)+(x1446);
x1502 = (x1501)<(x1446);
x1503 = (x1500)+(x1502);
x1504 = (x1503)+(x1389);
x1505 = (x1504)<(x1389);
x1506 = (x1504)+(x1451);
x1507 = (x1506)<(x1451);
x1508 = (x1505)+(x1507);
x1509 = (x1508)+(x1394);
x1510 = (x1509)<(x1394);
x1511 = (x1509)+(x1454);
x1512 = (x1511)<(x1454);
x1513 = (x1510)+(x1512);
x1514 = (x1513)+(x1396);
x1515 = (x29)*(x23);
x1516 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x23))>>32 : ((__uint128_t)(x29)*(x23))>>64;
x1517 = (x29)*(x22);
x1518 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x22))>>32 : ((__uint128_t)(x29)*(x22))>>64;
x1519 = (x29)*(x21);
x1520 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x21))>>32 : ((__uint128_t)(x29)*(x21))>>64;
x1521 = (x29)*(x20);
x1522 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x20))>>32 : ((__uint128_t)(x29)*(x20))>>64;
x1523 = (x29)*(x19);
x1524 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x19))>>32 : ((__uint128_t)(x29)*(x19))>>64;
x1525 = (x29)*(x18);
x1526 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x18))>>32 : ((__uint128_t)(x29)*(x18))>>64;
x1527 = (x29)*(x17);
x1528 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x17))>>32 : ((__uint128_t)(x29)*(x17))>>64;
x1529 = (x29)*(x16);
x1530 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x16))>>32 : ((__uint128_t)(x29)*(x16))>>64;
x1531 = (x29)*(x15);
x1532 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x15))>>32 : ((__uint128_t)(x29)*(x15))>>64;
x1533 = (x29)*(x14);
x1534 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x14))>>32 : ((__uint128_t)(x29)*(x14))>>64;
x1535 = (x29)*(x13);
x1536 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x13))>>32 : ((__uint128_t)(x29)*(x13))>>64;
x1537 = (x29)*(x12);
x1538 = sizeof(intptr_t) == 4 ? ((uint64_t)(x29)*(x12))>>32 : ((__uint128_t)(x29)*(x12))>>64;
x1539 = (x1538)+(x1535);
x1540 = (x1539)<(x1538);
x1541 = (x1540)+(x1536);
x1542 = (x1541)<(x1536);
x1543 = (x1541)+(x1533);
x1544 = (x1543)<(x1533);
x1545 = (x1542)+(x1544);
x1546 = (x1545)+(x1534);
x1547 = (x1546)<(x1534);
x1548 = (x1546)+(x1531);
x1549 = (x1548)<(x1531);
x1550 = (x1547)+(x1549);
x1551 = (x1550)+(x1532);
x1552 = (x1551)<(x1532);
x1553 = (x1551)+(x1529);
x1554 = (x1553)<(x1529);
x1555 = (x1552)+(x1554);
x1556 = (x1555)+(x1530);
x1557 = (x1556)<(x1530);
x1558 = (x1556)+(x1527);
x1559 = (x1558)<(x1527);
x1560 = (x1557)+(x1559);
x1561 = (x1560)+(x1528);
x1562 = (x1561)<(x1528);
x1563 = (x1561)+(x1525);
x1564 = (x1563)<(x1525);
x1565 = (x1562)+(x1564);
x1566 = (x1565)+(x1526);
x1567 = (x1566)<(x1526);
x1568 = (x1566)+(x1523);
x1569 = (x1568)<(x1523);
x1570 = (x1567)+(x1569);
x1571 = (x1570)+(x1524);
x1572 = (x1571)<(x1524);
x1573 = (x1571)+(x1521);
x1574 = (x1573)<(x1521);
x1575 = (x1572)+(x1574);
x1576 = (x1575)+(x1522);
x1577 = (x1576)<(x1522);
x1578 = (x1576)+(x1519);
x1579 = (x1578)<(x1519);
x1580 = (x1577)+(x1579);
x1581 = (x1580)+(x1520);
x1582 = (x1581)<(x1520);
x1583 = (x1581)+(x1517);
x1584 = (x1583)<(x1517);
x1585 = (x1582)+(x1584);
x1586 = (x1585)+(x1518);
x1587 = (x1586)<(x1518);
x1588 = (x1586)+(x1515);
x1589 = (x1588)<(x1515);
x1590 = (x1587)+(x1589);
x1591 = (x1590)+(x1516);
x1592 = (x1459)+(x1537);
x1593 = (x1592)<(x1459);
x1594 = (x1593)+(x1462);
x1595 = (x1594)<(x1462);
x1596 = (x1594)+(x1539);
x1597 = (x1596)<(x1539);
x1598 = (x1595)+(x1597);
x1599 = (x1598)+(x1466);
x1600 = (x1599)<(x1466);
x1601 = (x1599)+(x1543);
x1602 = (x1601)<(x1543);
x1603 = (x1600)+(x1602);
x1604 = (x1603)+(x1471);
x1605 = (x1604)<(x1471);
x1606 = (x1604)+(x1548);
x1607 = (x1606)<(x1548);
x1608 = (x1605)+(x1607);
x1609 = (x1608)+(x1476);
x1610 = (x1609)<(x1476);
x1611 = (x1609)+(x1553);
x1612 = (x1611)<(x1553);
x1613 = (x1610)+(x1612);
x1614 = (x1613)+(x1481);
x1615 = (x1614)<(x1481);
x1616 = (x1614)+(x1558);
x1617 = (x1616)<(x1558);
x1618 = (x1615)+(x1617);
x1619 = (x1618)+(x1486);
x1620 = (x1619)<(x1486);
x1621 = (x1619)+(x1563);
x1622 = (x1621)<(x1563);
x1623 = (x1620)+(x1622);
x1624 = (x1623)+(x1491);
x1625 = (x1624)<(x1491);
x1626 = (x1624)+(x1568);
x1627 = (x1626)<(x1568);
x1628 = (x1625)+(x1627);
x1629 = (x1628)+(x1496);
x1630 = (x1629)<(x1496);
x1631 = (x1629)+(x1573);
x1632 = (x1631)<(x1573);
x1633 = (x1630)+(x1632);
x1634 = (x1633)+(x1501);
x1635 = (x1634)<(x1501);
x1636 = (x1634)+(x1578);
x1637 = (x1636)<(x1578);
x1638 = (x1635)+(x1637);
x1639 = (x1638)+(x1506);
x1640 = (x1639)<(x1506);
x1641 = (x1639)+(x1583);
x1642 = (x1641)<(x1583);
x1643 = (x1640)+(x1642);
x1644 = (x1643)+(x1511);
x1645 = (x1644)<(x1511);
x1646 = (x1644)+(x1588);
x1647 = (x1646)<(x1588);
x1648 = (x1645)+(x1647);
x1649 = (x1648)+(x1514);
x1650 = (x1649)<(x1514);
x1651 = (x1649)+(x1591);
x1652 = (x1651)<(x1591);
x1653 = (x1650)+(x1652);
x1654 = (x1592)*((uintptr_t)4294967295ULL);
x1655 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1656 = (x1592)*((uintptr_t)4294967295ULL);
x1657 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1658 = (x1592)*((uintptr_t)4294967295ULL);
x1659 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1660 = (x1592)*((uintptr_t)4294967295ULL);
x1661 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1662 = (x1592)*((uintptr_t)4294967295ULL);
x1663 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1664 = (x1592)*((uintptr_t)4294967295ULL);
x1665 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1666 = (x1592)*((uintptr_t)4294967295ULL);
x1667 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1668 = (x1592)*((uintptr_t)4294967294ULL);
x1669 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967294ULL))>>64;
x1670 = (x1592)*((uintptr_t)4294967295ULL);
x1671 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1672 = (x1592)*((uintptr_t)4294967295ULL);
x1673 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1592)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1592)*((uintptr_t)4294967295ULL))>>64;
x1674 = (x1671)+(x1668);
x1675 = (x1674)<(x1671);
x1676 = (x1675)+(x1669);
x1677 = (x1676)<(x1669);
x1678 = (x1676)+(x1666);
x1679 = (x1678)<(x1666);
x1680 = (x1677)+(x1679);
x1681 = (x1680)+(x1667);
x1682 = (x1681)<(x1667);
x1683 = (x1681)+(x1664);
x1684 = (x1683)<(x1664);
x1685 = (x1682)+(x1684);
x1686 = (x1685)+(x1665);
x1687 = (x1686)<(x1665);
x1688 = (x1686)+(x1662);
x1689 = (x1688)<(x1662);
x1690 = (x1687)+(x1689);
x1691 = (x1690)+(x1663);
x1692 = (x1691)<(x1663);
x1693 = (x1691)+(x1660);
x1694 = (x1693)<(x1660);
x1695 = (x1692)+(x1694);
x1696 = (x1695)+(x1661);
x1697 = (x1696)<(x1661);
x1698 = (x1696)+(x1658);
x1699 = (x1698)<(x1658);
x1700 = (x1697)+(x1699);
x1701 = (x1700)+(x1659);
x1702 = (x1701)<(x1659);
x1703 = (x1701)+(x1656);
x1704 = (x1703)<(x1656);
x1705 = (x1702)+(x1704);
x1706 = (x1705)+(x1657);
x1707 = (x1706)<(x1657);
x1708 = (x1706)+(x1654);
x1709 = (x1708)<(x1654);
x1710 = (x1707)+(x1709);
x1711 = (x1710)+(x1655);
x1712 = (x1592)+(x1672);
x1713 = (x1712)<(x1592);
x1714 = (x1713)+(x1596);
x1715 = (x1714)<(x1596);
x1716 = (x1714)+(x1673);
x1717 = (x1716)<(x1673);
x1718 = (x1715)+(x1717);
x1719 = (x1718)+(x1601);
x1720 = (x1719)<(x1601);
x1721 = (x1720)+(x1606);
x1722 = (x1721)<(x1606);
x1723 = (x1721)+(x1670);
x1724 = (x1723)<(x1670);
x1725 = (x1722)+(x1724);
x1726 = (x1725)+(x1611);
x1727 = (x1726)<(x1611);
x1728 = (x1726)+(x1674);
x1729 = (x1728)<(x1674);
x1730 = (x1727)+(x1729);
x1731 = (x1730)+(x1616);
x1732 = (x1731)<(x1616);
x1733 = (x1731)+(x1678);
x1734 = (x1733)<(x1678);
x1735 = (x1732)+(x1734);
x1736 = (x1735)+(x1621);
x1737 = (x1736)<(x1621);
x1738 = (x1736)+(x1683);
x1739 = (x1738)<(x1683);
x1740 = (x1737)+(x1739);
x1741 = (x1740)+(x1626);
x1742 = (x1741)<(x1626);
x1743 = (x1741)+(x1688);
x1744 = (x1743)<(x1688);
x1745 = (x1742)+(x1744);
x1746 = (x1745)+(x1631);
x1747 = (x1746)<(x1631);
x1748 = (x1746)+(x1693);
x1749 = (x1748)<(x1693);
x1750 = (x1747)+(x1749);
x1751 = (x1750)+(x1636);
x1752 = (x1751)<(x1636);
x1753 = (x1751)+(x1698);
x1754 = (x1753)<(x1698);
x1755 = (x1752)+(x1754);
x1756 = (x1755)+(x1641);
x1757 = (x1756)<(x1641);
x1758 = (x1756)+(x1703);
x1759 = (x1758)<(x1703);
x1760 = (x1757)+(x1759);
x1761 = (x1760)+(x1646);
x1762 = (x1761)<(x1646);
x1763 = (x1761)+(x1708);
x1764 = (x1763)<(x1708);
x1765 = (x1762)+(x1764);
x1766 = (x1765)+(x1651);
x1767 = (x1766)<(x1651);
x1768 = (x1766)+(x1711);
x1769 = (x1768)<(x1711);
x1770 = (x1767)+(x1769);
x1771 = (x1770)+(x1653);
x1772 = (x30)*(x23);
x1773 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x23))>>32 : ((__uint128_t)(x30)*(x23))>>64;
x1774 = (x30)*(x22);
x1775 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x22))>>32 : ((__uint128_t)(x30)*(x22))>>64;
x1776 = (x30)*(x21);
x1777 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x21))>>32 : ((__uint128_t)(x30)*(x21))>>64;
x1778 = (x30)*(x20);
x1779 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x20))>>32 : ((__uint128_t)(x30)*(x20))>>64;
x1780 = (x30)*(x19);
x1781 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x19))>>32 : ((__uint128_t)(x30)*(x19))>>64;
x1782 = (x30)*(x18);
x1783 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x18))>>32 : ((__uint128_t)(x30)*(x18))>>64;
x1784 = (x30)*(x17);
x1785 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x17))>>32 : ((__uint128_t)(x30)*(x17))>>64;
x1786 = (x30)*(x16);
x1787 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x16))>>32 : ((__uint128_t)(x30)*(x16))>>64;
x1788 = (x30)*(x15);
x1789 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x15))>>32 : ((__uint128_t)(x30)*(x15))>>64;
x1790 = (x30)*(x14);
x1791 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x14))>>32 : ((__uint128_t)(x30)*(x14))>>64;
x1792 = (x30)*(x13);
x1793 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x13))>>32 : ((__uint128_t)(x30)*(x13))>>64;
x1794 = (x30)*(x12);
x1795 = sizeof(intptr_t) == 4 ? ((uint64_t)(x30)*(x12))>>32 : ((__uint128_t)(x30)*(x12))>>64;
x1796 = (x1795)+(x1792);
x1797 = (x1796)<(x1795);
x1798 = (x1797)+(x1793);
x1799 = (x1798)<(x1793);
x1800 = (x1798)+(x1790);
x1801 = (x1800)<(x1790);
x1802 = (x1799)+(x1801);
x1803 = (x1802)+(x1791);
x1804 = (x1803)<(x1791);
x1805 = (x1803)+(x1788);
x1806 = (x1805)<(x1788);
x1807 = (x1804)+(x1806);
x1808 = (x1807)+(x1789);
x1809 = (x1808)<(x1789);
x1810 = (x1808)+(x1786);
x1811 = (x1810)<(x1786);
x1812 = (x1809)+(x1811);
x1813 = (x1812)+(x1787);
x1814 = (x1813)<(x1787);
x1815 = (x1813)+(x1784);
x1816 = (x1815)<(x1784);
x1817 = (x1814)+(x1816);
x1818 = (x1817)+(x1785);
x1819 = (x1818)<(x1785);
x1820 = (x1818)+(x1782);
x1821 = (x1820)<(x1782);
x1822 = (x1819)+(x1821);
x1823 = (x1822)+(x1783);
x1824 = (x1823)<(x1783);
x1825 = (x1823)+(x1780);
x1826 = (x1825)<(x1780);
x1827 = (x1824)+(x1826);
x1828 = (x1827)+(x1781);
x1829 = (x1828)<(x1781);
x1830 = (x1828)+(x1778);
x1831 = (x1830)<(x1778);
x1832 = (x1829)+(x1831);
x1833 = (x1832)+(x1779);
x1834 = (x1833)<(x1779);
x1835 = (x1833)+(x1776);
x1836 = (x1835)<(x1776);
x1837 = (x1834)+(x1836);
x1838 = (x1837)+(x1777);
x1839 = (x1838)<(x1777);
x1840 = (x1838)+(x1774);
x1841 = (x1840)<(x1774);
x1842 = (x1839)+(x1841);
x1843 = (x1842)+(x1775);
x1844 = (x1843)<(x1775);
x1845 = (x1843)+(x1772);
x1846 = (x1845)<(x1772);
x1847 = (x1844)+(x1846);
x1848 = (x1847)+(x1773);
x1849 = (x1716)+(x1794);
x1850 = (x1849)<(x1716);
x1851 = (x1850)+(x1719);
x1852 = (x1851)<(x1719);
x1853 = (x1851)+(x1796);
x1854 = (x1853)<(x1796);
x1855 = (x1852)+(x1854);
x1856 = (x1855)+(x1723);
x1857 = (x1856)<(x1723);
x1858 = (x1856)+(x1800);
x1859 = (x1858)<(x1800);
x1860 = (x1857)+(x1859);
x1861 = (x1860)+(x1728);
x1862 = (x1861)<(x1728);
x1863 = (x1861)+(x1805);
x1864 = (x1863)<(x1805);
x1865 = (x1862)+(x1864);
x1866 = (x1865)+(x1733);
x1867 = (x1866)<(x1733);
x1868 = (x1866)+(x1810);
x1869 = (x1868)<(x1810);
x1870 = (x1867)+(x1869);
x1871 = (x1870)+(x1738);
x1872 = (x1871)<(x1738);
x1873 = (x1871)+(x1815);
x1874 = (x1873)<(x1815);
x1875 = (x1872)+(x1874);
x1876 = (x1875)+(x1743);
x1877 = (x1876)<(x1743);
x1878 = (x1876)+(x1820);
x1879 = (x1878)<(x1820);
x1880 = (x1877)+(x1879);
x1881 = (x1880)+(x1748);
x1882 = (x1881)<(x1748);
x1883 = (x1881)+(x1825);
x1884 = (x1883)<(x1825);
x1885 = (x1882)+(x1884);
x1886 = (x1885)+(x1753);
x1887 = (x1886)<(x1753);
x1888 = (x1886)+(x1830);
x1889 = (x1888)<(x1830);
x1890 = (x1887)+(x1889);
x1891 = (x1890)+(x1758);
x1892 = (x1891)<(x1758);
x1893 = (x1891)+(x1835);
x1894 = (x1893)<(x1835);
x1895 = (x1892)+(x1894);
x1896 = (x1895)+(x1763);
x1897 = (x1896)<(x1763);
x1898 = (x1896)+(x1840);
x1899 = (x1898)<(x1840);
x1900 = (x1897)+(x1899);
x1901 = (x1900)+(x1768);
x1902 = (x1901)<(x1768);
x1903 = (x1901)+(x1845);
x1904 = (x1903)<(x1845);
x1905 = (x1902)+(x1904);
x1906 = (x1905)+(x1771);
x1907 = (x1906)<(x1771);
x1908 = (x1906)+(x1848);
x1909 = (x1908)<(x1848);
x1910 = (x1907)+(x1909);
x1911 = (x1849)*((uintptr_t)4294967295ULL);
x1912 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1913 = (x1849)*((uintptr_t)4294967295ULL);
x1914 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1915 = (x1849)*((uintptr_t)4294967295ULL);
x1916 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1917 = (x1849)*((uintptr_t)4294967295ULL);
x1918 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1919 = (x1849)*((uintptr_t)4294967295ULL);
x1920 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1921 = (x1849)*((uintptr_t)4294967295ULL);
x1922 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1923 = (x1849)*((uintptr_t)4294967295ULL);
x1924 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1925 = (x1849)*((uintptr_t)4294967294ULL);
x1926 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967294ULL))>>64;
x1927 = (x1849)*((uintptr_t)4294967295ULL);
x1928 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1929 = (x1849)*((uintptr_t)4294967295ULL);
x1930 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1849)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1849)*((uintptr_t)4294967295ULL))>>64;
x1931 = (x1928)+(x1925);
x1932 = (x1931)<(x1928);
x1933 = (x1932)+(x1926);
x1934 = (x1933)<(x1926);
x1935 = (x1933)+(x1923);
x1936 = (x1935)<(x1923);
x1937 = (x1934)+(x1936);
x1938 = (x1937)+(x1924);
x1939 = (x1938)<(x1924);
x1940 = (x1938)+(x1921);
x1941 = (x1940)<(x1921);
x1942 = (x1939)+(x1941);
x1943 = (x1942)+(x1922);
x1944 = (x1943)<(x1922);
x1945 = (x1943)+(x1919);
x1946 = (x1945)<(x1919);
x1947 = (x1944)+(x1946);
x1948 = (x1947)+(x1920);
x1949 = (x1948)<(x1920);
x1950 = (x1948)+(x1917);
x1951 = (x1950)<(x1917);
x1952 = (x1949)+(x1951);
x1953 = (x1952)+(x1918);
x1954 = (x1953)<(x1918);
x1955 = (x1953)+(x1915);
x1956 = (x1955)<(x1915);
x1957 = (x1954)+(x1956);
x1958 = (x1957)+(x1916);
x1959 = (x1958)<(x1916);
x1960 = (x1958)+(x1913);
x1961 = (x1960)<(x1913);
x1962 = (x1959)+(x1961);
x1963 = (x1962)+(x1914);
x1964 = (x1963)<(x1914);
x1965 = (x1963)+(x1911);
x1966 = (x1965)<(x1911);
x1967 = (x1964)+(x1966);
x1968 = (x1967)+(x1912);
x1969 = (x1849)+(x1929);
x1970 = (x1969)<(x1849);
x1971 = (x1970)+(x1853);
x1972 = (x1971)<(x1853);
x1973 = (x1971)+(x1930);
x1974 = (x1973)<(x1930);
x1975 = (x1972)+(x1974);
x1976 = (x1975)+(x1858);
x1977 = (x1976)<(x1858);
x1978 = (x1977)+(x1863);
x1979 = (x1978)<(x1863);
x1980 = (x1978)+(x1927);
x1981 = (x1980)<(x1927);
x1982 = (x1979)+(x1981);
x1983 = (x1982)+(x1868);
x1984 = (x1983)<(x1868);
x1985 = (x1983)+(x1931);
x1986 = (x1985)<(x1931);
x1987 = (x1984)+(x1986);
x1988 = (x1987)+(x1873);
x1989 = (x1988)<(x1873);
x1990 = (x1988)+(x1935);
x1991 = (x1990)<(x1935);
x1992 = (x1989)+(x1991);
x1993 = (x1992)+(x1878);
x1994 = (x1993)<(x1878);
x1995 = (x1993)+(x1940);
x1996 = (x1995)<(x1940);
x1997 = (x1994)+(x1996);
x1998 = (x1997)+(x1883);
x1999 = (x1998)<(x1883);
x2000 = (x1998)+(x1945);
x2001 = (x2000)<(x1945);
x2002 = (x1999)+(x2001);
x2003 = (x2002)+(x1888);
x2004 = (x2003)<(x1888);
x2005 = (x2003)+(x1950);
x2006 = (x2005)<(x1950);
x2007 = (x2004)+(x2006);
x2008 = (x2007)+(x1893);
x2009 = (x2008)<(x1893);
x2010 = (x2008)+(x1955);
x2011 = (x2010)<(x1955);
x2012 = (x2009)+(x2011);
x2013 = (x2012)+(x1898);
x2014 = (x2013)<(x1898);
x2015 = (x2013)+(x1960);
x2016 = (x2015)<(x1960);
x2017 = (x2014)+(x2016);
x2018 = (x2017)+(x1903);
x2019 = (x2018)<(x1903);
x2020 = (x2018)+(x1965);
x2021 = (x2020)<(x1965);
x2022 = (x2019)+(x2021);
x2023 = (x2022)+(x1908);
x2024 = (x2023)<(x1908);
x2025 = (x2023)+(x1968);
x2026 = (x2025)<(x1968);
x2027 = (x2024)+(x2026);
x2028 = (x2027)+(x1910);
x2029 = (x31)*(x23);
x2030 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x23))>>32 : ((__uint128_t)(x31)*(x23))>>64;
x2031 = (x31)*(x22);
x2032 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x22))>>32 : ((__uint128_t)(x31)*(x22))>>64;
x2033 = (x31)*(x21);
x2034 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x21))>>32 : ((__uint128_t)(x31)*(x21))>>64;
x2035 = (x31)*(x20);
x2036 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x20))>>32 : ((__uint128_t)(x31)*(x20))>>64;
x2037 = (x31)*(x19);
x2038 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x19))>>32 : ((__uint128_t)(x31)*(x19))>>64;
x2039 = (x31)*(x18);
x2040 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x18))>>32 : ((__uint128_t)(x31)*(x18))>>64;
x2041 = (x31)*(x17);
x2042 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x17))>>32 : ((__uint128_t)(x31)*(x17))>>64;
x2043 = (x31)*(x16);
x2044 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x16))>>32 : ((__uint128_t)(x31)*(x16))>>64;
x2045 = (x31)*(x15);
x2046 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x15))>>32 : ((__uint128_t)(x31)*(x15))>>64;
x2047 = (x31)*(x14);
x2048 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x14))>>32 : ((__uint128_t)(x31)*(x14))>>64;
x2049 = (x31)*(x13);
x2050 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x13))>>32 : ((__uint128_t)(x31)*(x13))>>64;
x2051 = (x31)*(x12);
x2052 = sizeof(intptr_t) == 4 ? ((uint64_t)(x31)*(x12))>>32 : ((__uint128_t)(x31)*(x12))>>64;
x2053 = (x2052)+(x2049);
x2054 = (x2053)<(x2052);
x2055 = (x2054)+(x2050);
x2056 = (x2055)<(x2050);
x2057 = (x2055)+(x2047);
x2058 = (x2057)<(x2047);
x2059 = (x2056)+(x2058);
x2060 = (x2059)+(x2048);
x2061 = (x2060)<(x2048);
x2062 = (x2060)+(x2045);
x2063 = (x2062)<(x2045);
x2064 = (x2061)+(x2063);
x2065 = (x2064)+(x2046);
x2066 = (x2065)<(x2046);
x2067 = (x2065)+(x2043);
x2068 = (x2067)<(x2043);
x2069 = (x2066)+(x2068);
x2070 = (x2069)+(x2044);
x2071 = (x2070)<(x2044);
x2072 = (x2070)+(x2041);
x2073 = (x2072)<(x2041);
x2074 = (x2071)+(x2073);
x2075 = (x2074)+(x2042);
x2076 = (x2075)<(x2042);
x2077 = (x2075)+(x2039);
x2078 = (x2077)<(x2039);
x2079 = (x2076)+(x2078);
x2080 = (x2079)+(x2040);
x2081 = (x2080)<(x2040);
x2082 = (x2080)+(x2037);
x2083 = (x2082)<(x2037);
x2084 = (x2081)+(x2083);
x2085 = (x2084)+(x2038);
x2086 = (x2085)<(x2038);
x2087 = (x2085)+(x2035);
x2088 = (x2087)<(x2035);
x2089 = (x2086)+(x2088);
x2090 = (x2089)+(x2036);
x2091 = (x2090)<(x2036);
x2092 = (x2090)+(x2033);
x2093 = (x2092)<(x2033);
x2094 = (x2091)+(x2093);
x2095 = (x2094)+(x2034);
x2096 = (x2095)<(x2034);
x2097 = (x2095)+(x2031);
x2098 = (x2097)<(x2031);
x2099 = (x2096)+(x2098);
x2100 = (x2099)+(x2032);
x2101 = (x2100)<(x2032);
x2102 = (x2100)+(x2029);
x2103 = (x2102)<(x2029);
x2104 = (x2101)+(x2103);
x2105 = (x2104)+(x2030);
x2106 = (x1973)+(x2051);
x2107 = (x2106)<(x1973);
x2108 = (x2107)+(x1976);
x2109 = (x2108)<(x1976);
x2110 = (x2108)+(x2053);
x2111 = (x2110)<(x2053);
x2112 = (x2109)+(x2111);
x2113 = (x2112)+(x1980);
x2114 = (x2113)<(x1980);
x2115 = (x2113)+(x2057);
x2116 = (x2115)<(x2057);
x2117 = (x2114)+(x2116);
x2118 = (x2117)+(x1985);
x2119 = (x2118)<(x1985);
x2120 = (x2118)+(x2062);
x2121 = (x2120)<(x2062);
x2122 = (x2119)+(x2121);
x2123 = (x2122)+(x1990);
x2124 = (x2123)<(x1990);
x2125 = (x2123)+(x2067);
x2126 = (x2125)<(x2067);
x2127 = (x2124)+(x2126);
x2128 = (x2127)+(x1995);
x2129 = (x2128)<(x1995);
x2130 = (x2128)+(x2072);
x2131 = (x2130)<(x2072);
x2132 = (x2129)+(x2131);
x2133 = (x2132)+(x2000);
x2134 = (x2133)<(x2000);
x2135 = (x2133)+(x2077);
x2136 = (x2135)<(x2077);
x2137 = (x2134)+(x2136);
x2138 = (x2137)+(x2005);
x2139 = (x2138)<(x2005);
x2140 = (x2138)+(x2082);
x2141 = (x2140)<(x2082);
x2142 = (x2139)+(x2141);
x2143 = (x2142)+(x2010);
x2144 = (x2143)<(x2010);
x2145 = (x2143)+(x2087);
x2146 = (x2145)<(x2087);
x2147 = (x2144)+(x2146);
x2148 = (x2147)+(x2015);
x2149 = (x2148)<(x2015);
x2150 = (x2148)+(x2092);
x2151 = (x2150)<(x2092);
x2152 = (x2149)+(x2151);
x2153 = (x2152)+(x2020);
x2154 = (x2153)<(x2020);
x2155 = (x2153)+(x2097);
x2156 = (x2155)<(x2097);
x2157 = (x2154)+(x2156);
x2158 = (x2157)+(x2025);
x2159 = (x2158)<(x2025);
x2160 = (x2158)+(x2102);
x2161 = (x2160)<(x2102);
x2162 = (x2159)+(x2161);
x2163 = (x2162)+(x2028);
x2164 = (x2163)<(x2028);
x2165 = (x2163)+(x2105);
x2166 = (x2165)<(x2105);
x2167 = (x2164)+(x2166);
x2168 = (x2106)*((uintptr_t)4294967295ULL);
x2169 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2170 = (x2106)*((uintptr_t)4294967295ULL);
x2171 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2172 = (x2106)*((uintptr_t)4294967295ULL);
x2173 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2174 = (x2106)*((uintptr_t)4294967295ULL);
x2175 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2176 = (x2106)*((uintptr_t)4294967295ULL);
x2177 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2178 = (x2106)*((uintptr_t)4294967295ULL);
x2179 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2180 = (x2106)*((uintptr_t)4294967295ULL);
x2181 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2182 = (x2106)*((uintptr_t)4294967294ULL);
x2183 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967294ULL))>>64;
x2184 = (x2106)*((uintptr_t)4294967295ULL);
x2185 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2186 = (x2106)*((uintptr_t)4294967295ULL);
x2187 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2106)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2106)*((uintptr_t)4294967295ULL))>>64;
x2188 = (x2185)+(x2182);
x2189 = (x2188)<(x2185);
x2190 = (x2189)+(x2183);
x2191 = (x2190)<(x2183);
x2192 = (x2190)+(x2180);
x2193 = (x2192)<(x2180);
x2194 = (x2191)+(x2193);
x2195 = (x2194)+(x2181);
x2196 = (x2195)<(x2181);
x2197 = (x2195)+(x2178);
x2198 = (x2197)<(x2178);
x2199 = (x2196)+(x2198);
x2200 = (x2199)+(x2179);
x2201 = (x2200)<(x2179);
x2202 = (x2200)+(x2176);
x2203 = (x2202)<(x2176);
x2204 = (x2201)+(x2203);
x2205 = (x2204)+(x2177);
x2206 = (x2205)<(x2177);
x2207 = (x2205)+(x2174);
x2208 = (x2207)<(x2174);
x2209 = (x2206)+(x2208);
x2210 = (x2209)+(x2175);
x2211 = (x2210)<(x2175);
x2212 = (x2210)+(x2172);
x2213 = (x2212)<(x2172);
x2214 = (x2211)+(x2213);
x2215 = (x2214)+(x2173);
x2216 = (x2215)<(x2173);
x2217 = (x2215)+(x2170);
x2218 = (x2217)<(x2170);
x2219 = (x2216)+(x2218);
x2220 = (x2219)+(x2171);
x2221 = (x2220)<(x2171);
x2222 = (x2220)+(x2168);
x2223 = (x2222)<(x2168);
x2224 = (x2221)+(x2223);
x2225 = (x2224)+(x2169);
x2226 = (x2106)+(x2186);
x2227 = (x2226)<(x2106);
x2228 = (x2227)+(x2110);
x2229 = (x2228)<(x2110);
x2230 = (x2228)+(x2187);
x2231 = (x2230)<(x2187);
x2232 = (x2229)+(x2231);
x2233 = (x2232)+(x2115);
x2234 = (x2233)<(x2115);
x2235 = (x2234)+(x2120);
x2236 = (x2235)<(x2120);
x2237 = (x2235)+(x2184);
x2238 = (x2237)<(x2184);
x2239 = (x2236)+(x2238);
x2240 = (x2239)+(x2125);
x2241 = (x2240)<(x2125);
x2242 = (x2240)+(x2188);
x2243 = (x2242)<(x2188);
x2244 = (x2241)+(x2243);
x2245 = (x2244)+(x2130);
x2246 = (x2245)<(x2130);
x2247 = (x2245)+(x2192);
x2248 = (x2247)<(x2192);
x2249 = (x2246)+(x2248);
x2250 = (x2249)+(x2135);
x2251 = (x2250)<(x2135);
x2252 = (x2250)+(x2197);
x2253 = (x2252)<(x2197);
x2254 = (x2251)+(x2253);
x2255 = (x2254)+(x2140);
x2256 = (x2255)<(x2140);
x2257 = (x2255)+(x2202);
x2258 = (x2257)<(x2202);
x2259 = (x2256)+(x2258);
x2260 = (x2259)+(x2145);
x2261 = (x2260)<(x2145);
x2262 = (x2260)+(x2207);
x2263 = (x2262)<(x2207);
x2264 = (x2261)+(x2263);
x2265 = (x2264)+(x2150);
x2266 = (x2265)<(x2150);
x2267 = (x2265)+(x2212);
x2268 = (x2267)<(x2212);
x2269 = (x2266)+(x2268);
x2270 = (x2269)+(x2155);
x2271 = (x2270)<(x2155);
x2272 = (x2270)+(x2217);
x2273 = (x2272)<(x2217);
x2274 = (x2271)+(x2273);
x2275 = (x2274)+(x2160);
x2276 = (x2275)<(x2160);
x2277 = (x2275)+(x2222);
x2278 = (x2277)<(x2222);
x2279 = (x2276)+(x2278);
x2280 = (x2279)+(x2165);
x2281 = (x2280)<(x2165);
x2282 = (x2280)+(x2225);
x2283 = (x2282)<(x2225);
x2284 = (x2281)+(x2283);
x2285 = (x2284)+(x2167);
x2286 = (x32)*(x23);
x2287 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x23))>>32 : ((__uint128_t)(x32)*(x23))>>64;
x2288 = (x32)*(x22);
x2289 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x22))>>32 : ((__uint128_t)(x32)*(x22))>>64;
x2290 = (x32)*(x21);
x2291 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x21))>>32 : ((__uint128_t)(x32)*(x21))>>64;
x2292 = (x32)*(x20);
x2293 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x20))>>32 : ((__uint128_t)(x32)*(x20))>>64;
x2294 = (x32)*(x19);
x2295 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x19))>>32 : ((__uint128_t)(x32)*(x19))>>64;
x2296 = (x32)*(x18);
x2297 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x18))>>32 : ((__uint128_t)(x32)*(x18))>>64;
x2298 = (x32)*(x17);
x2299 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x17))>>32 : ((__uint128_t)(x32)*(x17))>>64;
x2300 = (x32)*(x16);
x2301 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x16))>>32 : ((__uint128_t)(x32)*(x16))>>64;
x2302 = (x32)*(x15);
x2303 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x15))>>32 : ((__uint128_t)(x32)*(x15))>>64;
x2304 = (x32)*(x14);
x2305 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x14))>>32 : ((__uint128_t)(x32)*(x14))>>64;
x2306 = (x32)*(x13);
x2307 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x13))>>32 : ((__uint128_t)(x32)*(x13))>>64;
x2308 = (x32)*(x12);
x2309 = sizeof(intptr_t) == 4 ? ((uint64_t)(x32)*(x12))>>32 : ((__uint128_t)(x32)*(x12))>>64;
x2310 = (x2309)+(x2306);
x2311 = (x2310)<(x2309);
x2312 = (x2311)+(x2307);
x2313 = (x2312)<(x2307);
x2314 = (x2312)+(x2304);
x2315 = (x2314)<(x2304);
x2316 = (x2313)+(x2315);
x2317 = (x2316)+(x2305);
x2318 = (x2317)<(x2305);
x2319 = (x2317)+(x2302);
x2320 = (x2319)<(x2302);
x2321 = (x2318)+(x2320);
x2322 = (x2321)+(x2303);
x2323 = (x2322)<(x2303);
x2324 = (x2322)+(x2300);
x2325 = (x2324)<(x2300);
x2326 = (x2323)+(x2325);
x2327 = (x2326)+(x2301);
x2328 = (x2327)<(x2301);
x2329 = (x2327)+(x2298);
x2330 = (x2329)<(x2298);
x2331 = (x2328)+(x2330);
x2332 = (x2331)+(x2299);
x2333 = (x2332)<(x2299);
x2334 = (x2332)+(x2296);
x2335 = (x2334)<(x2296);
x2336 = (x2333)+(x2335);
x2337 = (x2336)+(x2297);
x2338 = (x2337)<(x2297);
x2339 = (x2337)+(x2294);
x2340 = (x2339)<(x2294);
x2341 = (x2338)+(x2340);
x2342 = (x2341)+(x2295);
x2343 = (x2342)<(x2295);
x2344 = (x2342)+(x2292);
x2345 = (x2344)<(x2292);
x2346 = (x2343)+(x2345);
x2347 = (x2346)+(x2293);
x2348 = (x2347)<(x2293);
x2349 = (x2347)+(x2290);
x2350 = (x2349)<(x2290);
x2351 = (x2348)+(x2350);
x2352 = (x2351)+(x2291);
x2353 = (x2352)<(x2291);
x2354 = (x2352)+(x2288);
x2355 = (x2354)<(x2288);
x2356 = (x2353)+(x2355);
x2357 = (x2356)+(x2289);
x2358 = (x2357)<(x2289);
x2359 = (x2357)+(x2286);
x2360 = (x2359)<(x2286);
x2361 = (x2358)+(x2360);
x2362 = (x2361)+(x2287);
x2363 = (x2230)+(x2308);
x2364 = (x2363)<(x2230);
x2365 = (x2364)+(x2233);
x2366 = (x2365)<(x2233);
x2367 = (x2365)+(x2310);
x2368 = (x2367)<(x2310);
x2369 = (x2366)+(x2368);
x2370 = (x2369)+(x2237);
x2371 = (x2370)<(x2237);
x2372 = (x2370)+(x2314);
x2373 = (x2372)<(x2314);
x2374 = (x2371)+(x2373);
x2375 = (x2374)+(x2242);
x2376 = (x2375)<(x2242);
x2377 = (x2375)+(x2319);
x2378 = (x2377)<(x2319);
x2379 = (x2376)+(x2378);
x2380 = (x2379)+(x2247);
x2381 = (x2380)<(x2247);
x2382 = (x2380)+(x2324);
x2383 = (x2382)<(x2324);
x2384 = (x2381)+(x2383);
x2385 = (x2384)+(x2252);
x2386 = (x2385)<(x2252);
x2387 = (x2385)+(x2329);
x2388 = (x2387)<(x2329);
x2389 = (x2386)+(x2388);
x2390 = (x2389)+(x2257);
x2391 = (x2390)<(x2257);
x2392 = (x2390)+(x2334);
x2393 = (x2392)<(x2334);
x2394 = (x2391)+(x2393);
x2395 = (x2394)+(x2262);
x2396 = (x2395)<(x2262);
x2397 = (x2395)+(x2339);
x2398 = (x2397)<(x2339);
x2399 = (x2396)+(x2398);
x2400 = (x2399)+(x2267);
x2401 = (x2400)<(x2267);
x2402 = (x2400)+(x2344);
x2403 = (x2402)<(x2344);
x2404 = (x2401)+(x2403);
x2405 = (x2404)+(x2272);
x2406 = (x2405)<(x2272);
x2407 = (x2405)+(x2349);
x2408 = (x2407)<(x2349);
x2409 = (x2406)+(x2408);
x2410 = (x2409)+(x2277);
x2411 = (x2410)<(x2277);
x2412 = (x2410)+(x2354);
x2413 = (x2412)<(x2354);
x2414 = (x2411)+(x2413);
x2415 = (x2414)+(x2282);
x2416 = (x2415)<(x2282);
x2417 = (x2415)+(x2359);
x2418 = (x2417)<(x2359);
x2419 = (x2416)+(x2418);
x2420 = (x2419)+(x2285);
x2421 = (x2420)<(x2285);
x2422 = (x2420)+(x2362);
x2423 = (x2422)<(x2362);
x2424 = (x2421)+(x2423);
x2425 = (x2363)*((uintptr_t)4294967295ULL);
x2426 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2427 = (x2363)*((uintptr_t)4294967295ULL);
x2428 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2429 = (x2363)*((uintptr_t)4294967295ULL);
x2430 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2431 = (x2363)*((uintptr_t)4294967295ULL);
x2432 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2433 = (x2363)*((uintptr_t)4294967295ULL);
x2434 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2435 = (x2363)*((uintptr_t)4294967295ULL);
x2436 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2437 = (x2363)*((uintptr_t)4294967295ULL);
x2438 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2439 = (x2363)*((uintptr_t)4294967294ULL);
x2440 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967294ULL))>>64;
x2441 = (x2363)*((uintptr_t)4294967295ULL);
x2442 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2443 = (x2363)*((uintptr_t)4294967295ULL);
x2444 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2363)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2363)*((uintptr_t)4294967295ULL))>>64;
x2445 = (x2442)+(x2439);
x2446 = (x2445)<(x2442);
x2447 = (x2446)+(x2440);
x2448 = (x2447)<(x2440);
x2449 = (x2447)+(x2437);
x2450 = (x2449)<(x2437);
x2451 = (x2448)+(x2450);
x2452 = (x2451)+(x2438);
x2453 = (x2452)<(x2438);
x2454 = (x2452)+(x2435);
x2455 = (x2454)<(x2435);
x2456 = (x2453)+(x2455);
x2457 = (x2456)+(x2436);
x2458 = (x2457)<(x2436);
x2459 = (x2457)+(x2433);
x2460 = (x2459)<(x2433);
x2461 = (x2458)+(x2460);
x2462 = (x2461)+(x2434);
x2463 = (x2462)<(x2434);
x2464 = (x2462)+(x2431);
x2465 = (x2464)<(x2431);
x2466 = (x2463)+(x2465);
x2467 = (x2466)+(x2432);
x2468 = (x2467)<(x2432);
x2469 = (x2467)+(x2429);
x2470 = (x2469)<(x2429);
x2471 = (x2468)+(x2470);
x2472 = (x2471)+(x2430);
x2473 = (x2472)<(x2430);
x2474 = (x2472)+(x2427);
x2475 = (x2474)<(x2427);
x2476 = (x2473)+(x2475);
x2477 = (x2476)+(x2428);
x2478 = (x2477)<(x2428);
x2479 = (x2477)+(x2425);
x2480 = (x2479)<(x2425);
x2481 = (x2478)+(x2480);
x2482 = (x2481)+(x2426);
x2483 = (x2363)+(x2443);
x2484 = (x2483)<(x2363);
x2485 = (x2484)+(x2367);
x2486 = (x2485)<(x2367);
x2487 = (x2485)+(x2444);
x2488 = (x2487)<(x2444);
x2489 = (x2486)+(x2488);
x2490 = (x2489)+(x2372);
x2491 = (x2490)<(x2372);
x2492 = (x2491)+(x2377);
x2493 = (x2492)<(x2377);
x2494 = (x2492)+(x2441);
x2495 = (x2494)<(x2441);
x2496 = (x2493)+(x2495);
x2497 = (x2496)+(x2382);
x2498 = (x2497)<(x2382);
x2499 = (x2497)+(x2445);
x2500 = (x2499)<(x2445);
x2501 = (x2498)+(x2500);
x2502 = (x2501)+(x2387);
x2503 = (x2502)<(x2387);
x2504 = (x2502)+(x2449);
x2505 = (x2504)<(x2449);
x2506 = (x2503)+(x2505);
x2507 = (x2506)+(x2392);
x2508 = (x2507)<(x2392);
x2509 = (x2507)+(x2454);
x2510 = (x2509)<(x2454);
x2511 = (x2508)+(x2510);
x2512 = (x2511)+(x2397);
x2513 = (x2512)<(x2397);
x2514 = (x2512)+(x2459);
x2515 = (x2514)<(x2459);
x2516 = (x2513)+(x2515);
x2517 = (x2516)+(x2402);
x2518 = (x2517)<(x2402);
x2519 = (x2517)+(x2464);
x2520 = (x2519)<(x2464);
x2521 = (x2518)+(x2520);
x2522 = (x2521)+(x2407);
x2523 = (x2522)<(x2407);
x2524 = (x2522)+(x2469);
x2525 = (x2524)<(x2469);
x2526 = (x2523)+(x2525);
x2527 = (x2526)+(x2412);
x2528 = (x2527)<(x2412);
x2529 = (x2527)+(x2474);
x2530 = (x2529)<(x2474);
x2531 = (x2528)+(x2530);
x2532 = (x2531)+(x2417);
x2533 = (x2532)<(x2417);
x2534 = (x2532)+(x2479);
x2535 = (x2534)<(x2479);
x2536 = (x2533)+(x2535);
x2537 = (x2536)+(x2422);
x2538 = (x2537)<(x2422);
x2539 = (x2537)+(x2482);
x2540 = (x2539)<(x2482);
x2541 = (x2538)+(x2540);
x2542 = (x2541)+(x2424);
x2543 = (x33)*(x23);
x2544 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x23))>>32 : ((__uint128_t)(x33)*(x23))>>64;
x2545 = (x33)*(x22);
x2546 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x22))>>32 : ((__uint128_t)(x33)*(x22))>>64;
x2547 = (x33)*(x21);
x2548 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x21))>>32 : ((__uint128_t)(x33)*(x21))>>64;
x2549 = (x33)*(x20);
x2550 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x20))>>32 : ((__uint128_t)(x33)*(x20))>>64;
x2551 = (x33)*(x19);
x2552 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x19))>>32 : ((__uint128_t)(x33)*(x19))>>64;
x2553 = (x33)*(x18);
x2554 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x18))>>32 : ((__uint128_t)(x33)*(x18))>>64;
x2555 = (x33)*(x17);
x2556 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x17))>>32 : ((__uint128_t)(x33)*(x17))>>64;
x2557 = (x33)*(x16);
x2558 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x16))>>32 : ((__uint128_t)(x33)*(x16))>>64;
x2559 = (x33)*(x15);
x2560 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x15))>>32 : ((__uint128_t)(x33)*(x15))>>64;
x2561 = (x33)*(x14);
x2562 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x14))>>32 : ((__uint128_t)(x33)*(x14))>>64;
x2563 = (x33)*(x13);
x2564 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x13))>>32 : ((__uint128_t)(x33)*(x13))>>64;
x2565 = (x33)*(x12);
x2566 = sizeof(intptr_t) == 4 ? ((uint64_t)(x33)*(x12))>>32 : ((__uint128_t)(x33)*(x12))>>64;
x2567 = (x2566)+(x2563);
x2568 = (x2567)<(x2566);
x2569 = (x2568)+(x2564);
x2570 = (x2569)<(x2564);
x2571 = (x2569)+(x2561);
x2572 = (x2571)<(x2561);
x2573 = (x2570)+(x2572);
x2574 = (x2573)+(x2562);
x2575 = (x2574)<(x2562);
x2576 = (x2574)+(x2559);
x2577 = (x2576)<(x2559);
x2578 = (x2575)+(x2577);
x2579 = (x2578)+(x2560);
x2580 = (x2579)<(x2560);
x2581 = (x2579)+(x2557);
x2582 = (x2581)<(x2557);
x2583 = (x2580)+(x2582);
x2584 = (x2583)+(x2558);
x2585 = (x2584)<(x2558);
x2586 = (x2584)+(x2555);
x2587 = (x2586)<(x2555);
x2588 = (x2585)+(x2587);
x2589 = (x2588)+(x2556);
x2590 = (x2589)<(x2556);
x2591 = (x2589)+(x2553);
x2592 = (x2591)<(x2553);
x2593 = (x2590)+(x2592);
x2594 = (x2593)+(x2554);
x2595 = (x2594)<(x2554);
x2596 = (x2594)+(x2551);
x2597 = (x2596)<(x2551);
x2598 = (x2595)+(x2597);
x2599 = (x2598)+(x2552);
x2600 = (x2599)<(x2552);
x2601 = (x2599)+(x2549);
x2602 = (x2601)<(x2549);
x2603 = (x2600)+(x2602);
x2604 = (x2603)+(x2550);
x2605 = (x2604)<(x2550);
x2606 = (x2604)+(x2547);
x2607 = (x2606)<(x2547);
x2608 = (x2605)+(x2607);
x2609 = (x2608)+(x2548);
x2610 = (x2609)<(x2548);
x2611 = (x2609)+(x2545);
x2612 = (x2611)<(x2545);
x2613 = (x2610)+(x2612);
x2614 = (x2613)+(x2546);
x2615 = (x2614)<(x2546);
x2616 = (x2614)+(x2543);
x2617 = (x2616)<(x2543);
x2618 = (x2615)+(x2617);
x2619 = (x2618)+(x2544);
x2620 = (x2487)+(x2565);
x2621 = (x2620)<(x2487);
x2622 = (x2621)+(x2490);
x2623 = (x2622)<(x2490);
x2624 = (x2622)+(x2567);
x2625 = (x2624)<(x2567);
x2626 = (x2623)+(x2625);
x2627 = (x2626)+(x2494);
x2628 = (x2627)<(x2494);
x2629 = (x2627)+(x2571);
x2630 = (x2629)<(x2571);
x2631 = (x2628)+(x2630);
x2632 = (x2631)+(x2499);
x2633 = (x2632)<(x2499);
x2634 = (x2632)+(x2576);
x2635 = (x2634)<(x2576);
x2636 = (x2633)+(x2635);
x2637 = (x2636)+(x2504);
x2638 = (x2637)<(x2504);
x2639 = (x2637)+(x2581);
x2640 = (x2639)<(x2581);
x2641 = (x2638)+(x2640);
x2642 = (x2641)+(x2509);
x2643 = (x2642)<(x2509);
x2644 = (x2642)+(x2586);
x2645 = (x2644)<(x2586);
x2646 = (x2643)+(x2645);
x2647 = (x2646)+(x2514);
x2648 = (x2647)<(x2514);
x2649 = (x2647)+(x2591);
x2650 = (x2649)<(x2591);
x2651 = (x2648)+(x2650);
x2652 = (x2651)+(x2519);
x2653 = (x2652)<(x2519);
x2654 = (x2652)+(x2596);
x2655 = (x2654)<(x2596);
x2656 = (x2653)+(x2655);
x2657 = (x2656)+(x2524);
x2658 = (x2657)<(x2524);
x2659 = (x2657)+(x2601);
x2660 = (x2659)<(x2601);
x2661 = (x2658)+(x2660);
x2662 = (x2661)+(x2529);
x2663 = (x2662)<(x2529);
x2664 = (x2662)+(x2606);
x2665 = (x2664)<(x2606);
x2666 = (x2663)+(x2665);
x2667 = (x2666)+(x2534);
x2668 = (x2667)<(x2534);
x2669 = (x2667)+(x2611);
x2670 = (x2669)<(x2611);
x2671 = (x2668)+(x2670);
x2672 = (x2671)+(x2539);
x2673 = (x2672)<(x2539);
x2674 = (x2672)+(x2616);
x2675 = (x2674)<(x2616);
x2676 = (x2673)+(x2675);
x2677 = (x2676)+(x2542);
x2678 = (x2677)<(x2542);
x2679 = (x2677)+(x2619);
x2680 = (x2679)<(x2619);
x2681 = (x2678)+(x2680);
x2682 = (x2620)*((uintptr_t)4294967295ULL);
x2683 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2684 = (x2620)*((uintptr_t)4294967295ULL);
x2685 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2686 = (x2620)*((uintptr_t)4294967295ULL);
x2687 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2688 = (x2620)*((uintptr_t)4294967295ULL);
x2689 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2690 = (x2620)*((uintptr_t)4294967295ULL);
x2691 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2692 = (x2620)*((uintptr_t)4294967295ULL);
x2693 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2694 = (x2620)*((uintptr_t)4294967295ULL);
x2695 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2696 = (x2620)*((uintptr_t)4294967294ULL);
x2697 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967294ULL))>>64;
x2698 = (x2620)*((uintptr_t)4294967295ULL);
x2699 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2700 = (x2620)*((uintptr_t)4294967295ULL);
x2701 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2620)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2620)*((uintptr_t)4294967295ULL))>>64;
x2702 = (x2699)+(x2696);
x2703 = (x2702)<(x2699);
x2704 = (x2703)+(x2697);
x2705 = (x2704)<(x2697);
x2706 = (x2704)+(x2694);
x2707 = (x2706)<(x2694);
x2708 = (x2705)+(x2707);
x2709 = (x2708)+(x2695);
x2710 = (x2709)<(x2695);
x2711 = (x2709)+(x2692);
x2712 = (x2711)<(x2692);
x2713 = (x2710)+(x2712);
x2714 = (x2713)+(x2693);
x2715 = (x2714)<(x2693);
x2716 = (x2714)+(x2690);
x2717 = (x2716)<(x2690);
x2718 = (x2715)+(x2717);
x2719 = (x2718)+(x2691);
x2720 = (x2719)<(x2691);
x2721 = (x2719)+(x2688);
x2722 = (x2721)<(x2688);
x2723 = (x2720)+(x2722);
x2724 = (x2723)+(x2689);
x2725 = (x2724)<(x2689);
x2726 = (x2724)+(x2686);
x2727 = (x2726)<(x2686);
x2728 = (x2725)+(x2727);
x2729 = (x2728)+(x2687);
x2730 = (x2729)<(x2687);
x2731 = (x2729)+(x2684);
x2732 = (x2731)<(x2684);
x2733 = (x2730)+(x2732);
x2734 = (x2733)+(x2685);
x2735 = (x2734)<(x2685);
x2736 = (x2734)+(x2682);
x2737 = (x2736)<(x2682);
x2738 = (x2735)+(x2737);
x2739 = (x2738)+(x2683);
x2740 = (x2620)+(x2700);
x2741 = (x2740)<(x2620);
x2742 = (x2741)+(x2624);
x2743 = (x2742)<(x2624);
x2744 = (x2742)+(x2701);
x2745 = (x2744)<(x2701);
x2746 = (x2743)+(x2745);
x2747 = (x2746)+(x2629);
x2748 = (x2747)<(x2629);
x2749 = (x2748)+(x2634);
x2750 = (x2749)<(x2634);
x2751 = (x2749)+(x2698);
x2752 = (x2751)<(x2698);
x2753 = (x2750)+(x2752);
x2754 = (x2753)+(x2639);
x2755 = (x2754)<(x2639);
x2756 = (x2754)+(x2702);
x2757 = (x2756)<(x2702);
x2758 = (x2755)+(x2757);
x2759 = (x2758)+(x2644);
x2760 = (x2759)<(x2644);
x2761 = (x2759)+(x2706);
x2762 = (x2761)<(x2706);
x2763 = (x2760)+(x2762);
x2764 = (x2763)+(x2649);
x2765 = (x2764)<(x2649);
x2766 = (x2764)+(x2711);
x2767 = (x2766)<(x2711);
x2768 = (x2765)+(x2767);
x2769 = (x2768)+(x2654);
x2770 = (x2769)<(x2654);
x2771 = (x2769)+(x2716);
x2772 = (x2771)<(x2716);
x2773 = (x2770)+(x2772);
x2774 = (x2773)+(x2659);
x2775 = (x2774)<(x2659);
x2776 = (x2774)+(x2721);
x2777 = (x2776)<(x2721);
x2778 = (x2775)+(x2777);
x2779 = (x2778)+(x2664);
x2780 = (x2779)<(x2664);
x2781 = (x2779)+(x2726);
x2782 = (x2781)<(x2726);
x2783 = (x2780)+(x2782);
x2784 = (x2783)+(x2669);
x2785 = (x2784)<(x2669);
x2786 = (x2784)+(x2731);
x2787 = (x2786)<(x2731);
x2788 = (x2785)+(x2787);
x2789 = (x2788)+(x2674);
x2790 = (x2789)<(x2674);
x2791 = (x2789)+(x2736);
x2792 = (x2791)<(x2736);
x2793 = (x2790)+(x2792);
x2794 = (x2793)+(x2679);
x2795 = (x2794)<(x2679);
x2796 = (x2794)+(x2739);
x2797 = (x2796)<(x2739);
x2798 = (x2795)+(x2797);
x2799 = (x2798)+(x2681);
x2800 = (x34)*(x23);
x2801 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x23))>>32 : ((__uint128_t)(x34)*(x23))>>64;
x2802 = (x34)*(x22);
x2803 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x22))>>32 : ((__uint128_t)(x34)*(x22))>>64;
x2804 = (x34)*(x21);
x2805 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x21))>>32 : ((__uint128_t)(x34)*(x21))>>64;
x2806 = (x34)*(x20);
x2807 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x20))>>32 : ((__uint128_t)(x34)*(x20))>>64;
x2808 = (x34)*(x19);
x2809 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x19))>>32 : ((__uint128_t)(x34)*(x19))>>64;
x2810 = (x34)*(x18);
x2811 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x18))>>32 : ((__uint128_t)(x34)*(x18))>>64;
x2812 = (x34)*(x17);
x2813 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x17))>>32 : ((__uint128_t)(x34)*(x17))>>64;
x2814 = (x34)*(x16);
x2815 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x16))>>32 : ((__uint128_t)(x34)*(x16))>>64;
x2816 = (x34)*(x15);
x2817 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x15))>>32 : ((__uint128_t)(x34)*(x15))>>64;
x2818 = (x34)*(x14);
x2819 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x14))>>32 : ((__uint128_t)(x34)*(x14))>>64;
x2820 = (x34)*(x13);
x2821 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x13))>>32 : ((__uint128_t)(x34)*(x13))>>64;
x2822 = (x34)*(x12);
x2823 = sizeof(intptr_t) == 4 ? ((uint64_t)(x34)*(x12))>>32 : ((__uint128_t)(x34)*(x12))>>64;
x2824 = (x2823)+(x2820);
x2825 = (x2824)<(x2823);
x2826 = (x2825)+(x2821);
x2827 = (x2826)<(x2821);
x2828 = (x2826)+(x2818);
x2829 = (x2828)<(x2818);
x2830 = (x2827)+(x2829);
x2831 = (x2830)+(x2819);
x2832 = (x2831)<(x2819);
x2833 = (x2831)+(x2816);
x2834 = (x2833)<(x2816);
x2835 = (x2832)+(x2834);
x2836 = (x2835)+(x2817);
x2837 = (x2836)<(x2817);
x2838 = (x2836)+(x2814);
x2839 = (x2838)<(x2814);
x2840 = (x2837)+(x2839);
x2841 = (x2840)+(x2815);
x2842 = (x2841)<(x2815);
x2843 = (x2841)+(x2812);
x2844 = (x2843)<(x2812);
x2845 = (x2842)+(x2844);
x2846 = (x2845)+(x2813);
x2847 = (x2846)<(x2813);
x2848 = (x2846)+(x2810);
x2849 = (x2848)<(x2810);
x2850 = (x2847)+(x2849);
x2851 = (x2850)+(x2811);
x2852 = (x2851)<(x2811);
x2853 = (x2851)+(x2808);
x2854 = (x2853)<(x2808);
x2855 = (x2852)+(x2854);
x2856 = (x2855)+(x2809);
x2857 = (x2856)<(x2809);
x2858 = (x2856)+(x2806);
x2859 = (x2858)<(x2806);
x2860 = (x2857)+(x2859);
x2861 = (x2860)+(x2807);
x2862 = (x2861)<(x2807);
x2863 = (x2861)+(x2804);
x2864 = (x2863)<(x2804);
x2865 = (x2862)+(x2864);
x2866 = (x2865)+(x2805);
x2867 = (x2866)<(x2805);
x2868 = (x2866)+(x2802);
x2869 = (x2868)<(x2802);
x2870 = (x2867)+(x2869);
x2871 = (x2870)+(x2803);
x2872 = (x2871)<(x2803);
x2873 = (x2871)+(x2800);
x2874 = (x2873)<(x2800);
x2875 = (x2872)+(x2874);
x2876 = (x2875)+(x2801);
x2877 = (x2744)+(x2822);
x2878 = (x2877)<(x2744);
x2879 = (x2878)+(x2747);
x2880 = (x2879)<(x2747);
x2881 = (x2879)+(x2824);
x2882 = (x2881)<(x2824);
x2883 = (x2880)+(x2882);
x2884 = (x2883)+(x2751);
x2885 = (x2884)<(x2751);
x2886 = (x2884)+(x2828);
x2887 = (x2886)<(x2828);
x2888 = (x2885)+(x2887);
x2889 = (x2888)+(x2756);
x2890 = (x2889)<(x2756);
x2891 = (x2889)+(x2833);
x2892 = (x2891)<(x2833);
x2893 = (x2890)+(x2892);
x2894 = (x2893)+(x2761);
x2895 = (x2894)<(x2761);
x2896 = (x2894)+(x2838);
x2897 = (x2896)<(x2838);
x2898 = (x2895)+(x2897);
x2899 = (x2898)+(x2766);
x2900 = (x2899)<(x2766);
x2901 = (x2899)+(x2843);
x2902 = (x2901)<(x2843);
x2903 = (x2900)+(x2902);
x2904 = (x2903)+(x2771);
x2905 = (x2904)<(x2771);
x2906 = (x2904)+(x2848);
x2907 = (x2906)<(x2848);
x2908 = (x2905)+(x2907);
x2909 = (x2908)+(x2776);
x2910 = (x2909)<(x2776);
x2911 = (x2909)+(x2853);
x2912 = (x2911)<(x2853);
x2913 = (x2910)+(x2912);
x2914 = (x2913)+(x2781);
x2915 = (x2914)<(x2781);
x2916 = (x2914)+(x2858);
x2917 = (x2916)<(x2858);
x2918 = (x2915)+(x2917);
x2919 = (x2918)+(x2786);
x2920 = (x2919)<(x2786);
x2921 = (x2919)+(x2863);
x2922 = (x2921)<(x2863);
x2923 = (x2920)+(x2922);
x2924 = (x2923)+(x2791);
x2925 = (x2924)<(x2791);
x2926 = (x2924)+(x2868);
x2927 = (x2926)<(x2868);
x2928 = (x2925)+(x2927);
x2929 = (x2928)+(x2796);
x2930 = (x2929)<(x2796);
x2931 = (x2929)+(x2873);
x2932 = (x2931)<(x2873);
x2933 = (x2930)+(x2932);
x2934 = (x2933)+(x2799);
x2935 = (x2934)<(x2799);
x2936 = (x2934)+(x2876);
x2937 = (x2936)<(x2876);
x2938 = (x2935)+(x2937);
x2939 = (x2877)*((uintptr_t)4294967295ULL);
x2940 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2941 = (x2877)*((uintptr_t)4294967295ULL);
x2942 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2943 = (x2877)*((uintptr_t)4294967295ULL);
x2944 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2945 = (x2877)*((uintptr_t)4294967295ULL);
x2946 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2947 = (x2877)*((uintptr_t)4294967295ULL);
x2948 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2949 = (x2877)*((uintptr_t)4294967295ULL);
x2950 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2951 = (x2877)*((uintptr_t)4294967295ULL);
x2952 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2953 = (x2877)*((uintptr_t)4294967294ULL);
x2954 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967294ULL))>>64;
x2955 = (x2877)*((uintptr_t)4294967295ULL);
x2956 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2957 = (x2877)*((uintptr_t)4294967295ULL);
x2958 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2877)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2877)*((uintptr_t)4294967295ULL))>>64;
x2959 = (x2956)+(x2953);
x2960 = (x2959)<(x2956);
x2961 = (x2960)+(x2954);
x2962 = (x2961)<(x2954);
x2963 = (x2961)+(x2951);
x2964 = (x2963)<(x2951);
x2965 = (x2962)+(x2964);
x2966 = (x2965)+(x2952);
x2967 = (x2966)<(x2952);
x2968 = (x2966)+(x2949);
x2969 = (x2968)<(x2949);
x2970 = (x2967)+(x2969);
x2971 = (x2970)+(x2950);
x2972 = (x2971)<(x2950);
x2973 = (x2971)+(x2947);
x2974 = (x2973)<(x2947);
x2975 = (x2972)+(x2974);
x2976 = (x2975)+(x2948);
x2977 = (x2976)<(x2948);
x2978 = (x2976)+(x2945);
x2979 = (x2978)<(x2945);
x2980 = (x2977)+(x2979);
x2981 = (x2980)+(x2946);
x2982 = (x2981)<(x2946);
x2983 = (x2981)+(x2943);
x2984 = (x2983)<(x2943);
x2985 = (x2982)+(x2984);
x2986 = (x2985)+(x2944);
x2987 = (x2986)<(x2944);
x2988 = (x2986)+(x2941);
x2989 = (x2988)<(x2941);
x2990 = (x2987)+(x2989);
x2991 = (x2990)+(x2942);
x2992 = (x2991)<(x2942);
x2993 = (x2991)+(x2939);
x2994 = (x2993)<(x2939);
x2995 = (x2992)+(x2994);
x2996 = (x2995)+(x2940);
x2997 = (x2877)+(x2957);
x2998 = (x2997)<(x2877);
x2999 = (x2998)+(x2881);
x3000 = (x2999)<(x2881);
x3001 = (x2999)+(x2958);
x3002 = (x3001)<(x2958);
x3003 = (x3000)+(x3002);
x3004 = (x3003)+(x2886);
x3005 = (x3004)<(x2886);
x3006 = (x3005)+(x2891);
x3007 = (x3006)<(x2891);
x3008 = (x3006)+(x2955);
x3009 = (x3008)<(x2955);
x3010 = (x3007)+(x3009);
x3011 = (x3010)+(x2896);
x3012 = (x3011)<(x2896);
x3013 = (x3011)+(x2959);
x3014 = (x3013)<(x2959);
x3015 = (x3012)+(x3014);
x3016 = (x3015)+(x2901);
x3017 = (x3016)<(x2901);
x3018 = (x3016)+(x2963);
x3019 = (x3018)<(x2963);
x3020 = (x3017)+(x3019);
x3021 = (x3020)+(x2906);
x3022 = (x3021)<(x2906);
x3023 = (x3021)+(x2968);
x3024 = (x3023)<(x2968);
x3025 = (x3022)+(x3024);
x3026 = (x3025)+(x2911);
x3027 = (x3026)<(x2911);
x3028 = (x3026)+(x2973);
x3029 = (x3028)<(x2973);
x3030 = (x3027)+(x3029);
x3031 = (x3030)+(x2916);
x3032 = (x3031)<(x2916);
x3033 = (x3031)+(x2978);
x3034 = (x3033)<(x2978);
x3035 = (x3032)+(x3034);
x3036 = (x3035)+(x2921);
x3037 = (x3036)<(x2921);
x3038 = (x3036)+(x2983);
x3039 = (x3038)<(x2983);
x3040 = (x3037)+(x3039);
x3041 = (x3040)+(x2926);
x3042 = (x3041)<(x2926);
x3043 = (x3041)+(x2988);
x3044 = (x3043)<(x2988);
x3045 = (x3042)+(x3044);
x3046 = (x3045)+(x2931);
x3047 = (x3046)<(x2931);
x3048 = (x3046)+(x2993);
x3049 = (x3048)<(x2993);
x3050 = (x3047)+(x3049);
x3051 = (x3050)+(x2936);
x3052 = (x3051)<(x2936);
x3053 = (x3051)+(x2996);
x3054 = (x3053)<(x2996);
x3055 = (x3052)+(x3054);
x3056 = (x3055)+(x2938);
x3057 = (x3001)-((uintptr_t)4294967295ULL);
x3058 = (x3001)<(x3057);
x3059 = (x3057)<(x3057);
x3060 = (x3058)+(x3059);
x3061 = (x3004)<(x3004);
x3062 = (x3004)-(x3060);
x3063 = (x3004)<(x3062);
x3064 = (x3061)+(x3063);
x3065 = (x3008)<(x3008);
x3066 = (x3008)-(x3064);
x3067 = (x3008)<(x3066);
x3068 = (x3065)+(x3067);
x3069 = (x3013)-((uintptr_t)4294967295ULL);
x3070 = (x3013)<(x3069);
x3071 = (x3069)-(x3068);
x3072 = (x3069)<(x3071);
x3073 = (x3070)+(x3072);
x3074 = (x3018)-((uintptr_t)4294967294ULL);
x3075 = (x3018)<(x3074);
x3076 = (x3074)-(x3073);
x3077 = (x3074)<(x3076);
x3078 = (x3075)+(x3077);
x3079 = (x3023)-((uintptr_t)4294967295ULL);
x3080 = (x3023)<(x3079);
x3081 = (x3079)-(x3078);
x3082 = (x3079)<(x3081);
x3083 = (x3080)+(x3082);
x3084 = (x3028)-((uintptr_t)4294967295ULL);
x3085 = (x3028)<(x3084);
x3086 = (x3084)-(x3083);
x3087 = (x3084)<(x3086);
x3088 = (x3085)+(x3087);
x3089 = (x3033)-((uintptr_t)4294967295ULL);
x3090 = (x3033)<(x3089);
x3091 = (x3089)-(x3088);
x3092 = (x3089)<(x3091);
x3093 = (x3090)+(x3092);
x3094 = (x3038)-((uintptr_t)4294967295ULL);
x3095 = (x3038)<(x3094);
x3096 = (x3094)-(x3093);
x3097 = (x3094)<(x3096);
x3098 = (x3095)+(x3097);
x3099 = (x3043)-((uintptr_t)4294967295ULL);
x3100 = (x3043)<(x3099);
x3101 = (x3099)-(x3098);
x3102 = (x3099)<(x3101);
x3103 = (x3100)+(x3102);
x3104 = (x3048)-((uintptr_t)4294967295ULL);
x3105 = (x3048)<(x3104);
x3106 = (x3104)-(x3103);
x3107 = (x3104)<(x3106);
x3108 = (x3105)+(x3107);
x3109 = (x3053)-((uintptr_t)4294967295ULL);
x3110 = (x3053)<(x3109);
x3111 = (x3109)-(x3108);
x3112 = (x3109)<(x3111);
x3113 = (x3110)+(x3112);
x3114 = (x3056)<(x3056);
x3115 = (x3056)-(x3113);
x3116 = (x3056)<(x3115);
x3117 = (x3114)+(x3116);
x3118 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3119 = (x3118)^((uintptr_t)4294967295ULL);
x3120 = ((x3001)&(x3118))|((x3057)&(x3119));
x3121 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3122 = (x3121)^((uintptr_t)4294967295ULL);
x3123 = ((x3004)&(x3121))|((x3062)&(x3122));
x3124 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3125 = (x3124)^((uintptr_t)4294967295ULL);
x3126 = ((x3008)&(x3124))|((x3066)&(x3125));
x3127 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3128 = (x3127)^((uintptr_t)4294967295ULL);
x3129 = ((x3013)&(x3127))|((x3071)&(x3128));
x3130 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3131 = (x3130)^((uintptr_t)4294967295ULL);
x3132 = ((x3018)&(x3130))|((x3076)&(x3131));
x3133 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3134 = (x3133)^((uintptr_t)4294967295ULL);
x3135 = ((x3023)&(x3133))|((x3081)&(x3134));
x3136 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3137 = (x3136)^((uintptr_t)4294967295ULL);
x3138 = ((x3028)&(x3136))|((x3086)&(x3137));
x3139 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3140 = (x3139)^((uintptr_t)4294967295ULL);
x3141 = ((x3033)&(x3139))|((x3091)&(x3140));
x3142 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3143 = (x3142)^((uintptr_t)4294967295ULL);
x3144 = ((x3038)&(x3142))|((x3096)&(x3143));
x3145 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3146 = (x3145)^((uintptr_t)4294967295ULL);
x3147 = ((x3043)&(x3145))|((x3101)&(x3146));
x3148 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3149 = (x3148)^((uintptr_t)4294967295ULL);
x3150 = ((x3048)&(x3148))|((x3106)&(x3149));
x3151 = ((uintptr_t)-1ULL)+((x3117)==((uintptr_t)0ULL));
x3152 = (x3151)^((uintptr_t)4294967295ULL);
x3153 = ((x3053)&(x3151))|((x3111)&(x3152));
x3154 = x3120;
x3155 = x3123;
x3156 = x3126;
x3157 = x3129;
x3158 = x3132;
x3159 = x3135;
x3160 = x3138;
x3161 = x3141;
x3162 = x3144;
x3163 = x3147;
x3164 = x3150;
x3165 = x3153;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x3154;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x3155;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x3156;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x3157;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x3158;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x3159;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x3160;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x3161;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x3162;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x3163;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x3164;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x3165;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_square(uintptr_t in0, uintptr_t out0) {
uintptr_t x23, x44, x47, x49, x45, x50, x42, x51, x53, x54, x43, x55, x40, x56, x58, x59, x41, x60, x38, x61, x63, x64, x39, x65, x36, x66, x68, x69, x37, x70, x34, x71, x73, x74, x35, x75, x32, x76, x78, x79, x33, x80, x30, x81, x83, x84, x31, x85, x28, x86, x88, x89, x29, x90, x26, x91, x93, x94, x27, x95, x24, x96, x98, x99, x25, x115, x118, x122, x116, x123, x113, x124, x126, x127, x114, x128, x111, x129, x131, x132, x112, x133, x109, x134, x136, x137, x110, x138, x107, x139, x141, x142, x108, x143, x105, x144, x146, x147, x106, x148, x103, x149, x151, x152, x104, x153, x101, x154, x156, x157, x102, x119, x159, x46, x160, x48, x161, x120, x162, x164, x165, x52, x167, x57, x168, x117, x169, x171, x172, x62, x173, x121, x174, x176, x177, x67, x178, x125, x179, x181, x182, x72, x183, x130, x184, x186, x187, x77, x188, x135, x189, x191, x192, x82, x193, x140, x194, x196, x197, x87, x198, x145, x199, x201, x202, x92, x203, x150, x204, x206, x207, x97, x208, x155, x209, x211, x212, x100, x213, x158, x214, x216, x12, x238, x241, x243, x239, x244, x236, x245, x247, x248, x237, x249, x234, x250, x252, x253, x235, x254, x232, x255, x257, x258, x233, x259, x230, x260, x262, x263, x231, x264, x228, x265, x267, x268, x229, x269, x226, x270, x272, x273, x227, x274, x224, x275, x277, x278, x225, x279, x222, x280, x282, x283, x223, x284, x220, x285, x287, x288, x221, x289, x218, x290, x292, x293, x219, x240, x163, x296, x166, x297, x242, x298, x300, x301, x170, x302, x246, x303, x305, x306, x175, x307, x251, x308, x310, x311, x180, x312, x256, x313, x315, x316, x185, x317, x261, x318, x320, x321, x190, x322, x266, x323, x325, x326, x195, x327, x271, x328, x330, x331, x200, x332, x276, x333, x335, x336, x205, x337, x281, x338, x340, x341, x210, x342, x286, x343, x345, x346, x215, x347, x291, x348, x350, x351, x217, x352, x294, x353, x355, x371, x374, x378, x372, x379, x369, x380, x382, x383, x370, x384, x367, x385, x387, x388, x368, x389, x365, x390, x392, x393, x366, x394, x363, x395, x397, x398, x364, x399, x361, x400, x402, x403, x362, x404, x359, x405, x407, x408, x360, x409, x357, x410, x412, x413, x358, x375, x415, x295, x416, x299, x417, x376, x418, x420, x421, x304, x423, x309, x424, x373, x425, x427, x428, x314, x429, x377, x430, x432, x433, x319, x434, x381, x435, x437, x438, x324, x439, x386, x440, x442, x443, x329, x444, x391, x445, x447, x448, x334, x449, x396, x450, x452, x453, x339, x454, x401, x455, x457, x458, x344, x459, x406, x460, x462, x463, x349, x464, x411, x465, x467, x468, x354, x469, x414, x470, x472, x473, x356, x13, x495, x498, x500, x496, x501, x493, x502, x504, x505, x494, x506, x491, x507, x509, x510, x492, x511, x489, x512, x514, x515, x490, x516, x487, x517, x519, x520, x488, x521, x485, x522, x524, x525, x486, x526, x483, x527, x529, x530, x484, x531, x481, x532, x534, x535, x482, x536, x479, x537, x539, x540, x480, x541, x477, x542, x544, x545, x478, x546, x475, x547, x549, x550, x476, x497, x419, x553, x422, x554, x499, x555, x557, x558, x426, x559, x503, x560, x562, x563, x431, x564, x508, x565, x567, x568, x436, x569, x513, x570, x572, x573, x441, x574, x518, x575, x577, x578, x446, x579, x523, x580, x582, x583, x451, x584, x528, x585, x587, x588, x456, x589, x533, x590, x592, x593, x461, x594, x538, x595, x597, x598, x466, x599, x543, x600, x602, x603, x471, x604, x548, x605, x607, x608, x474, x609, x551, x610, x612, x628, x631, x635, x629, x636, x626, x637, x639, x640, x627, x641, x624, x642, x644, x645, x625, x646, x622, x647, x649, x650, x623, x651, x620, x652, x654, x655, x621, x656, x618, x657, x659, x660, x619, x661, x616, x662, x664, x665, x617, x666, x614, x667, x669, x670, x615, x632, x672, x552, x673, x556, x674, x633, x675, x677, x678, x561, x680, x566, x681, x630, x682, x684, x685, x571, x686, x634, x687, x689, x690, x576, x691, x638, x692, x694, x695, x581, x696, x643, x697, x699, x700, x586, x701, x648, x702, x704, x705, x591, x706, x653, x707, x709, x710, x596, x711, x658, x712, x714, x715, x601, x716, x663, x717, x719, x720, x606, x721, x668, x722, x724, x725, x611, x726, x671, x727, x729, x730, x613, x14, x752, x755, x757, x753, x758, x750, x759, x761, x762, x751, x763, x748, x764, x766, x767, x749, x768, x746, x769, x771, x772, x747, x773, x744, x774, x776, x777, x745, x778, x742, x779, x781, x782, x743, x783, x740, x784, x786, x787, x741, x788, x738, x789, x791, x792, x739, x793, x736, x794, x796, x797, x737, x798, x734, x799, x801, x802, x735, x803, x732, x804, x806, x807, x733, x754, x676, x810, x679, x811, x756, x812, x814, x815, x683, x816, x760, x817, x819, x820, x688, x821, x765, x822, x824, x825, x693, x826, x770, x827, x829, x830, x698, x831, x775, x832, x834, x835, x703, x836, x780, x837, x839, x840, x708, x841, x785, x842, x844, x845, x713, x846, x790, x847, x849, x850, x718, x851, x795, x852, x854, x855, x723, x856, x800, x857, x859, x860, x728, x861, x805, x862, x864, x865, x731, x866, x808, x867, x869, x885, x888, x892, x886, x893, x883, x894, x896, x897, x884, x898, x881, x899, x901, x902, x882, x903, x879, x904, x906, x907, x880, x908, x877, x909, x911, x912, x878, x913, x875, x914, x916, x917, x876, x918, x873, x919, x921, x922, x874, x923, x871, x924, x926, x927, x872, x889, x929, x809, x930, x813, x931, x890, x932, x934, x935, x818, x937, x823, x938, x887, x939, x941, x942, x828, x943, x891, x944, x946, x947, x833, x948, x895, x949, x951, x952, x838, x953, x900, x954, x956, x957, x843, x958, x905, x959, x961, x962, x848, x963, x910, x964, x966, x967, x853, x968, x915, x969, x971, x972, x858, x973, x920, x974, x976, x977, x863, x978, x925, x979, x981, x982, x868, x983, x928, x984, x986, x987, x870, x15, x1009, x1012, x1014, x1010, x1015, x1007, x1016, x1018, x1019, x1008, x1020, x1005, x1021, x1023, x1024, x1006, x1025, x1003, x1026, x1028, x1029, x1004, x1030, x1001, x1031, x1033, x1034, x1002, x1035, x999, x1036, x1038, x1039, x1000, x1040, x997, x1041, x1043, x1044, x998, x1045, x995, x1046, x1048, x1049, x996, x1050, x993, x1051, x1053, x1054, x994, x1055, x991, x1056, x1058, x1059, x992, x1060, x989, x1061, x1063, x1064, x990, x1011, x933, x1067, x936, x1068, x1013, x1069, x1071, x1072, x940, x1073, x1017, x1074, x1076, x1077, x945, x1078, x1022, x1079, x1081, x1082, x950, x1083, x1027, x1084, x1086, x1087, x955, x1088, x1032, x1089, x1091, x1092, x960, x1093, x1037, x1094, x1096, x1097, x965, x1098, x1042, x1099, x1101, x1102, x970, x1103, x1047, x1104, x1106, x1107, x975, x1108, x1052, x1109, x1111, x1112, x980, x1113, x1057, x1114, x1116, x1117, x985, x1118, x1062, x1119, x1121, x1122, x988, x1123, x1065, x1124, x1126, x1142, x1145, x1149, x1143, x1150, x1140, x1151, x1153, x1154, x1141, x1155, x1138, x1156, x1158, x1159, x1139, x1160, x1136, x1161, x1163, x1164, x1137, x1165, x1134, x1166, x1168, x1169, x1135, x1170, x1132, x1171, x1173, x1174, x1133, x1175, x1130, x1176, x1178, x1179, x1131, x1180, x1128, x1181, x1183, x1184, x1129, x1146, x1186, x1066, x1187, x1070, x1188, x1147, x1189, x1191, x1192, x1075, x1194, x1080, x1195, x1144, x1196, x1198, x1199, x1085, x1200, x1148, x1201, x1203, x1204, x1090, x1205, x1152, x1206, x1208, x1209, x1095, x1210, x1157, x1211, x1213, x1214, x1100, x1215, x1162, x1216, x1218, x1219, x1105, x1220, x1167, x1221, x1223, x1224, x1110, x1225, x1172, x1226, x1228, x1229, x1115, x1230, x1177, x1231, x1233, x1234, x1120, x1235, x1182, x1236, x1238, x1239, x1125, x1240, x1185, x1241, x1243, x1244, x1127, x16, x1266, x1269, x1271, x1267, x1272, x1264, x1273, x1275, x1276, x1265, x1277, x1262, x1278, x1280, x1281, x1263, x1282, x1260, x1283, x1285, x1286, x1261, x1287, x1258, x1288, x1290, x1291, x1259, x1292, x1256, x1293, x1295, x1296, x1257, x1297, x1254, x1298, x1300, x1301, x1255, x1302, x1252, x1303, x1305, x1306, x1253, x1307, x1250, x1308, x1310, x1311, x1251, x1312, x1248, x1313, x1315, x1316, x1249, x1317, x1246, x1318, x1320, x1321, x1247, x1268, x1190, x1324, x1193, x1325, x1270, x1326, x1328, x1329, x1197, x1330, x1274, x1331, x1333, x1334, x1202, x1335, x1279, x1336, x1338, x1339, x1207, x1340, x1284, x1341, x1343, x1344, x1212, x1345, x1289, x1346, x1348, x1349, x1217, x1350, x1294, x1351, x1353, x1354, x1222, x1355, x1299, x1356, x1358, x1359, x1227, x1360, x1304, x1361, x1363, x1364, x1232, x1365, x1309, x1366, x1368, x1369, x1237, x1370, x1314, x1371, x1373, x1374, x1242, x1375, x1319, x1376, x1378, x1379, x1245, x1380, x1322, x1381, x1383, x1399, x1402, x1406, x1400, x1407, x1397, x1408, x1410, x1411, x1398, x1412, x1395, x1413, x1415, x1416, x1396, x1417, x1393, x1418, x1420, x1421, x1394, x1422, x1391, x1423, x1425, x1426, x1392, x1427, x1389, x1428, x1430, x1431, x1390, x1432, x1387, x1433, x1435, x1436, x1388, x1437, x1385, x1438, x1440, x1441, x1386, x1403, x1443, x1323, x1444, x1327, x1445, x1404, x1446, x1448, x1449, x1332, x1451, x1337, x1452, x1401, x1453, x1455, x1456, x1342, x1457, x1405, x1458, x1460, x1461, x1347, x1462, x1409, x1463, x1465, x1466, x1352, x1467, x1414, x1468, x1470, x1471, x1357, x1472, x1419, x1473, x1475, x1476, x1362, x1477, x1424, x1478, x1480, x1481, x1367, x1482, x1429, x1483, x1485, x1486, x1372, x1487, x1434, x1488, x1490, x1491, x1377, x1492, x1439, x1493, x1495, x1496, x1382, x1497, x1442, x1498, x1500, x1501, x1384, x17, x1523, x1526, x1528, x1524, x1529, x1521, x1530, x1532, x1533, x1522, x1534, x1519, x1535, x1537, x1538, x1520, x1539, x1517, x1540, x1542, x1543, x1518, x1544, x1515, x1545, x1547, x1548, x1516, x1549, x1513, x1550, x1552, x1553, x1514, x1554, x1511, x1555, x1557, x1558, x1512, x1559, x1509, x1560, x1562, x1563, x1510, x1564, x1507, x1565, x1567, x1568, x1508, x1569, x1505, x1570, x1572, x1573, x1506, x1574, x1503, x1575, x1577, x1578, x1504, x1525, x1447, x1581, x1450, x1582, x1527, x1583, x1585, x1586, x1454, x1587, x1531, x1588, x1590, x1591, x1459, x1592, x1536, x1593, x1595, x1596, x1464, x1597, x1541, x1598, x1600, x1601, x1469, x1602, x1546, x1603, x1605, x1606, x1474, x1607, x1551, x1608, x1610, x1611, x1479, x1612, x1556, x1613, x1615, x1616, x1484, x1617, x1561, x1618, x1620, x1621, x1489, x1622, x1566, x1623, x1625, x1626, x1494, x1627, x1571, x1628, x1630, x1631, x1499, x1632, x1576, x1633, x1635, x1636, x1502, x1637, x1579, x1638, x1640, x1656, x1659, x1663, x1657, x1664, x1654, x1665, x1667, x1668, x1655, x1669, x1652, x1670, x1672, x1673, x1653, x1674, x1650, x1675, x1677, x1678, x1651, x1679, x1648, x1680, x1682, x1683, x1649, x1684, x1646, x1685, x1687, x1688, x1647, x1689, x1644, x1690, x1692, x1693, x1645, x1694, x1642, x1695, x1697, x1698, x1643, x1660, x1700, x1580, x1701, x1584, x1702, x1661, x1703, x1705, x1706, x1589, x1708, x1594, x1709, x1658, x1710, x1712, x1713, x1599, x1714, x1662, x1715, x1717, x1718, x1604, x1719, x1666, x1720, x1722, x1723, x1609, x1724, x1671, x1725, x1727, x1728, x1614, x1729, x1676, x1730, x1732, x1733, x1619, x1734, x1681, x1735, x1737, x1738, x1624, x1739, x1686, x1740, x1742, x1743, x1629, x1744, x1691, x1745, x1747, x1748, x1634, x1749, x1696, x1750, x1752, x1753, x1639, x1754, x1699, x1755, x1757, x1758, x1641, x18, x1780, x1783, x1785, x1781, x1786, x1778, x1787, x1789, x1790, x1779, x1791, x1776, x1792, x1794, x1795, x1777, x1796, x1774, x1797, x1799, x1800, x1775, x1801, x1772, x1802, x1804, x1805, x1773, x1806, x1770, x1807, x1809, x1810, x1771, x1811, x1768, x1812, x1814, x1815, x1769, x1816, x1766, x1817, x1819, x1820, x1767, x1821, x1764, x1822, x1824, x1825, x1765, x1826, x1762, x1827, x1829, x1830, x1763, x1831, x1760, x1832, x1834, x1835, x1761, x1782, x1704, x1838, x1707, x1839, x1784, x1840, x1842, x1843, x1711, x1844, x1788, x1845, x1847, x1848, x1716, x1849, x1793, x1850, x1852, x1853, x1721, x1854, x1798, x1855, x1857, x1858, x1726, x1859, x1803, x1860, x1862, x1863, x1731, x1864, x1808, x1865, x1867, x1868, x1736, x1869, x1813, x1870, x1872, x1873, x1741, x1874, x1818, x1875, x1877, x1878, x1746, x1879, x1823, x1880, x1882, x1883, x1751, x1884, x1828, x1885, x1887, x1888, x1756, x1889, x1833, x1890, x1892, x1893, x1759, x1894, x1836, x1895, x1897, x1913, x1916, x1920, x1914, x1921, x1911, x1922, x1924, x1925, x1912, x1926, x1909, x1927, x1929, x1930, x1910, x1931, x1907, x1932, x1934, x1935, x1908, x1936, x1905, x1937, x1939, x1940, x1906, x1941, x1903, x1942, x1944, x1945, x1904, x1946, x1901, x1947, x1949, x1950, x1902, x1951, x1899, x1952, x1954, x1955, x1900, x1917, x1957, x1837, x1958, x1841, x1959, x1918, x1960, x1962, x1963, x1846, x1965, x1851, x1966, x1915, x1967, x1969, x1970, x1856, x1971, x1919, x1972, x1974, x1975, x1861, x1976, x1923, x1977, x1979, x1980, x1866, x1981, x1928, x1982, x1984, x1985, x1871, x1986, x1933, x1987, x1989, x1990, x1876, x1991, x1938, x1992, x1994, x1995, x1881, x1996, x1943, x1997, x1999, x2000, x1886, x2001, x1948, x2002, x2004, x2005, x1891, x2006, x1953, x2007, x2009, x2010, x1896, x2011, x1956, x2012, x2014, x2015, x1898, x19, x2037, x2040, x2042, x2038, x2043, x2035, x2044, x2046, x2047, x2036, x2048, x2033, x2049, x2051, x2052, x2034, x2053, x2031, x2054, x2056, x2057, x2032, x2058, x2029, x2059, x2061, x2062, x2030, x2063, x2027, x2064, x2066, x2067, x2028, x2068, x2025, x2069, x2071, x2072, x2026, x2073, x2023, x2074, x2076, x2077, x2024, x2078, x2021, x2079, x2081, x2082, x2022, x2083, x2019, x2084, x2086, x2087, x2020, x2088, x2017, x2089, x2091, x2092, x2018, x2039, x1961, x2095, x1964, x2096, x2041, x2097, x2099, x2100, x1968, x2101, x2045, x2102, x2104, x2105, x1973, x2106, x2050, x2107, x2109, x2110, x1978, x2111, x2055, x2112, x2114, x2115, x1983, x2116, x2060, x2117, x2119, x2120, x1988, x2121, x2065, x2122, x2124, x2125, x1993, x2126, x2070, x2127, x2129, x2130, x1998, x2131, x2075, x2132, x2134, x2135, x2003, x2136, x2080, x2137, x2139, x2140, x2008, x2141, x2085, x2142, x2144, x2145, x2013, x2146, x2090, x2147, x2149, x2150, x2016, x2151, x2093, x2152, x2154, x2170, x2173, x2177, x2171, x2178, x2168, x2179, x2181, x2182, x2169, x2183, x2166, x2184, x2186, x2187, x2167, x2188, x2164, x2189, x2191, x2192, x2165, x2193, x2162, x2194, x2196, x2197, x2163, x2198, x2160, x2199, x2201, x2202, x2161, x2203, x2158, x2204, x2206, x2207, x2159, x2208, x2156, x2209, x2211, x2212, x2157, x2174, x2214, x2094, x2215, x2098, x2216, x2175, x2217, x2219, x2220, x2103, x2222, x2108, x2223, x2172, x2224, x2226, x2227, x2113, x2228, x2176, x2229, x2231, x2232, x2118, x2233, x2180, x2234, x2236, x2237, x2123, x2238, x2185, x2239, x2241, x2242, x2128, x2243, x2190, x2244, x2246, x2247, x2133, x2248, x2195, x2249, x2251, x2252, x2138, x2253, x2200, x2254, x2256, x2257, x2143, x2258, x2205, x2259, x2261, x2262, x2148, x2263, x2210, x2264, x2266, x2267, x2153, x2268, x2213, x2269, x2271, x2272, x2155, x20, x2294, x2297, x2299, x2295, x2300, x2292, x2301, x2303, x2304, x2293, x2305, x2290, x2306, x2308, x2309, x2291, x2310, x2288, x2311, x2313, x2314, x2289, x2315, x2286, x2316, x2318, x2319, x2287, x2320, x2284, x2321, x2323, x2324, x2285, x2325, x2282, x2326, x2328, x2329, x2283, x2330, x2280, x2331, x2333, x2334, x2281, x2335, x2278, x2336, x2338, x2339, x2279, x2340, x2276, x2341, x2343, x2344, x2277, x2345, x2274, x2346, x2348, x2349, x2275, x2296, x2218, x2352, x2221, x2353, x2298, x2354, x2356, x2357, x2225, x2358, x2302, x2359, x2361, x2362, x2230, x2363, x2307, x2364, x2366, x2367, x2235, x2368, x2312, x2369, x2371, x2372, x2240, x2373, x2317, x2374, x2376, x2377, x2245, x2378, x2322, x2379, x2381, x2382, x2250, x2383, x2327, x2384, x2386, x2387, x2255, x2388, x2332, x2389, x2391, x2392, x2260, x2393, x2337, x2394, x2396, x2397, x2265, x2398, x2342, x2399, x2401, x2402, x2270, x2403, x2347, x2404, x2406, x2407, x2273, x2408, x2350, x2409, x2411, x2427, x2430, x2434, x2428, x2435, x2425, x2436, x2438, x2439, x2426, x2440, x2423, x2441, x2443, x2444, x2424, x2445, x2421, x2446, x2448, x2449, x2422, x2450, x2419, x2451, x2453, x2454, x2420, x2455, x2417, x2456, x2458, x2459, x2418, x2460, x2415, x2461, x2463, x2464, x2416, x2465, x2413, x2466, x2468, x2469, x2414, x2431, x2471, x2351, x2472, x2355, x2473, x2432, x2474, x2476, x2477, x2360, x2479, x2365, x2480, x2429, x2481, x2483, x2484, x2370, x2485, x2433, x2486, x2488, x2489, x2375, x2490, x2437, x2491, x2493, x2494, x2380, x2495, x2442, x2496, x2498, x2499, x2385, x2500, x2447, x2501, x2503, x2504, x2390, x2505, x2452, x2506, x2508, x2509, x2395, x2510, x2457, x2511, x2513, x2514, x2400, x2515, x2462, x2516, x2518, x2519, x2405, x2520, x2467, x2521, x2523, x2524, x2410, x2525, x2470, x2526, x2528, x2529, x2412, x21, x2551, x2554, x2556, x2552, x2557, x2549, x2558, x2560, x2561, x2550, x2562, x2547, x2563, x2565, x2566, x2548, x2567, x2545, x2568, x2570, x2571, x2546, x2572, x2543, x2573, x2575, x2576, x2544, x2577, x2541, x2578, x2580, x2581, x2542, x2582, x2539, x2583, x2585, x2586, x2540, x2587, x2537, x2588, x2590, x2591, x2538, x2592, x2535, x2593, x2595, x2596, x2536, x2597, x2533, x2598, x2600, x2601, x2534, x2602, x2531, x2603, x2605, x2606, x2532, x2553, x2475, x2609, x2478, x2610, x2555, x2611, x2613, x2614, x2482, x2615, x2559, x2616, x2618, x2619, x2487, x2620, x2564, x2621, x2623, x2624, x2492, x2625, x2569, x2626, x2628, x2629, x2497, x2630, x2574, x2631, x2633, x2634, x2502, x2635, x2579, x2636, x2638, x2639, x2507, x2640, x2584, x2641, x2643, x2644, x2512, x2645, x2589, x2646, x2648, x2649, x2517, x2650, x2594, x2651, x2653, x2654, x2522, x2655, x2599, x2656, x2658, x2659, x2527, x2660, x2604, x2661, x2663, x2664, x2530, x2665, x2607, x2666, x2668, x2684, x2687, x2691, x2685, x2692, x2682, x2693, x2695, x2696, x2683, x2697, x2680, x2698, x2700, x2701, x2681, x2702, x2678, x2703, x2705, x2706, x2679, x2707, x2676, x2708, x2710, x2711, x2677, x2712, x2674, x2713, x2715, x2716, x2675, x2717, x2672, x2718, x2720, x2721, x2673, x2722, x2670, x2723, x2725, x2726, x2671, x2688, x2728, x2608, x2729, x2612, x2730, x2689, x2731, x2733, x2734, x2617, x2736, x2622, x2737, x2686, x2738, x2740, x2741, x2627, x2742, x2690, x2743, x2745, x2746, x2632, x2747, x2694, x2748, x2750, x2751, x2637, x2752, x2699, x2753, x2755, x2756, x2642, x2757, x2704, x2758, x2760, x2761, x2647, x2762, x2709, x2763, x2765, x2766, x2652, x2767, x2714, x2768, x2770, x2771, x2657, x2772, x2719, x2773, x2775, x2776, x2662, x2777, x2724, x2778, x2780, x2781, x2667, x2782, x2727, x2783, x2785, x2786, x2669, x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x22, x0, x2808, x2811, x2813, x2809, x2814, x2806, x2815, x2817, x2818, x2807, x2819, x2804, x2820, x2822, x2823, x2805, x2824, x2802, x2825, x2827, x2828, x2803, x2829, x2800, x2830, x2832, x2833, x2801, x2834, x2798, x2835, x2837, x2838, x2799, x2839, x2796, x2840, x2842, x2843, x2797, x2844, x2794, x2845, x2847, x2848, x2795, x2849, x2792, x2850, x2852, x2853, x2793, x2854, x2790, x2855, x2857, x2858, x2791, x2859, x2788, x2860, x2862, x2863, x2789, x2810, x2732, x2866, x2735, x2867, x2812, x2868, x2870, x2871, x2739, x2872, x2816, x2873, x2875, x2876, x2744, x2877, x2821, x2878, x2880, x2881, x2749, x2882, x2826, x2883, x2885, x2886, x2754, x2887, x2831, x2888, x2890, x2891, x2759, x2892, x2836, x2893, x2895, x2896, x2764, x2897, x2841, x2898, x2900, x2901, x2769, x2902, x2846, x2903, x2905, x2906, x2774, x2907, x2851, x2908, x2910, x2911, x2779, x2912, x2856, x2913, x2915, x2916, x2784, x2917, x2861, x2918, x2920, x2921, x2787, x2922, x2864, x2923, x2925, x2941, x2944, x2948, x2942, x2949, x2939, x2950, x2952, x2953, x2940, x2954, x2937, x2955, x2957, x2958, x2938, x2959, x2935, x2960, x2962, x2963, x2936, x2964, x2933, x2965, x2967, x2968, x2934, x2969, x2931, x2970, x2972, x2973, x2932, x2974, x2929, x2975, x2977, x2978, x2930, x2979, x2927, x2980, x2982, x2983, x2928, x2945, x2985, x2865, x2986, x2869, x2987, x2946, x2988, x2990, x2991, x2874, x2993, x2879, x2994, x2943, x2995, x2997, x2998, x2884, x2999, x2947, x3000, x3002, x3003, x2889, x3004, x2951, x3005, x3007, x3008, x2894, x3009, x2956, x3010, x3012, x3013, x2899, x3014, x2961, x3015, x3017, x3018, x2904, x3019, x2966, x3020, x3022, x3023, x2909, x3024, x2971, x3025, x3027, x3028, x2914, x3029, x2976, x3030, x3032, x3033, x2919, x3034, x2981, x3035, x3037, x3038, x2924, x3039, x2984, x3040, x3042, x3043, x2926, x3046, x3047, x3048, x3049, x3051, x3052, x3053, x3055, x3056, x3057, x3058, x3060, x3061, x3062, x3063, x3065, x3066, x3067, x3068, x3070, x3071, x3072, x3073, x3075, x3076, x3077, x3078, x3080, x3081, x3082, x3083, x3085, x3086, x3087, x3088, x3090, x3091, x3092, x3093, x3095, x3096, x3097, x3098, x3100, x3101, x3044, x3103, x3102, x3104, x2989, x3106, x3045, x3107, x2992, x3109, x3050, x3110, x2996, x3112, x3054, x3113, x3001, x3115, x3059, x3116, x3006, x3118, x3064, x3119, x3011, x3121, x3069, x3122, x3016, x3124, x3074, x3125, x3021, x3127, x3079, x3128, x3026, x3130, x3084, x3131, x3031, x3133, x3089, x3134, x3036, x3136, x3094, x3137, x3105, x3041, x3139, x3099, x3140, x3108, x3111, x3114, x3117, x3120, x3123, x3126, x3129, x3132, x3135, x3138, x3141, x3142, x3143, x3144, x3145, x3146, x3147, x3148, x3149, x3150, x3151, x3152, x3153;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x12 = x1;
x13 = x2;
x14 = x3;
x15 = x4;
x16 = x5;
x17 = x6;
x18 = x7;
x19 = x8;
x20 = x9;
x21 = x10;
x22 = x11;
x23 = x0;
x24 = (x23)*(x11);
x25 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x11))>>32 : ((__uint128_t)(x23)*(x11))>>64;
x26 = (x23)*(x10);
x27 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x10))>>32 : ((__uint128_t)(x23)*(x10))>>64;
x28 = (x23)*(x9);
x29 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x9))>>32 : ((__uint128_t)(x23)*(x9))>>64;
x30 = (x23)*(x8);
x31 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x8))>>32 : ((__uint128_t)(x23)*(x8))>>64;
x32 = (x23)*(x7);
x33 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x7))>>32 : ((__uint128_t)(x23)*(x7))>>64;
x34 = (x23)*(x6);
x35 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x6))>>32 : ((__uint128_t)(x23)*(x6))>>64;
x36 = (x23)*(x5);
x37 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x5))>>32 : ((__uint128_t)(x23)*(x5))>>64;
x38 = (x23)*(x4);
x39 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x4))>>32 : ((__uint128_t)(x23)*(x4))>>64;
x40 = (x23)*(x3);
x41 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x3))>>32 : ((__uint128_t)(x23)*(x3))>>64;
x42 = (x23)*(x2);
x43 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x2))>>32 : ((__uint128_t)(x23)*(x2))>>64;
x44 = (x23)*(x1);
x45 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x1))>>32 : ((__uint128_t)(x23)*(x1))>>64;
x46 = (x23)*(x0);
x47 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*(x0))>>32 : ((__uint128_t)(x23)*(x0))>>64;
x48 = (x47)+(x44);
x49 = (x48)<(x47);
x50 = (x49)+(x45);
x51 = (x50)<(x45);
x52 = (x50)+(x42);
x53 = (x52)<(x42);
x54 = (x51)+(x53);
x55 = (x54)+(x43);
x56 = (x55)<(x43);
x57 = (x55)+(x40);
x58 = (x57)<(x40);
x59 = (x56)+(x58);
x60 = (x59)+(x41);
x61 = (x60)<(x41);
x62 = (x60)+(x38);
x63 = (x62)<(x38);
x64 = (x61)+(x63);
x65 = (x64)+(x39);
x66 = (x65)<(x39);
x67 = (x65)+(x36);
x68 = (x67)<(x36);
x69 = (x66)+(x68);
x70 = (x69)+(x37);
x71 = (x70)<(x37);
x72 = (x70)+(x34);
x73 = (x72)<(x34);
x74 = (x71)+(x73);
x75 = (x74)+(x35);
x76 = (x75)<(x35);
x77 = (x75)+(x32);
x78 = (x77)<(x32);
x79 = (x76)+(x78);
x80 = (x79)+(x33);
x81 = (x80)<(x33);
x82 = (x80)+(x30);
x83 = (x82)<(x30);
x84 = (x81)+(x83);
x85 = (x84)+(x31);
x86 = (x85)<(x31);
x87 = (x85)+(x28);
x88 = (x87)<(x28);
x89 = (x86)+(x88);
x90 = (x89)+(x29);
x91 = (x90)<(x29);
x92 = (x90)+(x26);
x93 = (x92)<(x26);
x94 = (x91)+(x93);
x95 = (x94)+(x27);
x96 = (x95)<(x27);
x97 = (x95)+(x24);
x98 = (x97)<(x24);
x99 = (x96)+(x98);
x100 = (x99)+(x25);
x101 = (x46)*((uintptr_t)4294967295ULL);
x102 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x103 = (x46)*((uintptr_t)4294967295ULL);
x104 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x105 = (x46)*((uintptr_t)4294967295ULL);
x106 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x107 = (x46)*((uintptr_t)4294967295ULL);
x108 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x109 = (x46)*((uintptr_t)4294967295ULL);
x110 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x111 = (x46)*((uintptr_t)4294967295ULL);
x112 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x113 = (x46)*((uintptr_t)4294967295ULL);
x114 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x115 = (x46)*((uintptr_t)4294967294ULL);
x116 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967294ULL))>>64;
x117 = (x46)*((uintptr_t)4294967295ULL);
x118 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x119 = (x46)*((uintptr_t)4294967295ULL);
x120 = sizeof(intptr_t) == 4 ? ((uint64_t)(x46)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x46)*((uintptr_t)4294967295ULL))>>64;
x121 = (x118)+(x115);
x122 = (x121)<(x118);
x123 = (x122)+(x116);
x124 = (x123)<(x116);
x125 = (x123)+(x113);
x126 = (x125)<(x113);
x127 = (x124)+(x126);
x128 = (x127)+(x114);
x129 = (x128)<(x114);
x130 = (x128)+(x111);
x131 = (x130)<(x111);
x132 = (x129)+(x131);
x133 = (x132)+(x112);
x134 = (x133)<(x112);
x135 = (x133)+(x109);
x136 = (x135)<(x109);
x137 = (x134)+(x136);
x138 = (x137)+(x110);
x139 = (x138)<(x110);
x140 = (x138)+(x107);
x141 = (x140)<(x107);
x142 = (x139)+(x141);
x143 = (x142)+(x108);
x144 = (x143)<(x108);
x145 = (x143)+(x105);
x146 = (x145)<(x105);
x147 = (x144)+(x146);
x148 = (x147)+(x106);
x149 = (x148)<(x106);
x150 = (x148)+(x103);
x151 = (x150)<(x103);
x152 = (x149)+(x151);
x153 = (x152)+(x104);
x154 = (x153)<(x104);
x155 = (x153)+(x101);
x156 = (x155)<(x101);
x157 = (x154)+(x156);
x158 = (x157)+(x102);
x159 = (x46)+(x119);
x160 = (x159)<(x46);
x161 = (x160)+(x48);
x162 = (x161)<(x48);
x163 = (x161)+(x120);
x164 = (x163)<(x120);
x165 = (x162)+(x164);
x166 = (x165)+(x52);
x167 = (x166)<(x52);
x168 = (x167)+(x57);
x169 = (x168)<(x57);
x170 = (x168)+(x117);
x171 = (x170)<(x117);
x172 = (x169)+(x171);
x173 = (x172)+(x62);
x174 = (x173)<(x62);
x175 = (x173)+(x121);
x176 = (x175)<(x121);
x177 = (x174)+(x176);
x178 = (x177)+(x67);
x179 = (x178)<(x67);
x180 = (x178)+(x125);
x181 = (x180)<(x125);
x182 = (x179)+(x181);
x183 = (x182)+(x72);
x184 = (x183)<(x72);
x185 = (x183)+(x130);
x186 = (x185)<(x130);
x187 = (x184)+(x186);
x188 = (x187)+(x77);
x189 = (x188)<(x77);
x190 = (x188)+(x135);
x191 = (x190)<(x135);
x192 = (x189)+(x191);
x193 = (x192)+(x82);
x194 = (x193)<(x82);
x195 = (x193)+(x140);
x196 = (x195)<(x140);
x197 = (x194)+(x196);
x198 = (x197)+(x87);
x199 = (x198)<(x87);
x200 = (x198)+(x145);
x201 = (x200)<(x145);
x202 = (x199)+(x201);
x203 = (x202)+(x92);
x204 = (x203)<(x92);
x205 = (x203)+(x150);
x206 = (x205)<(x150);
x207 = (x204)+(x206);
x208 = (x207)+(x97);
x209 = (x208)<(x97);
x210 = (x208)+(x155);
x211 = (x210)<(x155);
x212 = (x209)+(x211);
x213 = (x212)+(x100);
x214 = (x213)<(x100);
x215 = (x213)+(x158);
x216 = (x215)<(x158);
x217 = (x214)+(x216);
x218 = (x12)*(x11);
x219 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x11))>>32 : ((__uint128_t)(x12)*(x11))>>64;
x220 = (x12)*(x10);
x221 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x10))>>32 : ((__uint128_t)(x12)*(x10))>>64;
x222 = (x12)*(x9);
x223 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x9))>>32 : ((__uint128_t)(x12)*(x9))>>64;
x224 = (x12)*(x8);
x225 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x8))>>32 : ((__uint128_t)(x12)*(x8))>>64;
x226 = (x12)*(x7);
x227 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x7))>>32 : ((__uint128_t)(x12)*(x7))>>64;
x228 = (x12)*(x6);
x229 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x6))>>32 : ((__uint128_t)(x12)*(x6))>>64;
x230 = (x12)*(x5);
x231 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x5))>>32 : ((__uint128_t)(x12)*(x5))>>64;
x232 = (x12)*(x4);
x233 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x4))>>32 : ((__uint128_t)(x12)*(x4))>>64;
x234 = (x12)*(x3);
x235 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x3))>>32 : ((__uint128_t)(x12)*(x3))>>64;
x236 = (x12)*(x2);
x237 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x2))>>32 : ((__uint128_t)(x12)*(x2))>>64;
x238 = (x12)*(x1);
x239 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x1))>>32 : ((__uint128_t)(x12)*(x1))>>64;
x240 = (x12)*(x0);
x241 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*(x0))>>32 : ((__uint128_t)(x12)*(x0))>>64;
x242 = (x241)+(x238);
x243 = (x242)<(x241);
x244 = (x243)+(x239);
x245 = (x244)<(x239);
x246 = (x244)+(x236);
x247 = (x246)<(x236);
x248 = (x245)+(x247);
x249 = (x248)+(x237);
x250 = (x249)<(x237);
x251 = (x249)+(x234);
x252 = (x251)<(x234);
x253 = (x250)+(x252);
x254 = (x253)+(x235);
x255 = (x254)<(x235);
x256 = (x254)+(x232);
x257 = (x256)<(x232);
x258 = (x255)+(x257);
x259 = (x258)+(x233);
x260 = (x259)<(x233);
x261 = (x259)+(x230);
x262 = (x261)<(x230);
x263 = (x260)+(x262);
x264 = (x263)+(x231);
x265 = (x264)<(x231);
x266 = (x264)+(x228);
x267 = (x266)<(x228);
x268 = (x265)+(x267);
x269 = (x268)+(x229);
x270 = (x269)<(x229);
x271 = (x269)+(x226);
x272 = (x271)<(x226);
x273 = (x270)+(x272);
x274 = (x273)+(x227);
x275 = (x274)<(x227);
x276 = (x274)+(x224);
x277 = (x276)<(x224);
x278 = (x275)+(x277);
x279 = (x278)+(x225);
x280 = (x279)<(x225);
x281 = (x279)+(x222);
x282 = (x281)<(x222);
x283 = (x280)+(x282);
x284 = (x283)+(x223);
x285 = (x284)<(x223);
x286 = (x284)+(x220);
x287 = (x286)<(x220);
x288 = (x285)+(x287);
x289 = (x288)+(x221);
x290 = (x289)<(x221);
x291 = (x289)+(x218);
x292 = (x291)<(x218);
x293 = (x290)+(x292);
x294 = (x293)+(x219);
x295 = (x163)+(x240);
x296 = (x295)<(x163);
x297 = (x296)+(x166);
x298 = (x297)<(x166);
x299 = (x297)+(x242);
x300 = (x299)<(x242);
x301 = (x298)+(x300);
x302 = (x301)+(x170);
x303 = (x302)<(x170);
x304 = (x302)+(x246);
x305 = (x304)<(x246);
x306 = (x303)+(x305);
x307 = (x306)+(x175);
x308 = (x307)<(x175);
x309 = (x307)+(x251);
x310 = (x309)<(x251);
x311 = (x308)+(x310);
x312 = (x311)+(x180);
x313 = (x312)<(x180);
x314 = (x312)+(x256);
x315 = (x314)<(x256);
x316 = (x313)+(x315);
x317 = (x316)+(x185);
x318 = (x317)<(x185);
x319 = (x317)+(x261);
x320 = (x319)<(x261);
x321 = (x318)+(x320);
x322 = (x321)+(x190);
x323 = (x322)<(x190);
x324 = (x322)+(x266);
x325 = (x324)<(x266);
x326 = (x323)+(x325);
x327 = (x326)+(x195);
x328 = (x327)<(x195);
x329 = (x327)+(x271);
x330 = (x329)<(x271);
x331 = (x328)+(x330);
x332 = (x331)+(x200);
x333 = (x332)<(x200);
x334 = (x332)+(x276);
x335 = (x334)<(x276);
x336 = (x333)+(x335);
x337 = (x336)+(x205);
x338 = (x337)<(x205);
x339 = (x337)+(x281);
x340 = (x339)<(x281);
x341 = (x338)+(x340);
x342 = (x341)+(x210);
x343 = (x342)<(x210);
x344 = (x342)+(x286);
x345 = (x344)<(x286);
x346 = (x343)+(x345);
x347 = (x346)+(x215);
x348 = (x347)<(x215);
x349 = (x347)+(x291);
x350 = (x349)<(x291);
x351 = (x348)+(x350);
x352 = (x351)+(x217);
x353 = (x352)<(x217);
x354 = (x352)+(x294);
x355 = (x354)<(x294);
x356 = (x353)+(x355);
x357 = (x295)*((uintptr_t)4294967295ULL);
x358 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x359 = (x295)*((uintptr_t)4294967295ULL);
x360 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x361 = (x295)*((uintptr_t)4294967295ULL);
x362 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x363 = (x295)*((uintptr_t)4294967295ULL);
x364 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x365 = (x295)*((uintptr_t)4294967295ULL);
x366 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x367 = (x295)*((uintptr_t)4294967295ULL);
x368 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x369 = (x295)*((uintptr_t)4294967295ULL);
x370 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x371 = (x295)*((uintptr_t)4294967294ULL);
x372 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967294ULL))>>64;
x373 = (x295)*((uintptr_t)4294967295ULL);
x374 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x375 = (x295)*((uintptr_t)4294967295ULL);
x376 = sizeof(intptr_t) == 4 ? ((uint64_t)(x295)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x295)*((uintptr_t)4294967295ULL))>>64;
x377 = (x374)+(x371);
x378 = (x377)<(x374);
x379 = (x378)+(x372);
x380 = (x379)<(x372);
x381 = (x379)+(x369);
x382 = (x381)<(x369);
x383 = (x380)+(x382);
x384 = (x383)+(x370);
x385 = (x384)<(x370);
x386 = (x384)+(x367);
x387 = (x386)<(x367);
x388 = (x385)+(x387);
x389 = (x388)+(x368);
x390 = (x389)<(x368);
x391 = (x389)+(x365);
x392 = (x391)<(x365);
x393 = (x390)+(x392);
x394 = (x393)+(x366);
x395 = (x394)<(x366);
x396 = (x394)+(x363);
x397 = (x396)<(x363);
x398 = (x395)+(x397);
x399 = (x398)+(x364);
x400 = (x399)<(x364);
x401 = (x399)+(x361);
x402 = (x401)<(x361);
x403 = (x400)+(x402);
x404 = (x403)+(x362);
x405 = (x404)<(x362);
x406 = (x404)+(x359);
x407 = (x406)<(x359);
x408 = (x405)+(x407);
x409 = (x408)+(x360);
x410 = (x409)<(x360);
x411 = (x409)+(x357);
x412 = (x411)<(x357);
x413 = (x410)+(x412);
x414 = (x413)+(x358);
x415 = (x295)+(x375);
x416 = (x415)<(x295);
x417 = (x416)+(x299);
x418 = (x417)<(x299);
x419 = (x417)+(x376);
x420 = (x419)<(x376);
x421 = (x418)+(x420);
x422 = (x421)+(x304);
x423 = (x422)<(x304);
x424 = (x423)+(x309);
x425 = (x424)<(x309);
x426 = (x424)+(x373);
x427 = (x426)<(x373);
x428 = (x425)+(x427);
x429 = (x428)+(x314);
x430 = (x429)<(x314);
x431 = (x429)+(x377);
x432 = (x431)<(x377);
x433 = (x430)+(x432);
x434 = (x433)+(x319);
x435 = (x434)<(x319);
x436 = (x434)+(x381);
x437 = (x436)<(x381);
x438 = (x435)+(x437);
x439 = (x438)+(x324);
x440 = (x439)<(x324);
x441 = (x439)+(x386);
x442 = (x441)<(x386);
x443 = (x440)+(x442);
x444 = (x443)+(x329);
x445 = (x444)<(x329);
x446 = (x444)+(x391);
x447 = (x446)<(x391);
x448 = (x445)+(x447);
x449 = (x448)+(x334);
x450 = (x449)<(x334);
x451 = (x449)+(x396);
x452 = (x451)<(x396);
x453 = (x450)+(x452);
x454 = (x453)+(x339);
x455 = (x454)<(x339);
x456 = (x454)+(x401);
x457 = (x456)<(x401);
x458 = (x455)+(x457);
x459 = (x458)+(x344);
x460 = (x459)<(x344);
x461 = (x459)+(x406);
x462 = (x461)<(x406);
x463 = (x460)+(x462);
x464 = (x463)+(x349);
x465 = (x464)<(x349);
x466 = (x464)+(x411);
x467 = (x466)<(x411);
x468 = (x465)+(x467);
x469 = (x468)+(x354);
x470 = (x469)<(x354);
x471 = (x469)+(x414);
x472 = (x471)<(x414);
x473 = (x470)+(x472);
x474 = (x473)+(x356);
x475 = (x13)*(x11);
x476 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x11))>>32 : ((__uint128_t)(x13)*(x11))>>64;
x477 = (x13)*(x10);
x478 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x10))>>32 : ((__uint128_t)(x13)*(x10))>>64;
x479 = (x13)*(x9);
x480 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x9))>>32 : ((__uint128_t)(x13)*(x9))>>64;
x481 = (x13)*(x8);
x482 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x8))>>32 : ((__uint128_t)(x13)*(x8))>>64;
x483 = (x13)*(x7);
x484 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x7))>>32 : ((__uint128_t)(x13)*(x7))>>64;
x485 = (x13)*(x6);
x486 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x6))>>32 : ((__uint128_t)(x13)*(x6))>>64;
x487 = (x13)*(x5);
x488 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x5))>>32 : ((__uint128_t)(x13)*(x5))>>64;
x489 = (x13)*(x4);
x490 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x4))>>32 : ((__uint128_t)(x13)*(x4))>>64;
x491 = (x13)*(x3);
x492 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x3))>>32 : ((__uint128_t)(x13)*(x3))>>64;
x493 = (x13)*(x2);
x494 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x2))>>32 : ((__uint128_t)(x13)*(x2))>>64;
x495 = (x13)*(x1);
x496 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x1))>>32 : ((__uint128_t)(x13)*(x1))>>64;
x497 = (x13)*(x0);
x498 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*(x0))>>32 : ((__uint128_t)(x13)*(x0))>>64;
x499 = (x498)+(x495);
x500 = (x499)<(x498);
x501 = (x500)+(x496);
x502 = (x501)<(x496);
x503 = (x501)+(x493);
x504 = (x503)<(x493);
x505 = (x502)+(x504);
x506 = (x505)+(x494);
x507 = (x506)<(x494);
x508 = (x506)+(x491);
x509 = (x508)<(x491);
x510 = (x507)+(x509);
x511 = (x510)+(x492);
x512 = (x511)<(x492);
x513 = (x511)+(x489);
x514 = (x513)<(x489);
x515 = (x512)+(x514);
x516 = (x515)+(x490);
x517 = (x516)<(x490);
x518 = (x516)+(x487);
x519 = (x518)<(x487);
x520 = (x517)+(x519);
x521 = (x520)+(x488);
x522 = (x521)<(x488);
x523 = (x521)+(x485);
x524 = (x523)<(x485);
x525 = (x522)+(x524);
x526 = (x525)+(x486);
x527 = (x526)<(x486);
x528 = (x526)+(x483);
x529 = (x528)<(x483);
x530 = (x527)+(x529);
x531 = (x530)+(x484);
x532 = (x531)<(x484);
x533 = (x531)+(x481);
x534 = (x533)<(x481);
x535 = (x532)+(x534);
x536 = (x535)+(x482);
x537 = (x536)<(x482);
x538 = (x536)+(x479);
x539 = (x538)<(x479);
x540 = (x537)+(x539);
x541 = (x540)+(x480);
x542 = (x541)<(x480);
x543 = (x541)+(x477);
x544 = (x543)<(x477);
x545 = (x542)+(x544);
x546 = (x545)+(x478);
x547 = (x546)<(x478);
x548 = (x546)+(x475);
x549 = (x548)<(x475);
x550 = (x547)+(x549);
x551 = (x550)+(x476);
x552 = (x419)+(x497);
x553 = (x552)<(x419);
x554 = (x553)+(x422);
x555 = (x554)<(x422);
x556 = (x554)+(x499);
x557 = (x556)<(x499);
x558 = (x555)+(x557);
x559 = (x558)+(x426);
x560 = (x559)<(x426);
x561 = (x559)+(x503);
x562 = (x561)<(x503);
x563 = (x560)+(x562);
x564 = (x563)+(x431);
x565 = (x564)<(x431);
x566 = (x564)+(x508);
x567 = (x566)<(x508);
x568 = (x565)+(x567);
x569 = (x568)+(x436);
x570 = (x569)<(x436);
x571 = (x569)+(x513);
x572 = (x571)<(x513);
x573 = (x570)+(x572);
x574 = (x573)+(x441);
x575 = (x574)<(x441);
x576 = (x574)+(x518);
x577 = (x576)<(x518);
x578 = (x575)+(x577);
x579 = (x578)+(x446);
x580 = (x579)<(x446);
x581 = (x579)+(x523);
x582 = (x581)<(x523);
x583 = (x580)+(x582);
x584 = (x583)+(x451);
x585 = (x584)<(x451);
x586 = (x584)+(x528);
x587 = (x586)<(x528);
x588 = (x585)+(x587);
x589 = (x588)+(x456);
x590 = (x589)<(x456);
x591 = (x589)+(x533);
x592 = (x591)<(x533);
x593 = (x590)+(x592);
x594 = (x593)+(x461);
x595 = (x594)<(x461);
x596 = (x594)+(x538);
x597 = (x596)<(x538);
x598 = (x595)+(x597);
x599 = (x598)+(x466);
x600 = (x599)<(x466);
x601 = (x599)+(x543);
x602 = (x601)<(x543);
x603 = (x600)+(x602);
x604 = (x603)+(x471);
x605 = (x604)<(x471);
x606 = (x604)+(x548);
x607 = (x606)<(x548);
x608 = (x605)+(x607);
x609 = (x608)+(x474);
x610 = (x609)<(x474);
x611 = (x609)+(x551);
x612 = (x611)<(x551);
x613 = (x610)+(x612);
x614 = (x552)*((uintptr_t)4294967295ULL);
x615 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x616 = (x552)*((uintptr_t)4294967295ULL);
x617 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x618 = (x552)*((uintptr_t)4294967295ULL);
x619 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x620 = (x552)*((uintptr_t)4294967295ULL);
x621 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x622 = (x552)*((uintptr_t)4294967295ULL);
x623 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x624 = (x552)*((uintptr_t)4294967295ULL);
x625 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x626 = (x552)*((uintptr_t)4294967295ULL);
x627 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x628 = (x552)*((uintptr_t)4294967294ULL);
x629 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967294ULL))>>64;
x630 = (x552)*((uintptr_t)4294967295ULL);
x631 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x632 = (x552)*((uintptr_t)4294967295ULL);
x633 = sizeof(intptr_t) == 4 ? ((uint64_t)(x552)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x552)*((uintptr_t)4294967295ULL))>>64;
x634 = (x631)+(x628);
x635 = (x634)<(x631);
x636 = (x635)+(x629);
x637 = (x636)<(x629);
x638 = (x636)+(x626);
x639 = (x638)<(x626);
x640 = (x637)+(x639);
x641 = (x640)+(x627);
x642 = (x641)<(x627);
x643 = (x641)+(x624);
x644 = (x643)<(x624);
x645 = (x642)+(x644);
x646 = (x645)+(x625);
x647 = (x646)<(x625);
x648 = (x646)+(x622);
x649 = (x648)<(x622);
x650 = (x647)+(x649);
x651 = (x650)+(x623);
x652 = (x651)<(x623);
x653 = (x651)+(x620);
x654 = (x653)<(x620);
x655 = (x652)+(x654);
x656 = (x655)+(x621);
x657 = (x656)<(x621);
x658 = (x656)+(x618);
x659 = (x658)<(x618);
x660 = (x657)+(x659);
x661 = (x660)+(x619);
x662 = (x661)<(x619);
x663 = (x661)+(x616);
x664 = (x663)<(x616);
x665 = (x662)+(x664);
x666 = (x665)+(x617);
x667 = (x666)<(x617);
x668 = (x666)+(x614);
x669 = (x668)<(x614);
x670 = (x667)+(x669);
x671 = (x670)+(x615);
x672 = (x552)+(x632);
x673 = (x672)<(x552);
x674 = (x673)+(x556);
x675 = (x674)<(x556);
x676 = (x674)+(x633);
x677 = (x676)<(x633);
x678 = (x675)+(x677);
x679 = (x678)+(x561);
x680 = (x679)<(x561);
x681 = (x680)+(x566);
x682 = (x681)<(x566);
x683 = (x681)+(x630);
x684 = (x683)<(x630);
x685 = (x682)+(x684);
x686 = (x685)+(x571);
x687 = (x686)<(x571);
x688 = (x686)+(x634);
x689 = (x688)<(x634);
x690 = (x687)+(x689);
x691 = (x690)+(x576);
x692 = (x691)<(x576);
x693 = (x691)+(x638);
x694 = (x693)<(x638);
x695 = (x692)+(x694);
x696 = (x695)+(x581);
x697 = (x696)<(x581);
x698 = (x696)+(x643);
x699 = (x698)<(x643);
x700 = (x697)+(x699);
x701 = (x700)+(x586);
x702 = (x701)<(x586);
x703 = (x701)+(x648);
x704 = (x703)<(x648);
x705 = (x702)+(x704);
x706 = (x705)+(x591);
x707 = (x706)<(x591);
x708 = (x706)+(x653);
x709 = (x708)<(x653);
x710 = (x707)+(x709);
x711 = (x710)+(x596);
x712 = (x711)<(x596);
x713 = (x711)+(x658);
x714 = (x713)<(x658);
x715 = (x712)+(x714);
x716 = (x715)+(x601);
x717 = (x716)<(x601);
x718 = (x716)+(x663);
x719 = (x718)<(x663);
x720 = (x717)+(x719);
x721 = (x720)+(x606);
x722 = (x721)<(x606);
x723 = (x721)+(x668);
x724 = (x723)<(x668);
x725 = (x722)+(x724);
x726 = (x725)+(x611);
x727 = (x726)<(x611);
x728 = (x726)+(x671);
x729 = (x728)<(x671);
x730 = (x727)+(x729);
x731 = (x730)+(x613);
x732 = (x14)*(x11);
x733 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x11))>>32 : ((__uint128_t)(x14)*(x11))>>64;
x734 = (x14)*(x10);
x735 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x10))>>32 : ((__uint128_t)(x14)*(x10))>>64;
x736 = (x14)*(x9);
x737 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x9))>>32 : ((__uint128_t)(x14)*(x9))>>64;
x738 = (x14)*(x8);
x739 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x8))>>32 : ((__uint128_t)(x14)*(x8))>>64;
x740 = (x14)*(x7);
x741 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x7))>>32 : ((__uint128_t)(x14)*(x7))>>64;
x742 = (x14)*(x6);
x743 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x6))>>32 : ((__uint128_t)(x14)*(x6))>>64;
x744 = (x14)*(x5);
x745 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x5))>>32 : ((__uint128_t)(x14)*(x5))>>64;
x746 = (x14)*(x4);
x747 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x4))>>32 : ((__uint128_t)(x14)*(x4))>>64;
x748 = (x14)*(x3);
x749 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x3))>>32 : ((__uint128_t)(x14)*(x3))>>64;
x750 = (x14)*(x2);
x751 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x2))>>32 : ((__uint128_t)(x14)*(x2))>>64;
x752 = (x14)*(x1);
x753 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x1))>>32 : ((__uint128_t)(x14)*(x1))>>64;
x754 = (x14)*(x0);
x755 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*(x0))>>32 : ((__uint128_t)(x14)*(x0))>>64;
x756 = (x755)+(x752);
x757 = (x756)<(x755);
x758 = (x757)+(x753);
x759 = (x758)<(x753);
x760 = (x758)+(x750);
x761 = (x760)<(x750);
x762 = (x759)+(x761);
x763 = (x762)+(x751);
x764 = (x763)<(x751);
x765 = (x763)+(x748);
x766 = (x765)<(x748);
x767 = (x764)+(x766);
x768 = (x767)+(x749);
x769 = (x768)<(x749);
x770 = (x768)+(x746);
x771 = (x770)<(x746);
x772 = (x769)+(x771);
x773 = (x772)+(x747);
x774 = (x773)<(x747);
x775 = (x773)+(x744);
x776 = (x775)<(x744);
x777 = (x774)+(x776);
x778 = (x777)+(x745);
x779 = (x778)<(x745);
x780 = (x778)+(x742);
x781 = (x780)<(x742);
x782 = (x779)+(x781);
x783 = (x782)+(x743);
x784 = (x783)<(x743);
x785 = (x783)+(x740);
x786 = (x785)<(x740);
x787 = (x784)+(x786);
x788 = (x787)+(x741);
x789 = (x788)<(x741);
x790 = (x788)+(x738);
x791 = (x790)<(x738);
x792 = (x789)+(x791);
x793 = (x792)+(x739);
x794 = (x793)<(x739);
x795 = (x793)+(x736);
x796 = (x795)<(x736);
x797 = (x794)+(x796);
x798 = (x797)+(x737);
x799 = (x798)<(x737);
x800 = (x798)+(x734);
x801 = (x800)<(x734);
x802 = (x799)+(x801);
x803 = (x802)+(x735);
x804 = (x803)<(x735);
x805 = (x803)+(x732);
x806 = (x805)<(x732);
x807 = (x804)+(x806);
x808 = (x807)+(x733);
x809 = (x676)+(x754);
x810 = (x809)<(x676);
x811 = (x810)+(x679);
x812 = (x811)<(x679);
x813 = (x811)+(x756);
x814 = (x813)<(x756);
x815 = (x812)+(x814);
x816 = (x815)+(x683);
x817 = (x816)<(x683);
x818 = (x816)+(x760);
x819 = (x818)<(x760);
x820 = (x817)+(x819);
x821 = (x820)+(x688);
x822 = (x821)<(x688);
x823 = (x821)+(x765);
x824 = (x823)<(x765);
x825 = (x822)+(x824);
x826 = (x825)+(x693);
x827 = (x826)<(x693);
x828 = (x826)+(x770);
x829 = (x828)<(x770);
x830 = (x827)+(x829);
x831 = (x830)+(x698);
x832 = (x831)<(x698);
x833 = (x831)+(x775);
x834 = (x833)<(x775);
x835 = (x832)+(x834);
x836 = (x835)+(x703);
x837 = (x836)<(x703);
x838 = (x836)+(x780);
x839 = (x838)<(x780);
x840 = (x837)+(x839);
x841 = (x840)+(x708);
x842 = (x841)<(x708);
x843 = (x841)+(x785);
x844 = (x843)<(x785);
x845 = (x842)+(x844);
x846 = (x845)+(x713);
x847 = (x846)<(x713);
x848 = (x846)+(x790);
x849 = (x848)<(x790);
x850 = (x847)+(x849);
x851 = (x850)+(x718);
x852 = (x851)<(x718);
x853 = (x851)+(x795);
x854 = (x853)<(x795);
x855 = (x852)+(x854);
x856 = (x855)+(x723);
x857 = (x856)<(x723);
x858 = (x856)+(x800);
x859 = (x858)<(x800);
x860 = (x857)+(x859);
x861 = (x860)+(x728);
x862 = (x861)<(x728);
x863 = (x861)+(x805);
x864 = (x863)<(x805);
x865 = (x862)+(x864);
x866 = (x865)+(x731);
x867 = (x866)<(x731);
x868 = (x866)+(x808);
x869 = (x868)<(x808);
x870 = (x867)+(x869);
x871 = (x809)*((uintptr_t)4294967295ULL);
x872 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x873 = (x809)*((uintptr_t)4294967295ULL);
x874 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x875 = (x809)*((uintptr_t)4294967295ULL);
x876 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x877 = (x809)*((uintptr_t)4294967295ULL);
x878 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x879 = (x809)*((uintptr_t)4294967295ULL);
x880 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x881 = (x809)*((uintptr_t)4294967295ULL);
x882 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x883 = (x809)*((uintptr_t)4294967295ULL);
x884 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x885 = (x809)*((uintptr_t)4294967294ULL);
x886 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967294ULL))>>64;
x887 = (x809)*((uintptr_t)4294967295ULL);
x888 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x889 = (x809)*((uintptr_t)4294967295ULL);
x890 = sizeof(intptr_t) == 4 ? ((uint64_t)(x809)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x809)*((uintptr_t)4294967295ULL))>>64;
x891 = (x888)+(x885);
x892 = (x891)<(x888);
x893 = (x892)+(x886);
x894 = (x893)<(x886);
x895 = (x893)+(x883);
x896 = (x895)<(x883);
x897 = (x894)+(x896);
x898 = (x897)+(x884);
x899 = (x898)<(x884);
x900 = (x898)+(x881);
x901 = (x900)<(x881);
x902 = (x899)+(x901);
x903 = (x902)+(x882);
x904 = (x903)<(x882);
x905 = (x903)+(x879);
x906 = (x905)<(x879);
x907 = (x904)+(x906);
x908 = (x907)+(x880);
x909 = (x908)<(x880);
x910 = (x908)+(x877);
x911 = (x910)<(x877);
x912 = (x909)+(x911);
x913 = (x912)+(x878);
x914 = (x913)<(x878);
x915 = (x913)+(x875);
x916 = (x915)<(x875);
x917 = (x914)+(x916);
x918 = (x917)+(x876);
x919 = (x918)<(x876);
x920 = (x918)+(x873);
x921 = (x920)<(x873);
x922 = (x919)+(x921);
x923 = (x922)+(x874);
x924 = (x923)<(x874);
x925 = (x923)+(x871);
x926 = (x925)<(x871);
x927 = (x924)+(x926);
x928 = (x927)+(x872);
x929 = (x809)+(x889);
x930 = (x929)<(x809);
x931 = (x930)+(x813);
x932 = (x931)<(x813);
x933 = (x931)+(x890);
x934 = (x933)<(x890);
x935 = (x932)+(x934);
x936 = (x935)+(x818);
x937 = (x936)<(x818);
x938 = (x937)+(x823);
x939 = (x938)<(x823);
x940 = (x938)+(x887);
x941 = (x940)<(x887);
x942 = (x939)+(x941);
x943 = (x942)+(x828);
x944 = (x943)<(x828);
x945 = (x943)+(x891);
x946 = (x945)<(x891);
x947 = (x944)+(x946);
x948 = (x947)+(x833);
x949 = (x948)<(x833);
x950 = (x948)+(x895);
x951 = (x950)<(x895);
x952 = (x949)+(x951);
x953 = (x952)+(x838);
x954 = (x953)<(x838);
x955 = (x953)+(x900);
x956 = (x955)<(x900);
x957 = (x954)+(x956);
x958 = (x957)+(x843);
x959 = (x958)<(x843);
x960 = (x958)+(x905);
x961 = (x960)<(x905);
x962 = (x959)+(x961);
x963 = (x962)+(x848);
x964 = (x963)<(x848);
x965 = (x963)+(x910);
x966 = (x965)<(x910);
x967 = (x964)+(x966);
x968 = (x967)+(x853);
x969 = (x968)<(x853);
x970 = (x968)+(x915);
x971 = (x970)<(x915);
x972 = (x969)+(x971);
x973 = (x972)+(x858);
x974 = (x973)<(x858);
x975 = (x973)+(x920);
x976 = (x975)<(x920);
x977 = (x974)+(x976);
x978 = (x977)+(x863);
x979 = (x978)<(x863);
x980 = (x978)+(x925);
x981 = (x980)<(x925);
x982 = (x979)+(x981);
x983 = (x982)+(x868);
x984 = (x983)<(x868);
x985 = (x983)+(x928);
x986 = (x985)<(x928);
x987 = (x984)+(x986);
x988 = (x987)+(x870);
x989 = (x15)*(x11);
x990 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x11))>>32 : ((__uint128_t)(x15)*(x11))>>64;
x991 = (x15)*(x10);
x992 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x10))>>32 : ((__uint128_t)(x15)*(x10))>>64;
x993 = (x15)*(x9);
x994 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x9))>>32 : ((__uint128_t)(x15)*(x9))>>64;
x995 = (x15)*(x8);
x996 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x8))>>32 : ((__uint128_t)(x15)*(x8))>>64;
x997 = (x15)*(x7);
x998 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x7))>>32 : ((__uint128_t)(x15)*(x7))>>64;
x999 = (x15)*(x6);
x1000 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x6))>>32 : ((__uint128_t)(x15)*(x6))>>64;
x1001 = (x15)*(x5);
x1002 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x5))>>32 : ((__uint128_t)(x15)*(x5))>>64;
x1003 = (x15)*(x4);
x1004 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x4))>>32 : ((__uint128_t)(x15)*(x4))>>64;
x1005 = (x15)*(x3);
x1006 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x3))>>32 : ((__uint128_t)(x15)*(x3))>>64;
x1007 = (x15)*(x2);
x1008 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x2))>>32 : ((__uint128_t)(x15)*(x2))>>64;
x1009 = (x15)*(x1);
x1010 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x1))>>32 : ((__uint128_t)(x15)*(x1))>>64;
x1011 = (x15)*(x0);
x1012 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*(x0))>>32 : ((__uint128_t)(x15)*(x0))>>64;
x1013 = (x1012)+(x1009);
x1014 = (x1013)<(x1012);
x1015 = (x1014)+(x1010);
x1016 = (x1015)<(x1010);
x1017 = (x1015)+(x1007);
x1018 = (x1017)<(x1007);
x1019 = (x1016)+(x1018);
x1020 = (x1019)+(x1008);
x1021 = (x1020)<(x1008);
x1022 = (x1020)+(x1005);
x1023 = (x1022)<(x1005);
x1024 = (x1021)+(x1023);
x1025 = (x1024)+(x1006);
x1026 = (x1025)<(x1006);
x1027 = (x1025)+(x1003);
x1028 = (x1027)<(x1003);
x1029 = (x1026)+(x1028);
x1030 = (x1029)+(x1004);
x1031 = (x1030)<(x1004);
x1032 = (x1030)+(x1001);
x1033 = (x1032)<(x1001);
x1034 = (x1031)+(x1033);
x1035 = (x1034)+(x1002);
x1036 = (x1035)<(x1002);
x1037 = (x1035)+(x999);
x1038 = (x1037)<(x999);
x1039 = (x1036)+(x1038);
x1040 = (x1039)+(x1000);
x1041 = (x1040)<(x1000);
x1042 = (x1040)+(x997);
x1043 = (x1042)<(x997);
x1044 = (x1041)+(x1043);
x1045 = (x1044)+(x998);
x1046 = (x1045)<(x998);
x1047 = (x1045)+(x995);
x1048 = (x1047)<(x995);
x1049 = (x1046)+(x1048);
x1050 = (x1049)+(x996);
x1051 = (x1050)<(x996);
x1052 = (x1050)+(x993);
x1053 = (x1052)<(x993);
x1054 = (x1051)+(x1053);
x1055 = (x1054)+(x994);
x1056 = (x1055)<(x994);
x1057 = (x1055)+(x991);
x1058 = (x1057)<(x991);
x1059 = (x1056)+(x1058);
x1060 = (x1059)+(x992);
x1061 = (x1060)<(x992);
x1062 = (x1060)+(x989);
x1063 = (x1062)<(x989);
x1064 = (x1061)+(x1063);
x1065 = (x1064)+(x990);
x1066 = (x933)+(x1011);
x1067 = (x1066)<(x933);
x1068 = (x1067)+(x936);
x1069 = (x1068)<(x936);
x1070 = (x1068)+(x1013);
x1071 = (x1070)<(x1013);
x1072 = (x1069)+(x1071);
x1073 = (x1072)+(x940);
x1074 = (x1073)<(x940);
x1075 = (x1073)+(x1017);
x1076 = (x1075)<(x1017);
x1077 = (x1074)+(x1076);
x1078 = (x1077)+(x945);
x1079 = (x1078)<(x945);
x1080 = (x1078)+(x1022);
x1081 = (x1080)<(x1022);
x1082 = (x1079)+(x1081);
x1083 = (x1082)+(x950);
x1084 = (x1083)<(x950);
x1085 = (x1083)+(x1027);
x1086 = (x1085)<(x1027);
x1087 = (x1084)+(x1086);
x1088 = (x1087)+(x955);
x1089 = (x1088)<(x955);
x1090 = (x1088)+(x1032);
x1091 = (x1090)<(x1032);
x1092 = (x1089)+(x1091);
x1093 = (x1092)+(x960);
x1094 = (x1093)<(x960);
x1095 = (x1093)+(x1037);
x1096 = (x1095)<(x1037);
x1097 = (x1094)+(x1096);
x1098 = (x1097)+(x965);
x1099 = (x1098)<(x965);
x1100 = (x1098)+(x1042);
x1101 = (x1100)<(x1042);
x1102 = (x1099)+(x1101);
x1103 = (x1102)+(x970);
x1104 = (x1103)<(x970);
x1105 = (x1103)+(x1047);
x1106 = (x1105)<(x1047);
x1107 = (x1104)+(x1106);
x1108 = (x1107)+(x975);
x1109 = (x1108)<(x975);
x1110 = (x1108)+(x1052);
x1111 = (x1110)<(x1052);
x1112 = (x1109)+(x1111);
x1113 = (x1112)+(x980);
x1114 = (x1113)<(x980);
x1115 = (x1113)+(x1057);
x1116 = (x1115)<(x1057);
x1117 = (x1114)+(x1116);
x1118 = (x1117)+(x985);
x1119 = (x1118)<(x985);
x1120 = (x1118)+(x1062);
x1121 = (x1120)<(x1062);
x1122 = (x1119)+(x1121);
x1123 = (x1122)+(x988);
x1124 = (x1123)<(x988);
x1125 = (x1123)+(x1065);
x1126 = (x1125)<(x1065);
x1127 = (x1124)+(x1126);
x1128 = (x1066)*((uintptr_t)4294967295ULL);
x1129 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1130 = (x1066)*((uintptr_t)4294967295ULL);
x1131 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1132 = (x1066)*((uintptr_t)4294967295ULL);
x1133 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1134 = (x1066)*((uintptr_t)4294967295ULL);
x1135 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1136 = (x1066)*((uintptr_t)4294967295ULL);
x1137 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1138 = (x1066)*((uintptr_t)4294967295ULL);
x1139 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1140 = (x1066)*((uintptr_t)4294967295ULL);
x1141 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1142 = (x1066)*((uintptr_t)4294967294ULL);
x1143 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967294ULL))>>64;
x1144 = (x1066)*((uintptr_t)4294967295ULL);
x1145 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1146 = (x1066)*((uintptr_t)4294967295ULL);
x1147 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1066)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1066)*((uintptr_t)4294967295ULL))>>64;
x1148 = (x1145)+(x1142);
x1149 = (x1148)<(x1145);
x1150 = (x1149)+(x1143);
x1151 = (x1150)<(x1143);
x1152 = (x1150)+(x1140);
x1153 = (x1152)<(x1140);
x1154 = (x1151)+(x1153);
x1155 = (x1154)+(x1141);
x1156 = (x1155)<(x1141);
x1157 = (x1155)+(x1138);
x1158 = (x1157)<(x1138);
x1159 = (x1156)+(x1158);
x1160 = (x1159)+(x1139);
x1161 = (x1160)<(x1139);
x1162 = (x1160)+(x1136);
x1163 = (x1162)<(x1136);
x1164 = (x1161)+(x1163);
x1165 = (x1164)+(x1137);
x1166 = (x1165)<(x1137);
x1167 = (x1165)+(x1134);
x1168 = (x1167)<(x1134);
x1169 = (x1166)+(x1168);
x1170 = (x1169)+(x1135);
x1171 = (x1170)<(x1135);
x1172 = (x1170)+(x1132);
x1173 = (x1172)<(x1132);
x1174 = (x1171)+(x1173);
x1175 = (x1174)+(x1133);
x1176 = (x1175)<(x1133);
x1177 = (x1175)+(x1130);
x1178 = (x1177)<(x1130);
x1179 = (x1176)+(x1178);
x1180 = (x1179)+(x1131);
x1181 = (x1180)<(x1131);
x1182 = (x1180)+(x1128);
x1183 = (x1182)<(x1128);
x1184 = (x1181)+(x1183);
x1185 = (x1184)+(x1129);
x1186 = (x1066)+(x1146);
x1187 = (x1186)<(x1066);
x1188 = (x1187)+(x1070);
x1189 = (x1188)<(x1070);
x1190 = (x1188)+(x1147);
x1191 = (x1190)<(x1147);
x1192 = (x1189)+(x1191);
x1193 = (x1192)+(x1075);
x1194 = (x1193)<(x1075);
x1195 = (x1194)+(x1080);
x1196 = (x1195)<(x1080);
x1197 = (x1195)+(x1144);
x1198 = (x1197)<(x1144);
x1199 = (x1196)+(x1198);
x1200 = (x1199)+(x1085);
x1201 = (x1200)<(x1085);
x1202 = (x1200)+(x1148);
x1203 = (x1202)<(x1148);
x1204 = (x1201)+(x1203);
x1205 = (x1204)+(x1090);
x1206 = (x1205)<(x1090);
x1207 = (x1205)+(x1152);
x1208 = (x1207)<(x1152);
x1209 = (x1206)+(x1208);
x1210 = (x1209)+(x1095);
x1211 = (x1210)<(x1095);
x1212 = (x1210)+(x1157);
x1213 = (x1212)<(x1157);
x1214 = (x1211)+(x1213);
x1215 = (x1214)+(x1100);
x1216 = (x1215)<(x1100);
x1217 = (x1215)+(x1162);
x1218 = (x1217)<(x1162);
x1219 = (x1216)+(x1218);
x1220 = (x1219)+(x1105);
x1221 = (x1220)<(x1105);
x1222 = (x1220)+(x1167);
x1223 = (x1222)<(x1167);
x1224 = (x1221)+(x1223);
x1225 = (x1224)+(x1110);
x1226 = (x1225)<(x1110);
x1227 = (x1225)+(x1172);
x1228 = (x1227)<(x1172);
x1229 = (x1226)+(x1228);
x1230 = (x1229)+(x1115);
x1231 = (x1230)<(x1115);
x1232 = (x1230)+(x1177);
x1233 = (x1232)<(x1177);
x1234 = (x1231)+(x1233);
x1235 = (x1234)+(x1120);
x1236 = (x1235)<(x1120);
x1237 = (x1235)+(x1182);
x1238 = (x1237)<(x1182);
x1239 = (x1236)+(x1238);
x1240 = (x1239)+(x1125);
x1241 = (x1240)<(x1125);
x1242 = (x1240)+(x1185);
x1243 = (x1242)<(x1185);
x1244 = (x1241)+(x1243);
x1245 = (x1244)+(x1127);
x1246 = (x16)*(x11);
x1247 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x11))>>32 : ((__uint128_t)(x16)*(x11))>>64;
x1248 = (x16)*(x10);
x1249 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x10))>>32 : ((__uint128_t)(x16)*(x10))>>64;
x1250 = (x16)*(x9);
x1251 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x9))>>32 : ((__uint128_t)(x16)*(x9))>>64;
x1252 = (x16)*(x8);
x1253 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x8))>>32 : ((__uint128_t)(x16)*(x8))>>64;
x1254 = (x16)*(x7);
x1255 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x7))>>32 : ((__uint128_t)(x16)*(x7))>>64;
x1256 = (x16)*(x6);
x1257 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x6))>>32 : ((__uint128_t)(x16)*(x6))>>64;
x1258 = (x16)*(x5);
x1259 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x5))>>32 : ((__uint128_t)(x16)*(x5))>>64;
x1260 = (x16)*(x4);
x1261 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x4))>>32 : ((__uint128_t)(x16)*(x4))>>64;
x1262 = (x16)*(x3);
x1263 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x3))>>32 : ((__uint128_t)(x16)*(x3))>>64;
x1264 = (x16)*(x2);
x1265 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x2))>>32 : ((__uint128_t)(x16)*(x2))>>64;
x1266 = (x16)*(x1);
x1267 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x1))>>32 : ((__uint128_t)(x16)*(x1))>>64;
x1268 = (x16)*(x0);
x1269 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*(x0))>>32 : ((__uint128_t)(x16)*(x0))>>64;
x1270 = (x1269)+(x1266);
x1271 = (x1270)<(x1269);
x1272 = (x1271)+(x1267);
x1273 = (x1272)<(x1267);
x1274 = (x1272)+(x1264);
x1275 = (x1274)<(x1264);
x1276 = (x1273)+(x1275);
x1277 = (x1276)+(x1265);
x1278 = (x1277)<(x1265);
x1279 = (x1277)+(x1262);
x1280 = (x1279)<(x1262);
x1281 = (x1278)+(x1280);
x1282 = (x1281)+(x1263);
x1283 = (x1282)<(x1263);
x1284 = (x1282)+(x1260);
x1285 = (x1284)<(x1260);
x1286 = (x1283)+(x1285);
x1287 = (x1286)+(x1261);
x1288 = (x1287)<(x1261);
x1289 = (x1287)+(x1258);
x1290 = (x1289)<(x1258);
x1291 = (x1288)+(x1290);
x1292 = (x1291)+(x1259);
x1293 = (x1292)<(x1259);
x1294 = (x1292)+(x1256);
x1295 = (x1294)<(x1256);
x1296 = (x1293)+(x1295);
x1297 = (x1296)+(x1257);
x1298 = (x1297)<(x1257);
x1299 = (x1297)+(x1254);
x1300 = (x1299)<(x1254);
x1301 = (x1298)+(x1300);
x1302 = (x1301)+(x1255);
x1303 = (x1302)<(x1255);
x1304 = (x1302)+(x1252);
x1305 = (x1304)<(x1252);
x1306 = (x1303)+(x1305);
x1307 = (x1306)+(x1253);
x1308 = (x1307)<(x1253);
x1309 = (x1307)+(x1250);
x1310 = (x1309)<(x1250);
x1311 = (x1308)+(x1310);
x1312 = (x1311)+(x1251);
x1313 = (x1312)<(x1251);
x1314 = (x1312)+(x1248);
x1315 = (x1314)<(x1248);
x1316 = (x1313)+(x1315);
x1317 = (x1316)+(x1249);
x1318 = (x1317)<(x1249);
x1319 = (x1317)+(x1246);
x1320 = (x1319)<(x1246);
x1321 = (x1318)+(x1320);
x1322 = (x1321)+(x1247);
x1323 = (x1190)+(x1268);
x1324 = (x1323)<(x1190);
x1325 = (x1324)+(x1193);
x1326 = (x1325)<(x1193);
x1327 = (x1325)+(x1270);
x1328 = (x1327)<(x1270);
x1329 = (x1326)+(x1328);
x1330 = (x1329)+(x1197);
x1331 = (x1330)<(x1197);
x1332 = (x1330)+(x1274);
x1333 = (x1332)<(x1274);
x1334 = (x1331)+(x1333);
x1335 = (x1334)+(x1202);
x1336 = (x1335)<(x1202);
x1337 = (x1335)+(x1279);
x1338 = (x1337)<(x1279);
x1339 = (x1336)+(x1338);
x1340 = (x1339)+(x1207);
x1341 = (x1340)<(x1207);
x1342 = (x1340)+(x1284);
x1343 = (x1342)<(x1284);
x1344 = (x1341)+(x1343);
x1345 = (x1344)+(x1212);
x1346 = (x1345)<(x1212);
x1347 = (x1345)+(x1289);
x1348 = (x1347)<(x1289);
x1349 = (x1346)+(x1348);
x1350 = (x1349)+(x1217);
x1351 = (x1350)<(x1217);
x1352 = (x1350)+(x1294);
x1353 = (x1352)<(x1294);
x1354 = (x1351)+(x1353);
x1355 = (x1354)+(x1222);
x1356 = (x1355)<(x1222);
x1357 = (x1355)+(x1299);
x1358 = (x1357)<(x1299);
x1359 = (x1356)+(x1358);
x1360 = (x1359)+(x1227);
x1361 = (x1360)<(x1227);
x1362 = (x1360)+(x1304);
x1363 = (x1362)<(x1304);
x1364 = (x1361)+(x1363);
x1365 = (x1364)+(x1232);
x1366 = (x1365)<(x1232);
x1367 = (x1365)+(x1309);
x1368 = (x1367)<(x1309);
x1369 = (x1366)+(x1368);
x1370 = (x1369)+(x1237);
x1371 = (x1370)<(x1237);
x1372 = (x1370)+(x1314);
x1373 = (x1372)<(x1314);
x1374 = (x1371)+(x1373);
x1375 = (x1374)+(x1242);
x1376 = (x1375)<(x1242);
x1377 = (x1375)+(x1319);
x1378 = (x1377)<(x1319);
x1379 = (x1376)+(x1378);
x1380 = (x1379)+(x1245);
x1381 = (x1380)<(x1245);
x1382 = (x1380)+(x1322);
x1383 = (x1382)<(x1322);
x1384 = (x1381)+(x1383);
x1385 = (x1323)*((uintptr_t)4294967295ULL);
x1386 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1387 = (x1323)*((uintptr_t)4294967295ULL);
x1388 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1389 = (x1323)*((uintptr_t)4294967295ULL);
x1390 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1391 = (x1323)*((uintptr_t)4294967295ULL);
x1392 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1393 = (x1323)*((uintptr_t)4294967295ULL);
x1394 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1395 = (x1323)*((uintptr_t)4294967295ULL);
x1396 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1397 = (x1323)*((uintptr_t)4294967295ULL);
x1398 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1399 = (x1323)*((uintptr_t)4294967294ULL);
x1400 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967294ULL))>>64;
x1401 = (x1323)*((uintptr_t)4294967295ULL);
x1402 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1403 = (x1323)*((uintptr_t)4294967295ULL);
x1404 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1323)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1323)*((uintptr_t)4294967295ULL))>>64;
x1405 = (x1402)+(x1399);
x1406 = (x1405)<(x1402);
x1407 = (x1406)+(x1400);
x1408 = (x1407)<(x1400);
x1409 = (x1407)+(x1397);
x1410 = (x1409)<(x1397);
x1411 = (x1408)+(x1410);
x1412 = (x1411)+(x1398);
x1413 = (x1412)<(x1398);
x1414 = (x1412)+(x1395);
x1415 = (x1414)<(x1395);
x1416 = (x1413)+(x1415);
x1417 = (x1416)+(x1396);
x1418 = (x1417)<(x1396);
x1419 = (x1417)+(x1393);
x1420 = (x1419)<(x1393);
x1421 = (x1418)+(x1420);
x1422 = (x1421)+(x1394);
x1423 = (x1422)<(x1394);
x1424 = (x1422)+(x1391);
x1425 = (x1424)<(x1391);
x1426 = (x1423)+(x1425);
x1427 = (x1426)+(x1392);
x1428 = (x1427)<(x1392);
x1429 = (x1427)+(x1389);
x1430 = (x1429)<(x1389);
x1431 = (x1428)+(x1430);
x1432 = (x1431)+(x1390);
x1433 = (x1432)<(x1390);
x1434 = (x1432)+(x1387);
x1435 = (x1434)<(x1387);
x1436 = (x1433)+(x1435);
x1437 = (x1436)+(x1388);
x1438 = (x1437)<(x1388);
x1439 = (x1437)+(x1385);
x1440 = (x1439)<(x1385);
x1441 = (x1438)+(x1440);
x1442 = (x1441)+(x1386);
x1443 = (x1323)+(x1403);
x1444 = (x1443)<(x1323);
x1445 = (x1444)+(x1327);
x1446 = (x1445)<(x1327);
x1447 = (x1445)+(x1404);
x1448 = (x1447)<(x1404);
x1449 = (x1446)+(x1448);
x1450 = (x1449)+(x1332);
x1451 = (x1450)<(x1332);
x1452 = (x1451)+(x1337);
x1453 = (x1452)<(x1337);
x1454 = (x1452)+(x1401);
x1455 = (x1454)<(x1401);
x1456 = (x1453)+(x1455);
x1457 = (x1456)+(x1342);
x1458 = (x1457)<(x1342);
x1459 = (x1457)+(x1405);
x1460 = (x1459)<(x1405);
x1461 = (x1458)+(x1460);
x1462 = (x1461)+(x1347);
x1463 = (x1462)<(x1347);
x1464 = (x1462)+(x1409);
x1465 = (x1464)<(x1409);
x1466 = (x1463)+(x1465);
x1467 = (x1466)+(x1352);
x1468 = (x1467)<(x1352);
x1469 = (x1467)+(x1414);
x1470 = (x1469)<(x1414);
x1471 = (x1468)+(x1470);
x1472 = (x1471)+(x1357);
x1473 = (x1472)<(x1357);
x1474 = (x1472)+(x1419);
x1475 = (x1474)<(x1419);
x1476 = (x1473)+(x1475);
x1477 = (x1476)+(x1362);
x1478 = (x1477)<(x1362);
x1479 = (x1477)+(x1424);
x1480 = (x1479)<(x1424);
x1481 = (x1478)+(x1480);
x1482 = (x1481)+(x1367);
x1483 = (x1482)<(x1367);
x1484 = (x1482)+(x1429);
x1485 = (x1484)<(x1429);
x1486 = (x1483)+(x1485);
x1487 = (x1486)+(x1372);
x1488 = (x1487)<(x1372);
x1489 = (x1487)+(x1434);
x1490 = (x1489)<(x1434);
x1491 = (x1488)+(x1490);
x1492 = (x1491)+(x1377);
x1493 = (x1492)<(x1377);
x1494 = (x1492)+(x1439);
x1495 = (x1494)<(x1439);
x1496 = (x1493)+(x1495);
x1497 = (x1496)+(x1382);
x1498 = (x1497)<(x1382);
x1499 = (x1497)+(x1442);
x1500 = (x1499)<(x1442);
x1501 = (x1498)+(x1500);
x1502 = (x1501)+(x1384);
x1503 = (x17)*(x11);
x1504 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x11))>>32 : ((__uint128_t)(x17)*(x11))>>64;
x1505 = (x17)*(x10);
x1506 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x10))>>32 : ((__uint128_t)(x17)*(x10))>>64;
x1507 = (x17)*(x9);
x1508 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x9))>>32 : ((__uint128_t)(x17)*(x9))>>64;
x1509 = (x17)*(x8);
x1510 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x8))>>32 : ((__uint128_t)(x17)*(x8))>>64;
x1511 = (x17)*(x7);
x1512 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x7))>>32 : ((__uint128_t)(x17)*(x7))>>64;
x1513 = (x17)*(x6);
x1514 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x6))>>32 : ((__uint128_t)(x17)*(x6))>>64;
x1515 = (x17)*(x5);
x1516 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x5))>>32 : ((__uint128_t)(x17)*(x5))>>64;
x1517 = (x17)*(x4);
x1518 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x4))>>32 : ((__uint128_t)(x17)*(x4))>>64;
x1519 = (x17)*(x3);
x1520 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x3))>>32 : ((__uint128_t)(x17)*(x3))>>64;
x1521 = (x17)*(x2);
x1522 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x2))>>32 : ((__uint128_t)(x17)*(x2))>>64;
x1523 = (x17)*(x1);
x1524 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x1))>>32 : ((__uint128_t)(x17)*(x1))>>64;
x1525 = (x17)*(x0);
x1526 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*(x0))>>32 : ((__uint128_t)(x17)*(x0))>>64;
x1527 = (x1526)+(x1523);
x1528 = (x1527)<(x1526);
x1529 = (x1528)+(x1524);
x1530 = (x1529)<(x1524);
x1531 = (x1529)+(x1521);
x1532 = (x1531)<(x1521);
x1533 = (x1530)+(x1532);
x1534 = (x1533)+(x1522);
x1535 = (x1534)<(x1522);
x1536 = (x1534)+(x1519);
x1537 = (x1536)<(x1519);
x1538 = (x1535)+(x1537);
x1539 = (x1538)+(x1520);
x1540 = (x1539)<(x1520);
x1541 = (x1539)+(x1517);
x1542 = (x1541)<(x1517);
x1543 = (x1540)+(x1542);
x1544 = (x1543)+(x1518);
x1545 = (x1544)<(x1518);
x1546 = (x1544)+(x1515);
x1547 = (x1546)<(x1515);
x1548 = (x1545)+(x1547);
x1549 = (x1548)+(x1516);
x1550 = (x1549)<(x1516);
x1551 = (x1549)+(x1513);
x1552 = (x1551)<(x1513);
x1553 = (x1550)+(x1552);
x1554 = (x1553)+(x1514);
x1555 = (x1554)<(x1514);
x1556 = (x1554)+(x1511);
x1557 = (x1556)<(x1511);
x1558 = (x1555)+(x1557);
x1559 = (x1558)+(x1512);
x1560 = (x1559)<(x1512);
x1561 = (x1559)+(x1509);
x1562 = (x1561)<(x1509);
x1563 = (x1560)+(x1562);
x1564 = (x1563)+(x1510);
x1565 = (x1564)<(x1510);
x1566 = (x1564)+(x1507);
x1567 = (x1566)<(x1507);
x1568 = (x1565)+(x1567);
x1569 = (x1568)+(x1508);
x1570 = (x1569)<(x1508);
x1571 = (x1569)+(x1505);
x1572 = (x1571)<(x1505);
x1573 = (x1570)+(x1572);
x1574 = (x1573)+(x1506);
x1575 = (x1574)<(x1506);
x1576 = (x1574)+(x1503);
x1577 = (x1576)<(x1503);
x1578 = (x1575)+(x1577);
x1579 = (x1578)+(x1504);
x1580 = (x1447)+(x1525);
x1581 = (x1580)<(x1447);
x1582 = (x1581)+(x1450);
x1583 = (x1582)<(x1450);
x1584 = (x1582)+(x1527);
x1585 = (x1584)<(x1527);
x1586 = (x1583)+(x1585);
x1587 = (x1586)+(x1454);
x1588 = (x1587)<(x1454);
x1589 = (x1587)+(x1531);
x1590 = (x1589)<(x1531);
x1591 = (x1588)+(x1590);
x1592 = (x1591)+(x1459);
x1593 = (x1592)<(x1459);
x1594 = (x1592)+(x1536);
x1595 = (x1594)<(x1536);
x1596 = (x1593)+(x1595);
x1597 = (x1596)+(x1464);
x1598 = (x1597)<(x1464);
x1599 = (x1597)+(x1541);
x1600 = (x1599)<(x1541);
x1601 = (x1598)+(x1600);
x1602 = (x1601)+(x1469);
x1603 = (x1602)<(x1469);
x1604 = (x1602)+(x1546);
x1605 = (x1604)<(x1546);
x1606 = (x1603)+(x1605);
x1607 = (x1606)+(x1474);
x1608 = (x1607)<(x1474);
x1609 = (x1607)+(x1551);
x1610 = (x1609)<(x1551);
x1611 = (x1608)+(x1610);
x1612 = (x1611)+(x1479);
x1613 = (x1612)<(x1479);
x1614 = (x1612)+(x1556);
x1615 = (x1614)<(x1556);
x1616 = (x1613)+(x1615);
x1617 = (x1616)+(x1484);
x1618 = (x1617)<(x1484);
x1619 = (x1617)+(x1561);
x1620 = (x1619)<(x1561);
x1621 = (x1618)+(x1620);
x1622 = (x1621)+(x1489);
x1623 = (x1622)<(x1489);
x1624 = (x1622)+(x1566);
x1625 = (x1624)<(x1566);
x1626 = (x1623)+(x1625);
x1627 = (x1626)+(x1494);
x1628 = (x1627)<(x1494);
x1629 = (x1627)+(x1571);
x1630 = (x1629)<(x1571);
x1631 = (x1628)+(x1630);
x1632 = (x1631)+(x1499);
x1633 = (x1632)<(x1499);
x1634 = (x1632)+(x1576);
x1635 = (x1634)<(x1576);
x1636 = (x1633)+(x1635);
x1637 = (x1636)+(x1502);
x1638 = (x1637)<(x1502);
x1639 = (x1637)+(x1579);
x1640 = (x1639)<(x1579);
x1641 = (x1638)+(x1640);
x1642 = (x1580)*((uintptr_t)4294967295ULL);
x1643 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1644 = (x1580)*((uintptr_t)4294967295ULL);
x1645 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1646 = (x1580)*((uintptr_t)4294967295ULL);
x1647 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1648 = (x1580)*((uintptr_t)4294967295ULL);
x1649 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1650 = (x1580)*((uintptr_t)4294967295ULL);
x1651 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1652 = (x1580)*((uintptr_t)4294967295ULL);
x1653 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1654 = (x1580)*((uintptr_t)4294967295ULL);
x1655 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1656 = (x1580)*((uintptr_t)4294967294ULL);
x1657 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967294ULL))>>64;
x1658 = (x1580)*((uintptr_t)4294967295ULL);
x1659 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1660 = (x1580)*((uintptr_t)4294967295ULL);
x1661 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1580)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1580)*((uintptr_t)4294967295ULL))>>64;
x1662 = (x1659)+(x1656);
x1663 = (x1662)<(x1659);
x1664 = (x1663)+(x1657);
x1665 = (x1664)<(x1657);
x1666 = (x1664)+(x1654);
x1667 = (x1666)<(x1654);
x1668 = (x1665)+(x1667);
x1669 = (x1668)+(x1655);
x1670 = (x1669)<(x1655);
x1671 = (x1669)+(x1652);
x1672 = (x1671)<(x1652);
x1673 = (x1670)+(x1672);
x1674 = (x1673)+(x1653);
x1675 = (x1674)<(x1653);
x1676 = (x1674)+(x1650);
x1677 = (x1676)<(x1650);
x1678 = (x1675)+(x1677);
x1679 = (x1678)+(x1651);
x1680 = (x1679)<(x1651);
x1681 = (x1679)+(x1648);
x1682 = (x1681)<(x1648);
x1683 = (x1680)+(x1682);
x1684 = (x1683)+(x1649);
x1685 = (x1684)<(x1649);
x1686 = (x1684)+(x1646);
x1687 = (x1686)<(x1646);
x1688 = (x1685)+(x1687);
x1689 = (x1688)+(x1647);
x1690 = (x1689)<(x1647);
x1691 = (x1689)+(x1644);
x1692 = (x1691)<(x1644);
x1693 = (x1690)+(x1692);
x1694 = (x1693)+(x1645);
x1695 = (x1694)<(x1645);
x1696 = (x1694)+(x1642);
x1697 = (x1696)<(x1642);
x1698 = (x1695)+(x1697);
x1699 = (x1698)+(x1643);
x1700 = (x1580)+(x1660);
x1701 = (x1700)<(x1580);
x1702 = (x1701)+(x1584);
x1703 = (x1702)<(x1584);
x1704 = (x1702)+(x1661);
x1705 = (x1704)<(x1661);
x1706 = (x1703)+(x1705);
x1707 = (x1706)+(x1589);
x1708 = (x1707)<(x1589);
x1709 = (x1708)+(x1594);
x1710 = (x1709)<(x1594);
x1711 = (x1709)+(x1658);
x1712 = (x1711)<(x1658);
x1713 = (x1710)+(x1712);
x1714 = (x1713)+(x1599);
x1715 = (x1714)<(x1599);
x1716 = (x1714)+(x1662);
x1717 = (x1716)<(x1662);
x1718 = (x1715)+(x1717);
x1719 = (x1718)+(x1604);
x1720 = (x1719)<(x1604);
x1721 = (x1719)+(x1666);
x1722 = (x1721)<(x1666);
x1723 = (x1720)+(x1722);
x1724 = (x1723)+(x1609);
x1725 = (x1724)<(x1609);
x1726 = (x1724)+(x1671);
x1727 = (x1726)<(x1671);
x1728 = (x1725)+(x1727);
x1729 = (x1728)+(x1614);
x1730 = (x1729)<(x1614);
x1731 = (x1729)+(x1676);
x1732 = (x1731)<(x1676);
x1733 = (x1730)+(x1732);
x1734 = (x1733)+(x1619);
x1735 = (x1734)<(x1619);
x1736 = (x1734)+(x1681);
x1737 = (x1736)<(x1681);
x1738 = (x1735)+(x1737);
x1739 = (x1738)+(x1624);
x1740 = (x1739)<(x1624);
x1741 = (x1739)+(x1686);
x1742 = (x1741)<(x1686);
x1743 = (x1740)+(x1742);
x1744 = (x1743)+(x1629);
x1745 = (x1744)<(x1629);
x1746 = (x1744)+(x1691);
x1747 = (x1746)<(x1691);
x1748 = (x1745)+(x1747);
x1749 = (x1748)+(x1634);
x1750 = (x1749)<(x1634);
x1751 = (x1749)+(x1696);
x1752 = (x1751)<(x1696);
x1753 = (x1750)+(x1752);
x1754 = (x1753)+(x1639);
x1755 = (x1754)<(x1639);
x1756 = (x1754)+(x1699);
x1757 = (x1756)<(x1699);
x1758 = (x1755)+(x1757);
x1759 = (x1758)+(x1641);
x1760 = (x18)*(x11);
x1761 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x11))>>32 : ((__uint128_t)(x18)*(x11))>>64;
x1762 = (x18)*(x10);
x1763 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x10))>>32 : ((__uint128_t)(x18)*(x10))>>64;
x1764 = (x18)*(x9);
x1765 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x9))>>32 : ((__uint128_t)(x18)*(x9))>>64;
x1766 = (x18)*(x8);
x1767 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x8))>>32 : ((__uint128_t)(x18)*(x8))>>64;
x1768 = (x18)*(x7);
x1769 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x7))>>32 : ((__uint128_t)(x18)*(x7))>>64;
x1770 = (x18)*(x6);
x1771 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x6))>>32 : ((__uint128_t)(x18)*(x6))>>64;
x1772 = (x18)*(x5);
x1773 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x5))>>32 : ((__uint128_t)(x18)*(x5))>>64;
x1774 = (x18)*(x4);
x1775 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x4))>>32 : ((__uint128_t)(x18)*(x4))>>64;
x1776 = (x18)*(x3);
x1777 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x3))>>32 : ((__uint128_t)(x18)*(x3))>>64;
x1778 = (x18)*(x2);
x1779 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x2))>>32 : ((__uint128_t)(x18)*(x2))>>64;
x1780 = (x18)*(x1);
x1781 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x1))>>32 : ((__uint128_t)(x18)*(x1))>>64;
x1782 = (x18)*(x0);
x1783 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*(x0))>>32 : ((__uint128_t)(x18)*(x0))>>64;
x1784 = (x1783)+(x1780);
x1785 = (x1784)<(x1783);
x1786 = (x1785)+(x1781);
x1787 = (x1786)<(x1781);
x1788 = (x1786)+(x1778);
x1789 = (x1788)<(x1778);
x1790 = (x1787)+(x1789);
x1791 = (x1790)+(x1779);
x1792 = (x1791)<(x1779);
x1793 = (x1791)+(x1776);
x1794 = (x1793)<(x1776);
x1795 = (x1792)+(x1794);
x1796 = (x1795)+(x1777);
x1797 = (x1796)<(x1777);
x1798 = (x1796)+(x1774);
x1799 = (x1798)<(x1774);
x1800 = (x1797)+(x1799);
x1801 = (x1800)+(x1775);
x1802 = (x1801)<(x1775);
x1803 = (x1801)+(x1772);
x1804 = (x1803)<(x1772);
x1805 = (x1802)+(x1804);
x1806 = (x1805)+(x1773);
x1807 = (x1806)<(x1773);
x1808 = (x1806)+(x1770);
x1809 = (x1808)<(x1770);
x1810 = (x1807)+(x1809);
x1811 = (x1810)+(x1771);
x1812 = (x1811)<(x1771);
x1813 = (x1811)+(x1768);
x1814 = (x1813)<(x1768);
x1815 = (x1812)+(x1814);
x1816 = (x1815)+(x1769);
x1817 = (x1816)<(x1769);
x1818 = (x1816)+(x1766);
x1819 = (x1818)<(x1766);
x1820 = (x1817)+(x1819);
x1821 = (x1820)+(x1767);
x1822 = (x1821)<(x1767);
x1823 = (x1821)+(x1764);
x1824 = (x1823)<(x1764);
x1825 = (x1822)+(x1824);
x1826 = (x1825)+(x1765);
x1827 = (x1826)<(x1765);
x1828 = (x1826)+(x1762);
x1829 = (x1828)<(x1762);
x1830 = (x1827)+(x1829);
x1831 = (x1830)+(x1763);
x1832 = (x1831)<(x1763);
x1833 = (x1831)+(x1760);
x1834 = (x1833)<(x1760);
x1835 = (x1832)+(x1834);
x1836 = (x1835)+(x1761);
x1837 = (x1704)+(x1782);
x1838 = (x1837)<(x1704);
x1839 = (x1838)+(x1707);
x1840 = (x1839)<(x1707);
x1841 = (x1839)+(x1784);
x1842 = (x1841)<(x1784);
x1843 = (x1840)+(x1842);
x1844 = (x1843)+(x1711);
x1845 = (x1844)<(x1711);
x1846 = (x1844)+(x1788);
x1847 = (x1846)<(x1788);
x1848 = (x1845)+(x1847);
x1849 = (x1848)+(x1716);
x1850 = (x1849)<(x1716);
x1851 = (x1849)+(x1793);
x1852 = (x1851)<(x1793);
x1853 = (x1850)+(x1852);
x1854 = (x1853)+(x1721);
x1855 = (x1854)<(x1721);
x1856 = (x1854)+(x1798);
x1857 = (x1856)<(x1798);
x1858 = (x1855)+(x1857);
x1859 = (x1858)+(x1726);
x1860 = (x1859)<(x1726);
x1861 = (x1859)+(x1803);
x1862 = (x1861)<(x1803);
x1863 = (x1860)+(x1862);
x1864 = (x1863)+(x1731);
x1865 = (x1864)<(x1731);
x1866 = (x1864)+(x1808);
x1867 = (x1866)<(x1808);
x1868 = (x1865)+(x1867);
x1869 = (x1868)+(x1736);
x1870 = (x1869)<(x1736);
x1871 = (x1869)+(x1813);
x1872 = (x1871)<(x1813);
x1873 = (x1870)+(x1872);
x1874 = (x1873)+(x1741);
x1875 = (x1874)<(x1741);
x1876 = (x1874)+(x1818);
x1877 = (x1876)<(x1818);
x1878 = (x1875)+(x1877);
x1879 = (x1878)+(x1746);
x1880 = (x1879)<(x1746);
x1881 = (x1879)+(x1823);
x1882 = (x1881)<(x1823);
x1883 = (x1880)+(x1882);
x1884 = (x1883)+(x1751);
x1885 = (x1884)<(x1751);
x1886 = (x1884)+(x1828);
x1887 = (x1886)<(x1828);
x1888 = (x1885)+(x1887);
x1889 = (x1888)+(x1756);
x1890 = (x1889)<(x1756);
x1891 = (x1889)+(x1833);
x1892 = (x1891)<(x1833);
x1893 = (x1890)+(x1892);
x1894 = (x1893)+(x1759);
x1895 = (x1894)<(x1759);
x1896 = (x1894)+(x1836);
x1897 = (x1896)<(x1836);
x1898 = (x1895)+(x1897);
x1899 = (x1837)*((uintptr_t)4294967295ULL);
x1900 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1901 = (x1837)*((uintptr_t)4294967295ULL);
x1902 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1903 = (x1837)*((uintptr_t)4294967295ULL);
x1904 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1905 = (x1837)*((uintptr_t)4294967295ULL);
x1906 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1907 = (x1837)*((uintptr_t)4294967295ULL);
x1908 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1909 = (x1837)*((uintptr_t)4294967295ULL);
x1910 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1911 = (x1837)*((uintptr_t)4294967295ULL);
x1912 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1913 = (x1837)*((uintptr_t)4294967294ULL);
x1914 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967294ULL))>>64;
x1915 = (x1837)*((uintptr_t)4294967295ULL);
x1916 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1917 = (x1837)*((uintptr_t)4294967295ULL);
x1918 = sizeof(intptr_t) == 4 ? ((uint64_t)(x1837)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x1837)*((uintptr_t)4294967295ULL))>>64;
x1919 = (x1916)+(x1913);
x1920 = (x1919)<(x1916);
x1921 = (x1920)+(x1914);
x1922 = (x1921)<(x1914);
x1923 = (x1921)+(x1911);
x1924 = (x1923)<(x1911);
x1925 = (x1922)+(x1924);
x1926 = (x1925)+(x1912);
x1927 = (x1926)<(x1912);
x1928 = (x1926)+(x1909);
x1929 = (x1928)<(x1909);
x1930 = (x1927)+(x1929);
x1931 = (x1930)+(x1910);
x1932 = (x1931)<(x1910);
x1933 = (x1931)+(x1907);
x1934 = (x1933)<(x1907);
x1935 = (x1932)+(x1934);
x1936 = (x1935)+(x1908);
x1937 = (x1936)<(x1908);
x1938 = (x1936)+(x1905);
x1939 = (x1938)<(x1905);
x1940 = (x1937)+(x1939);
x1941 = (x1940)+(x1906);
x1942 = (x1941)<(x1906);
x1943 = (x1941)+(x1903);
x1944 = (x1943)<(x1903);
x1945 = (x1942)+(x1944);
x1946 = (x1945)+(x1904);
x1947 = (x1946)<(x1904);
x1948 = (x1946)+(x1901);
x1949 = (x1948)<(x1901);
x1950 = (x1947)+(x1949);
x1951 = (x1950)+(x1902);
x1952 = (x1951)<(x1902);
x1953 = (x1951)+(x1899);
x1954 = (x1953)<(x1899);
x1955 = (x1952)+(x1954);
x1956 = (x1955)+(x1900);
x1957 = (x1837)+(x1917);
x1958 = (x1957)<(x1837);
x1959 = (x1958)+(x1841);
x1960 = (x1959)<(x1841);
x1961 = (x1959)+(x1918);
x1962 = (x1961)<(x1918);
x1963 = (x1960)+(x1962);
x1964 = (x1963)+(x1846);
x1965 = (x1964)<(x1846);
x1966 = (x1965)+(x1851);
x1967 = (x1966)<(x1851);
x1968 = (x1966)+(x1915);
x1969 = (x1968)<(x1915);
x1970 = (x1967)+(x1969);
x1971 = (x1970)+(x1856);
x1972 = (x1971)<(x1856);
x1973 = (x1971)+(x1919);
x1974 = (x1973)<(x1919);
x1975 = (x1972)+(x1974);
x1976 = (x1975)+(x1861);
x1977 = (x1976)<(x1861);
x1978 = (x1976)+(x1923);
x1979 = (x1978)<(x1923);
x1980 = (x1977)+(x1979);
x1981 = (x1980)+(x1866);
x1982 = (x1981)<(x1866);
x1983 = (x1981)+(x1928);
x1984 = (x1983)<(x1928);
x1985 = (x1982)+(x1984);
x1986 = (x1985)+(x1871);
x1987 = (x1986)<(x1871);
x1988 = (x1986)+(x1933);
x1989 = (x1988)<(x1933);
x1990 = (x1987)+(x1989);
x1991 = (x1990)+(x1876);
x1992 = (x1991)<(x1876);
x1993 = (x1991)+(x1938);
x1994 = (x1993)<(x1938);
x1995 = (x1992)+(x1994);
x1996 = (x1995)+(x1881);
x1997 = (x1996)<(x1881);
x1998 = (x1996)+(x1943);
x1999 = (x1998)<(x1943);
x2000 = (x1997)+(x1999);
x2001 = (x2000)+(x1886);
x2002 = (x2001)<(x1886);
x2003 = (x2001)+(x1948);
x2004 = (x2003)<(x1948);
x2005 = (x2002)+(x2004);
x2006 = (x2005)+(x1891);
x2007 = (x2006)<(x1891);
x2008 = (x2006)+(x1953);
x2009 = (x2008)<(x1953);
x2010 = (x2007)+(x2009);
x2011 = (x2010)+(x1896);
x2012 = (x2011)<(x1896);
x2013 = (x2011)+(x1956);
x2014 = (x2013)<(x1956);
x2015 = (x2012)+(x2014);
x2016 = (x2015)+(x1898);
x2017 = (x19)*(x11);
x2018 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x11))>>32 : ((__uint128_t)(x19)*(x11))>>64;
x2019 = (x19)*(x10);
x2020 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x10))>>32 : ((__uint128_t)(x19)*(x10))>>64;
x2021 = (x19)*(x9);
x2022 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x9))>>32 : ((__uint128_t)(x19)*(x9))>>64;
x2023 = (x19)*(x8);
x2024 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x8))>>32 : ((__uint128_t)(x19)*(x8))>>64;
x2025 = (x19)*(x7);
x2026 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x7))>>32 : ((__uint128_t)(x19)*(x7))>>64;
x2027 = (x19)*(x6);
x2028 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x6))>>32 : ((__uint128_t)(x19)*(x6))>>64;
x2029 = (x19)*(x5);
x2030 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x5))>>32 : ((__uint128_t)(x19)*(x5))>>64;
x2031 = (x19)*(x4);
x2032 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x4))>>32 : ((__uint128_t)(x19)*(x4))>>64;
x2033 = (x19)*(x3);
x2034 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x3))>>32 : ((__uint128_t)(x19)*(x3))>>64;
x2035 = (x19)*(x2);
x2036 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x2))>>32 : ((__uint128_t)(x19)*(x2))>>64;
x2037 = (x19)*(x1);
x2038 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x1))>>32 : ((__uint128_t)(x19)*(x1))>>64;
x2039 = (x19)*(x0);
x2040 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*(x0))>>32 : ((__uint128_t)(x19)*(x0))>>64;
x2041 = (x2040)+(x2037);
x2042 = (x2041)<(x2040);
x2043 = (x2042)+(x2038);
x2044 = (x2043)<(x2038);
x2045 = (x2043)+(x2035);
x2046 = (x2045)<(x2035);
x2047 = (x2044)+(x2046);
x2048 = (x2047)+(x2036);
x2049 = (x2048)<(x2036);
x2050 = (x2048)+(x2033);
x2051 = (x2050)<(x2033);
x2052 = (x2049)+(x2051);
x2053 = (x2052)+(x2034);
x2054 = (x2053)<(x2034);
x2055 = (x2053)+(x2031);
x2056 = (x2055)<(x2031);
x2057 = (x2054)+(x2056);
x2058 = (x2057)+(x2032);
x2059 = (x2058)<(x2032);
x2060 = (x2058)+(x2029);
x2061 = (x2060)<(x2029);
x2062 = (x2059)+(x2061);
x2063 = (x2062)+(x2030);
x2064 = (x2063)<(x2030);
x2065 = (x2063)+(x2027);
x2066 = (x2065)<(x2027);
x2067 = (x2064)+(x2066);
x2068 = (x2067)+(x2028);
x2069 = (x2068)<(x2028);
x2070 = (x2068)+(x2025);
x2071 = (x2070)<(x2025);
x2072 = (x2069)+(x2071);
x2073 = (x2072)+(x2026);
x2074 = (x2073)<(x2026);
x2075 = (x2073)+(x2023);
x2076 = (x2075)<(x2023);
x2077 = (x2074)+(x2076);
x2078 = (x2077)+(x2024);
x2079 = (x2078)<(x2024);
x2080 = (x2078)+(x2021);
x2081 = (x2080)<(x2021);
x2082 = (x2079)+(x2081);
x2083 = (x2082)+(x2022);
x2084 = (x2083)<(x2022);
x2085 = (x2083)+(x2019);
x2086 = (x2085)<(x2019);
x2087 = (x2084)+(x2086);
x2088 = (x2087)+(x2020);
x2089 = (x2088)<(x2020);
x2090 = (x2088)+(x2017);
x2091 = (x2090)<(x2017);
x2092 = (x2089)+(x2091);
x2093 = (x2092)+(x2018);
x2094 = (x1961)+(x2039);
x2095 = (x2094)<(x1961);
x2096 = (x2095)+(x1964);
x2097 = (x2096)<(x1964);
x2098 = (x2096)+(x2041);
x2099 = (x2098)<(x2041);
x2100 = (x2097)+(x2099);
x2101 = (x2100)+(x1968);
x2102 = (x2101)<(x1968);
x2103 = (x2101)+(x2045);
x2104 = (x2103)<(x2045);
x2105 = (x2102)+(x2104);
x2106 = (x2105)+(x1973);
x2107 = (x2106)<(x1973);
x2108 = (x2106)+(x2050);
x2109 = (x2108)<(x2050);
x2110 = (x2107)+(x2109);
x2111 = (x2110)+(x1978);
x2112 = (x2111)<(x1978);
x2113 = (x2111)+(x2055);
x2114 = (x2113)<(x2055);
x2115 = (x2112)+(x2114);
x2116 = (x2115)+(x1983);
x2117 = (x2116)<(x1983);
x2118 = (x2116)+(x2060);
x2119 = (x2118)<(x2060);
x2120 = (x2117)+(x2119);
x2121 = (x2120)+(x1988);
x2122 = (x2121)<(x1988);
x2123 = (x2121)+(x2065);
x2124 = (x2123)<(x2065);
x2125 = (x2122)+(x2124);
x2126 = (x2125)+(x1993);
x2127 = (x2126)<(x1993);
x2128 = (x2126)+(x2070);
x2129 = (x2128)<(x2070);
x2130 = (x2127)+(x2129);
x2131 = (x2130)+(x1998);
x2132 = (x2131)<(x1998);
x2133 = (x2131)+(x2075);
x2134 = (x2133)<(x2075);
x2135 = (x2132)+(x2134);
x2136 = (x2135)+(x2003);
x2137 = (x2136)<(x2003);
x2138 = (x2136)+(x2080);
x2139 = (x2138)<(x2080);
x2140 = (x2137)+(x2139);
x2141 = (x2140)+(x2008);
x2142 = (x2141)<(x2008);
x2143 = (x2141)+(x2085);
x2144 = (x2143)<(x2085);
x2145 = (x2142)+(x2144);
x2146 = (x2145)+(x2013);
x2147 = (x2146)<(x2013);
x2148 = (x2146)+(x2090);
x2149 = (x2148)<(x2090);
x2150 = (x2147)+(x2149);
x2151 = (x2150)+(x2016);
x2152 = (x2151)<(x2016);
x2153 = (x2151)+(x2093);
x2154 = (x2153)<(x2093);
x2155 = (x2152)+(x2154);
x2156 = (x2094)*((uintptr_t)4294967295ULL);
x2157 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2158 = (x2094)*((uintptr_t)4294967295ULL);
x2159 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2160 = (x2094)*((uintptr_t)4294967295ULL);
x2161 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2162 = (x2094)*((uintptr_t)4294967295ULL);
x2163 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2164 = (x2094)*((uintptr_t)4294967295ULL);
x2165 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2166 = (x2094)*((uintptr_t)4294967295ULL);
x2167 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2168 = (x2094)*((uintptr_t)4294967295ULL);
x2169 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2170 = (x2094)*((uintptr_t)4294967294ULL);
x2171 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967294ULL))>>64;
x2172 = (x2094)*((uintptr_t)4294967295ULL);
x2173 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2174 = (x2094)*((uintptr_t)4294967295ULL);
x2175 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2094)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2094)*((uintptr_t)4294967295ULL))>>64;
x2176 = (x2173)+(x2170);
x2177 = (x2176)<(x2173);
x2178 = (x2177)+(x2171);
x2179 = (x2178)<(x2171);
x2180 = (x2178)+(x2168);
x2181 = (x2180)<(x2168);
x2182 = (x2179)+(x2181);
x2183 = (x2182)+(x2169);
x2184 = (x2183)<(x2169);
x2185 = (x2183)+(x2166);
x2186 = (x2185)<(x2166);
x2187 = (x2184)+(x2186);
x2188 = (x2187)+(x2167);
x2189 = (x2188)<(x2167);
x2190 = (x2188)+(x2164);
x2191 = (x2190)<(x2164);
x2192 = (x2189)+(x2191);
x2193 = (x2192)+(x2165);
x2194 = (x2193)<(x2165);
x2195 = (x2193)+(x2162);
x2196 = (x2195)<(x2162);
x2197 = (x2194)+(x2196);
x2198 = (x2197)+(x2163);
x2199 = (x2198)<(x2163);
x2200 = (x2198)+(x2160);
x2201 = (x2200)<(x2160);
x2202 = (x2199)+(x2201);
x2203 = (x2202)+(x2161);
x2204 = (x2203)<(x2161);
x2205 = (x2203)+(x2158);
x2206 = (x2205)<(x2158);
x2207 = (x2204)+(x2206);
x2208 = (x2207)+(x2159);
x2209 = (x2208)<(x2159);
x2210 = (x2208)+(x2156);
x2211 = (x2210)<(x2156);
x2212 = (x2209)+(x2211);
x2213 = (x2212)+(x2157);
x2214 = (x2094)+(x2174);
x2215 = (x2214)<(x2094);
x2216 = (x2215)+(x2098);
x2217 = (x2216)<(x2098);
x2218 = (x2216)+(x2175);
x2219 = (x2218)<(x2175);
x2220 = (x2217)+(x2219);
x2221 = (x2220)+(x2103);
x2222 = (x2221)<(x2103);
x2223 = (x2222)+(x2108);
x2224 = (x2223)<(x2108);
x2225 = (x2223)+(x2172);
x2226 = (x2225)<(x2172);
x2227 = (x2224)+(x2226);
x2228 = (x2227)+(x2113);
x2229 = (x2228)<(x2113);
x2230 = (x2228)+(x2176);
x2231 = (x2230)<(x2176);
x2232 = (x2229)+(x2231);
x2233 = (x2232)+(x2118);
x2234 = (x2233)<(x2118);
x2235 = (x2233)+(x2180);
x2236 = (x2235)<(x2180);
x2237 = (x2234)+(x2236);
x2238 = (x2237)+(x2123);
x2239 = (x2238)<(x2123);
x2240 = (x2238)+(x2185);
x2241 = (x2240)<(x2185);
x2242 = (x2239)+(x2241);
x2243 = (x2242)+(x2128);
x2244 = (x2243)<(x2128);
x2245 = (x2243)+(x2190);
x2246 = (x2245)<(x2190);
x2247 = (x2244)+(x2246);
x2248 = (x2247)+(x2133);
x2249 = (x2248)<(x2133);
x2250 = (x2248)+(x2195);
x2251 = (x2250)<(x2195);
x2252 = (x2249)+(x2251);
x2253 = (x2252)+(x2138);
x2254 = (x2253)<(x2138);
x2255 = (x2253)+(x2200);
x2256 = (x2255)<(x2200);
x2257 = (x2254)+(x2256);
x2258 = (x2257)+(x2143);
x2259 = (x2258)<(x2143);
x2260 = (x2258)+(x2205);
x2261 = (x2260)<(x2205);
x2262 = (x2259)+(x2261);
x2263 = (x2262)+(x2148);
x2264 = (x2263)<(x2148);
x2265 = (x2263)+(x2210);
x2266 = (x2265)<(x2210);
x2267 = (x2264)+(x2266);
x2268 = (x2267)+(x2153);
x2269 = (x2268)<(x2153);
x2270 = (x2268)+(x2213);
x2271 = (x2270)<(x2213);
x2272 = (x2269)+(x2271);
x2273 = (x2272)+(x2155);
x2274 = (x20)*(x11);
x2275 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x11))>>32 : ((__uint128_t)(x20)*(x11))>>64;
x2276 = (x20)*(x10);
x2277 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x10))>>32 : ((__uint128_t)(x20)*(x10))>>64;
x2278 = (x20)*(x9);
x2279 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x9))>>32 : ((__uint128_t)(x20)*(x9))>>64;
x2280 = (x20)*(x8);
x2281 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x8))>>32 : ((__uint128_t)(x20)*(x8))>>64;
x2282 = (x20)*(x7);
x2283 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x7))>>32 : ((__uint128_t)(x20)*(x7))>>64;
x2284 = (x20)*(x6);
x2285 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x6))>>32 : ((__uint128_t)(x20)*(x6))>>64;
x2286 = (x20)*(x5);
x2287 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x5))>>32 : ((__uint128_t)(x20)*(x5))>>64;
x2288 = (x20)*(x4);
x2289 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x4))>>32 : ((__uint128_t)(x20)*(x4))>>64;
x2290 = (x20)*(x3);
x2291 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x3))>>32 : ((__uint128_t)(x20)*(x3))>>64;
x2292 = (x20)*(x2);
x2293 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x2))>>32 : ((__uint128_t)(x20)*(x2))>>64;
x2294 = (x20)*(x1);
x2295 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x1))>>32 : ((__uint128_t)(x20)*(x1))>>64;
x2296 = (x20)*(x0);
x2297 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*(x0))>>32 : ((__uint128_t)(x20)*(x0))>>64;
x2298 = (x2297)+(x2294);
x2299 = (x2298)<(x2297);
x2300 = (x2299)+(x2295);
x2301 = (x2300)<(x2295);
x2302 = (x2300)+(x2292);
x2303 = (x2302)<(x2292);
x2304 = (x2301)+(x2303);
x2305 = (x2304)+(x2293);
x2306 = (x2305)<(x2293);
x2307 = (x2305)+(x2290);
x2308 = (x2307)<(x2290);
x2309 = (x2306)+(x2308);
x2310 = (x2309)+(x2291);
x2311 = (x2310)<(x2291);
x2312 = (x2310)+(x2288);
x2313 = (x2312)<(x2288);
x2314 = (x2311)+(x2313);
x2315 = (x2314)+(x2289);
x2316 = (x2315)<(x2289);
x2317 = (x2315)+(x2286);
x2318 = (x2317)<(x2286);
x2319 = (x2316)+(x2318);
x2320 = (x2319)+(x2287);
x2321 = (x2320)<(x2287);
x2322 = (x2320)+(x2284);
x2323 = (x2322)<(x2284);
x2324 = (x2321)+(x2323);
x2325 = (x2324)+(x2285);
x2326 = (x2325)<(x2285);
x2327 = (x2325)+(x2282);
x2328 = (x2327)<(x2282);
x2329 = (x2326)+(x2328);
x2330 = (x2329)+(x2283);
x2331 = (x2330)<(x2283);
x2332 = (x2330)+(x2280);
x2333 = (x2332)<(x2280);
x2334 = (x2331)+(x2333);
x2335 = (x2334)+(x2281);
x2336 = (x2335)<(x2281);
x2337 = (x2335)+(x2278);
x2338 = (x2337)<(x2278);
x2339 = (x2336)+(x2338);
x2340 = (x2339)+(x2279);
x2341 = (x2340)<(x2279);
x2342 = (x2340)+(x2276);
x2343 = (x2342)<(x2276);
x2344 = (x2341)+(x2343);
x2345 = (x2344)+(x2277);
x2346 = (x2345)<(x2277);
x2347 = (x2345)+(x2274);
x2348 = (x2347)<(x2274);
x2349 = (x2346)+(x2348);
x2350 = (x2349)+(x2275);
x2351 = (x2218)+(x2296);
x2352 = (x2351)<(x2218);
x2353 = (x2352)+(x2221);
x2354 = (x2353)<(x2221);
x2355 = (x2353)+(x2298);
x2356 = (x2355)<(x2298);
x2357 = (x2354)+(x2356);
x2358 = (x2357)+(x2225);
x2359 = (x2358)<(x2225);
x2360 = (x2358)+(x2302);
x2361 = (x2360)<(x2302);
x2362 = (x2359)+(x2361);
x2363 = (x2362)+(x2230);
x2364 = (x2363)<(x2230);
x2365 = (x2363)+(x2307);
x2366 = (x2365)<(x2307);
x2367 = (x2364)+(x2366);
x2368 = (x2367)+(x2235);
x2369 = (x2368)<(x2235);
x2370 = (x2368)+(x2312);
x2371 = (x2370)<(x2312);
x2372 = (x2369)+(x2371);
x2373 = (x2372)+(x2240);
x2374 = (x2373)<(x2240);
x2375 = (x2373)+(x2317);
x2376 = (x2375)<(x2317);
x2377 = (x2374)+(x2376);
x2378 = (x2377)+(x2245);
x2379 = (x2378)<(x2245);
x2380 = (x2378)+(x2322);
x2381 = (x2380)<(x2322);
x2382 = (x2379)+(x2381);
x2383 = (x2382)+(x2250);
x2384 = (x2383)<(x2250);
x2385 = (x2383)+(x2327);
x2386 = (x2385)<(x2327);
x2387 = (x2384)+(x2386);
x2388 = (x2387)+(x2255);
x2389 = (x2388)<(x2255);
x2390 = (x2388)+(x2332);
x2391 = (x2390)<(x2332);
x2392 = (x2389)+(x2391);
x2393 = (x2392)+(x2260);
x2394 = (x2393)<(x2260);
x2395 = (x2393)+(x2337);
x2396 = (x2395)<(x2337);
x2397 = (x2394)+(x2396);
x2398 = (x2397)+(x2265);
x2399 = (x2398)<(x2265);
x2400 = (x2398)+(x2342);
x2401 = (x2400)<(x2342);
x2402 = (x2399)+(x2401);
x2403 = (x2402)+(x2270);
x2404 = (x2403)<(x2270);
x2405 = (x2403)+(x2347);
x2406 = (x2405)<(x2347);
x2407 = (x2404)+(x2406);
x2408 = (x2407)+(x2273);
x2409 = (x2408)<(x2273);
x2410 = (x2408)+(x2350);
x2411 = (x2410)<(x2350);
x2412 = (x2409)+(x2411);
x2413 = (x2351)*((uintptr_t)4294967295ULL);
x2414 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2415 = (x2351)*((uintptr_t)4294967295ULL);
x2416 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2417 = (x2351)*((uintptr_t)4294967295ULL);
x2418 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2419 = (x2351)*((uintptr_t)4294967295ULL);
x2420 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2421 = (x2351)*((uintptr_t)4294967295ULL);
x2422 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2423 = (x2351)*((uintptr_t)4294967295ULL);
x2424 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2425 = (x2351)*((uintptr_t)4294967295ULL);
x2426 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2427 = (x2351)*((uintptr_t)4294967294ULL);
x2428 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967294ULL))>>64;
x2429 = (x2351)*((uintptr_t)4294967295ULL);
x2430 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2431 = (x2351)*((uintptr_t)4294967295ULL);
x2432 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2351)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2351)*((uintptr_t)4294967295ULL))>>64;
x2433 = (x2430)+(x2427);
x2434 = (x2433)<(x2430);
x2435 = (x2434)+(x2428);
x2436 = (x2435)<(x2428);
x2437 = (x2435)+(x2425);
x2438 = (x2437)<(x2425);
x2439 = (x2436)+(x2438);
x2440 = (x2439)+(x2426);
x2441 = (x2440)<(x2426);
x2442 = (x2440)+(x2423);
x2443 = (x2442)<(x2423);
x2444 = (x2441)+(x2443);
x2445 = (x2444)+(x2424);
x2446 = (x2445)<(x2424);
x2447 = (x2445)+(x2421);
x2448 = (x2447)<(x2421);
x2449 = (x2446)+(x2448);
x2450 = (x2449)+(x2422);
x2451 = (x2450)<(x2422);
x2452 = (x2450)+(x2419);
x2453 = (x2452)<(x2419);
x2454 = (x2451)+(x2453);
x2455 = (x2454)+(x2420);
x2456 = (x2455)<(x2420);
x2457 = (x2455)+(x2417);
x2458 = (x2457)<(x2417);
x2459 = (x2456)+(x2458);
x2460 = (x2459)+(x2418);
x2461 = (x2460)<(x2418);
x2462 = (x2460)+(x2415);
x2463 = (x2462)<(x2415);
x2464 = (x2461)+(x2463);
x2465 = (x2464)+(x2416);
x2466 = (x2465)<(x2416);
x2467 = (x2465)+(x2413);
x2468 = (x2467)<(x2413);
x2469 = (x2466)+(x2468);
x2470 = (x2469)+(x2414);
x2471 = (x2351)+(x2431);
x2472 = (x2471)<(x2351);
x2473 = (x2472)+(x2355);
x2474 = (x2473)<(x2355);
x2475 = (x2473)+(x2432);
x2476 = (x2475)<(x2432);
x2477 = (x2474)+(x2476);
x2478 = (x2477)+(x2360);
x2479 = (x2478)<(x2360);
x2480 = (x2479)+(x2365);
x2481 = (x2480)<(x2365);
x2482 = (x2480)+(x2429);
x2483 = (x2482)<(x2429);
x2484 = (x2481)+(x2483);
x2485 = (x2484)+(x2370);
x2486 = (x2485)<(x2370);
x2487 = (x2485)+(x2433);
x2488 = (x2487)<(x2433);
x2489 = (x2486)+(x2488);
x2490 = (x2489)+(x2375);
x2491 = (x2490)<(x2375);
x2492 = (x2490)+(x2437);
x2493 = (x2492)<(x2437);
x2494 = (x2491)+(x2493);
x2495 = (x2494)+(x2380);
x2496 = (x2495)<(x2380);
x2497 = (x2495)+(x2442);
x2498 = (x2497)<(x2442);
x2499 = (x2496)+(x2498);
x2500 = (x2499)+(x2385);
x2501 = (x2500)<(x2385);
x2502 = (x2500)+(x2447);
x2503 = (x2502)<(x2447);
x2504 = (x2501)+(x2503);
x2505 = (x2504)+(x2390);
x2506 = (x2505)<(x2390);
x2507 = (x2505)+(x2452);
x2508 = (x2507)<(x2452);
x2509 = (x2506)+(x2508);
x2510 = (x2509)+(x2395);
x2511 = (x2510)<(x2395);
x2512 = (x2510)+(x2457);
x2513 = (x2512)<(x2457);
x2514 = (x2511)+(x2513);
x2515 = (x2514)+(x2400);
x2516 = (x2515)<(x2400);
x2517 = (x2515)+(x2462);
x2518 = (x2517)<(x2462);
x2519 = (x2516)+(x2518);
x2520 = (x2519)+(x2405);
x2521 = (x2520)<(x2405);
x2522 = (x2520)+(x2467);
x2523 = (x2522)<(x2467);
x2524 = (x2521)+(x2523);
x2525 = (x2524)+(x2410);
x2526 = (x2525)<(x2410);
x2527 = (x2525)+(x2470);
x2528 = (x2527)<(x2470);
x2529 = (x2526)+(x2528);
x2530 = (x2529)+(x2412);
x2531 = (x21)*(x11);
x2532 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x11))>>32 : ((__uint128_t)(x21)*(x11))>>64;
x2533 = (x21)*(x10);
x2534 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x10))>>32 : ((__uint128_t)(x21)*(x10))>>64;
x2535 = (x21)*(x9);
x2536 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x9))>>32 : ((__uint128_t)(x21)*(x9))>>64;
x2537 = (x21)*(x8);
x2538 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x8))>>32 : ((__uint128_t)(x21)*(x8))>>64;
x2539 = (x21)*(x7);
x2540 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x7))>>32 : ((__uint128_t)(x21)*(x7))>>64;
x2541 = (x21)*(x6);
x2542 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x6))>>32 : ((__uint128_t)(x21)*(x6))>>64;
x2543 = (x21)*(x5);
x2544 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x5))>>32 : ((__uint128_t)(x21)*(x5))>>64;
x2545 = (x21)*(x4);
x2546 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x4))>>32 : ((__uint128_t)(x21)*(x4))>>64;
x2547 = (x21)*(x3);
x2548 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x3))>>32 : ((__uint128_t)(x21)*(x3))>>64;
x2549 = (x21)*(x2);
x2550 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x2))>>32 : ((__uint128_t)(x21)*(x2))>>64;
x2551 = (x21)*(x1);
x2552 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x1))>>32 : ((__uint128_t)(x21)*(x1))>>64;
x2553 = (x21)*(x0);
x2554 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*(x0))>>32 : ((__uint128_t)(x21)*(x0))>>64;
x2555 = (x2554)+(x2551);
x2556 = (x2555)<(x2554);
x2557 = (x2556)+(x2552);
x2558 = (x2557)<(x2552);
x2559 = (x2557)+(x2549);
x2560 = (x2559)<(x2549);
x2561 = (x2558)+(x2560);
x2562 = (x2561)+(x2550);
x2563 = (x2562)<(x2550);
x2564 = (x2562)+(x2547);
x2565 = (x2564)<(x2547);
x2566 = (x2563)+(x2565);
x2567 = (x2566)+(x2548);
x2568 = (x2567)<(x2548);
x2569 = (x2567)+(x2545);
x2570 = (x2569)<(x2545);
x2571 = (x2568)+(x2570);
x2572 = (x2571)+(x2546);
x2573 = (x2572)<(x2546);
x2574 = (x2572)+(x2543);
x2575 = (x2574)<(x2543);
x2576 = (x2573)+(x2575);
x2577 = (x2576)+(x2544);
x2578 = (x2577)<(x2544);
x2579 = (x2577)+(x2541);
x2580 = (x2579)<(x2541);
x2581 = (x2578)+(x2580);
x2582 = (x2581)+(x2542);
x2583 = (x2582)<(x2542);
x2584 = (x2582)+(x2539);
x2585 = (x2584)<(x2539);
x2586 = (x2583)+(x2585);
x2587 = (x2586)+(x2540);
x2588 = (x2587)<(x2540);
x2589 = (x2587)+(x2537);
x2590 = (x2589)<(x2537);
x2591 = (x2588)+(x2590);
x2592 = (x2591)+(x2538);
x2593 = (x2592)<(x2538);
x2594 = (x2592)+(x2535);
x2595 = (x2594)<(x2535);
x2596 = (x2593)+(x2595);
x2597 = (x2596)+(x2536);
x2598 = (x2597)<(x2536);
x2599 = (x2597)+(x2533);
x2600 = (x2599)<(x2533);
x2601 = (x2598)+(x2600);
x2602 = (x2601)+(x2534);
x2603 = (x2602)<(x2534);
x2604 = (x2602)+(x2531);
x2605 = (x2604)<(x2531);
x2606 = (x2603)+(x2605);
x2607 = (x2606)+(x2532);
x2608 = (x2475)+(x2553);
x2609 = (x2608)<(x2475);
x2610 = (x2609)+(x2478);
x2611 = (x2610)<(x2478);
x2612 = (x2610)+(x2555);
x2613 = (x2612)<(x2555);
x2614 = (x2611)+(x2613);
x2615 = (x2614)+(x2482);
x2616 = (x2615)<(x2482);
x2617 = (x2615)+(x2559);
x2618 = (x2617)<(x2559);
x2619 = (x2616)+(x2618);
x2620 = (x2619)+(x2487);
x2621 = (x2620)<(x2487);
x2622 = (x2620)+(x2564);
x2623 = (x2622)<(x2564);
x2624 = (x2621)+(x2623);
x2625 = (x2624)+(x2492);
x2626 = (x2625)<(x2492);
x2627 = (x2625)+(x2569);
x2628 = (x2627)<(x2569);
x2629 = (x2626)+(x2628);
x2630 = (x2629)+(x2497);
x2631 = (x2630)<(x2497);
x2632 = (x2630)+(x2574);
x2633 = (x2632)<(x2574);
x2634 = (x2631)+(x2633);
x2635 = (x2634)+(x2502);
x2636 = (x2635)<(x2502);
x2637 = (x2635)+(x2579);
x2638 = (x2637)<(x2579);
x2639 = (x2636)+(x2638);
x2640 = (x2639)+(x2507);
x2641 = (x2640)<(x2507);
x2642 = (x2640)+(x2584);
x2643 = (x2642)<(x2584);
x2644 = (x2641)+(x2643);
x2645 = (x2644)+(x2512);
x2646 = (x2645)<(x2512);
x2647 = (x2645)+(x2589);
x2648 = (x2647)<(x2589);
x2649 = (x2646)+(x2648);
x2650 = (x2649)+(x2517);
x2651 = (x2650)<(x2517);
x2652 = (x2650)+(x2594);
x2653 = (x2652)<(x2594);
x2654 = (x2651)+(x2653);
x2655 = (x2654)+(x2522);
x2656 = (x2655)<(x2522);
x2657 = (x2655)+(x2599);
x2658 = (x2657)<(x2599);
x2659 = (x2656)+(x2658);
x2660 = (x2659)+(x2527);
x2661 = (x2660)<(x2527);
x2662 = (x2660)+(x2604);
x2663 = (x2662)<(x2604);
x2664 = (x2661)+(x2663);
x2665 = (x2664)+(x2530);
x2666 = (x2665)<(x2530);
x2667 = (x2665)+(x2607);
x2668 = (x2667)<(x2607);
x2669 = (x2666)+(x2668);
x2670 = (x2608)*((uintptr_t)4294967295ULL);
x2671 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2672 = (x2608)*((uintptr_t)4294967295ULL);
x2673 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2674 = (x2608)*((uintptr_t)4294967295ULL);
x2675 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2676 = (x2608)*((uintptr_t)4294967295ULL);
x2677 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2678 = (x2608)*((uintptr_t)4294967295ULL);
x2679 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2680 = (x2608)*((uintptr_t)4294967295ULL);
x2681 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2682 = (x2608)*((uintptr_t)4294967295ULL);
x2683 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2684 = (x2608)*((uintptr_t)4294967294ULL);
x2685 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967294ULL))>>64;
x2686 = (x2608)*((uintptr_t)4294967295ULL);
x2687 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2688 = (x2608)*((uintptr_t)4294967295ULL);
x2689 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2608)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2608)*((uintptr_t)4294967295ULL))>>64;
x2690 = (x2687)+(x2684);
x2691 = (x2690)<(x2687);
x2692 = (x2691)+(x2685);
x2693 = (x2692)<(x2685);
x2694 = (x2692)+(x2682);
x2695 = (x2694)<(x2682);
x2696 = (x2693)+(x2695);
x2697 = (x2696)+(x2683);
x2698 = (x2697)<(x2683);
x2699 = (x2697)+(x2680);
x2700 = (x2699)<(x2680);
x2701 = (x2698)+(x2700);
x2702 = (x2701)+(x2681);
x2703 = (x2702)<(x2681);
x2704 = (x2702)+(x2678);
x2705 = (x2704)<(x2678);
x2706 = (x2703)+(x2705);
x2707 = (x2706)+(x2679);
x2708 = (x2707)<(x2679);
x2709 = (x2707)+(x2676);
x2710 = (x2709)<(x2676);
x2711 = (x2708)+(x2710);
x2712 = (x2711)+(x2677);
x2713 = (x2712)<(x2677);
x2714 = (x2712)+(x2674);
x2715 = (x2714)<(x2674);
x2716 = (x2713)+(x2715);
x2717 = (x2716)+(x2675);
x2718 = (x2717)<(x2675);
x2719 = (x2717)+(x2672);
x2720 = (x2719)<(x2672);
x2721 = (x2718)+(x2720);
x2722 = (x2721)+(x2673);
x2723 = (x2722)<(x2673);
x2724 = (x2722)+(x2670);
x2725 = (x2724)<(x2670);
x2726 = (x2723)+(x2725);
x2727 = (x2726)+(x2671);
x2728 = (x2608)+(x2688);
x2729 = (x2728)<(x2608);
x2730 = (x2729)+(x2612);
x2731 = (x2730)<(x2612);
x2732 = (x2730)+(x2689);
x2733 = (x2732)<(x2689);
x2734 = (x2731)+(x2733);
x2735 = (x2734)+(x2617);
x2736 = (x2735)<(x2617);
x2737 = (x2736)+(x2622);
x2738 = (x2737)<(x2622);
x2739 = (x2737)+(x2686);
x2740 = (x2739)<(x2686);
x2741 = (x2738)+(x2740);
x2742 = (x2741)+(x2627);
x2743 = (x2742)<(x2627);
x2744 = (x2742)+(x2690);
x2745 = (x2744)<(x2690);
x2746 = (x2743)+(x2745);
x2747 = (x2746)+(x2632);
x2748 = (x2747)<(x2632);
x2749 = (x2747)+(x2694);
x2750 = (x2749)<(x2694);
x2751 = (x2748)+(x2750);
x2752 = (x2751)+(x2637);
x2753 = (x2752)<(x2637);
x2754 = (x2752)+(x2699);
x2755 = (x2754)<(x2699);
x2756 = (x2753)+(x2755);
x2757 = (x2756)+(x2642);
x2758 = (x2757)<(x2642);
x2759 = (x2757)+(x2704);
x2760 = (x2759)<(x2704);
x2761 = (x2758)+(x2760);
x2762 = (x2761)+(x2647);
x2763 = (x2762)<(x2647);
x2764 = (x2762)+(x2709);
x2765 = (x2764)<(x2709);
x2766 = (x2763)+(x2765);
x2767 = (x2766)+(x2652);
x2768 = (x2767)<(x2652);
x2769 = (x2767)+(x2714);
x2770 = (x2769)<(x2714);
x2771 = (x2768)+(x2770);
x2772 = (x2771)+(x2657);
x2773 = (x2772)<(x2657);
x2774 = (x2772)+(x2719);
x2775 = (x2774)<(x2719);
x2776 = (x2773)+(x2775);
x2777 = (x2776)+(x2662);
x2778 = (x2777)<(x2662);
x2779 = (x2777)+(x2724);
x2780 = (x2779)<(x2724);
x2781 = (x2778)+(x2780);
x2782 = (x2781)+(x2667);
x2783 = (x2782)<(x2667);
x2784 = (x2782)+(x2727);
x2785 = (x2784)<(x2727);
x2786 = (x2783)+(x2785);
x2787 = (x2786)+(x2669);
x2788 = (x22)*(x11);
x2789 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x11))>>32 : ((__uint128_t)(x22)*(x11))>>64;
x2790 = (x22)*(x10);
x2791 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x10))>>32 : ((__uint128_t)(x22)*(x10))>>64;
x2792 = (x22)*(x9);
x2793 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x9))>>32 : ((__uint128_t)(x22)*(x9))>>64;
x2794 = (x22)*(x8);
x2795 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x8))>>32 : ((__uint128_t)(x22)*(x8))>>64;
x2796 = (x22)*(x7);
x2797 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x7))>>32 : ((__uint128_t)(x22)*(x7))>>64;
x2798 = (x22)*(x6);
x2799 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x6))>>32 : ((__uint128_t)(x22)*(x6))>>64;
x2800 = (x22)*(x5);
x2801 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x5))>>32 : ((__uint128_t)(x22)*(x5))>>64;
x2802 = (x22)*(x4);
x2803 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x4))>>32 : ((__uint128_t)(x22)*(x4))>>64;
x2804 = (x22)*(x3);
x2805 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x3))>>32 : ((__uint128_t)(x22)*(x3))>>64;
x2806 = (x22)*(x2);
x2807 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x2))>>32 : ((__uint128_t)(x22)*(x2))>>64;
x2808 = (x22)*(x1);
x2809 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x1))>>32 : ((__uint128_t)(x22)*(x1))>>64;
x2810 = (x22)*(x0);
x2811 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*(x0))>>32 : ((__uint128_t)(x22)*(x0))>>64;
x2812 = (x2811)+(x2808);
x2813 = (x2812)<(x2811);
x2814 = (x2813)+(x2809);
x2815 = (x2814)<(x2809);
x2816 = (x2814)+(x2806);
x2817 = (x2816)<(x2806);
x2818 = (x2815)+(x2817);
x2819 = (x2818)+(x2807);
x2820 = (x2819)<(x2807);
x2821 = (x2819)+(x2804);
x2822 = (x2821)<(x2804);
x2823 = (x2820)+(x2822);
x2824 = (x2823)+(x2805);
x2825 = (x2824)<(x2805);
x2826 = (x2824)+(x2802);
x2827 = (x2826)<(x2802);
x2828 = (x2825)+(x2827);
x2829 = (x2828)+(x2803);
x2830 = (x2829)<(x2803);
x2831 = (x2829)+(x2800);
x2832 = (x2831)<(x2800);
x2833 = (x2830)+(x2832);
x2834 = (x2833)+(x2801);
x2835 = (x2834)<(x2801);
x2836 = (x2834)+(x2798);
x2837 = (x2836)<(x2798);
x2838 = (x2835)+(x2837);
x2839 = (x2838)+(x2799);
x2840 = (x2839)<(x2799);
x2841 = (x2839)+(x2796);
x2842 = (x2841)<(x2796);
x2843 = (x2840)+(x2842);
x2844 = (x2843)+(x2797);
x2845 = (x2844)<(x2797);
x2846 = (x2844)+(x2794);
x2847 = (x2846)<(x2794);
x2848 = (x2845)+(x2847);
x2849 = (x2848)+(x2795);
x2850 = (x2849)<(x2795);
x2851 = (x2849)+(x2792);
x2852 = (x2851)<(x2792);
x2853 = (x2850)+(x2852);
x2854 = (x2853)+(x2793);
x2855 = (x2854)<(x2793);
x2856 = (x2854)+(x2790);
x2857 = (x2856)<(x2790);
x2858 = (x2855)+(x2857);
x2859 = (x2858)+(x2791);
x2860 = (x2859)<(x2791);
x2861 = (x2859)+(x2788);
x2862 = (x2861)<(x2788);
x2863 = (x2860)+(x2862);
x2864 = (x2863)+(x2789);
x2865 = (x2732)+(x2810);
x2866 = (x2865)<(x2732);
x2867 = (x2866)+(x2735);
x2868 = (x2867)<(x2735);
x2869 = (x2867)+(x2812);
x2870 = (x2869)<(x2812);
x2871 = (x2868)+(x2870);
x2872 = (x2871)+(x2739);
x2873 = (x2872)<(x2739);
x2874 = (x2872)+(x2816);
x2875 = (x2874)<(x2816);
x2876 = (x2873)+(x2875);
x2877 = (x2876)+(x2744);
x2878 = (x2877)<(x2744);
x2879 = (x2877)+(x2821);
x2880 = (x2879)<(x2821);
x2881 = (x2878)+(x2880);
x2882 = (x2881)+(x2749);
x2883 = (x2882)<(x2749);
x2884 = (x2882)+(x2826);
x2885 = (x2884)<(x2826);
x2886 = (x2883)+(x2885);
x2887 = (x2886)+(x2754);
x2888 = (x2887)<(x2754);
x2889 = (x2887)+(x2831);
x2890 = (x2889)<(x2831);
x2891 = (x2888)+(x2890);
x2892 = (x2891)+(x2759);
x2893 = (x2892)<(x2759);
x2894 = (x2892)+(x2836);
x2895 = (x2894)<(x2836);
x2896 = (x2893)+(x2895);
x2897 = (x2896)+(x2764);
x2898 = (x2897)<(x2764);
x2899 = (x2897)+(x2841);
x2900 = (x2899)<(x2841);
x2901 = (x2898)+(x2900);
x2902 = (x2901)+(x2769);
x2903 = (x2902)<(x2769);
x2904 = (x2902)+(x2846);
x2905 = (x2904)<(x2846);
x2906 = (x2903)+(x2905);
x2907 = (x2906)+(x2774);
x2908 = (x2907)<(x2774);
x2909 = (x2907)+(x2851);
x2910 = (x2909)<(x2851);
x2911 = (x2908)+(x2910);
x2912 = (x2911)+(x2779);
x2913 = (x2912)<(x2779);
x2914 = (x2912)+(x2856);
x2915 = (x2914)<(x2856);
x2916 = (x2913)+(x2915);
x2917 = (x2916)+(x2784);
x2918 = (x2917)<(x2784);
x2919 = (x2917)+(x2861);
x2920 = (x2919)<(x2861);
x2921 = (x2918)+(x2920);
x2922 = (x2921)+(x2787);
x2923 = (x2922)<(x2787);
x2924 = (x2922)+(x2864);
x2925 = (x2924)<(x2864);
x2926 = (x2923)+(x2925);
x2927 = (x2865)*((uintptr_t)4294967295ULL);
x2928 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2929 = (x2865)*((uintptr_t)4294967295ULL);
x2930 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2931 = (x2865)*((uintptr_t)4294967295ULL);
x2932 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2933 = (x2865)*((uintptr_t)4294967295ULL);
x2934 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2935 = (x2865)*((uintptr_t)4294967295ULL);
x2936 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2937 = (x2865)*((uintptr_t)4294967295ULL);
x2938 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2939 = (x2865)*((uintptr_t)4294967295ULL);
x2940 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2941 = (x2865)*((uintptr_t)4294967294ULL);
x2942 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967294ULL))>>64;
x2943 = (x2865)*((uintptr_t)4294967295ULL);
x2944 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2945 = (x2865)*((uintptr_t)4294967295ULL);
x2946 = sizeof(intptr_t) == 4 ? ((uint64_t)(x2865)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x2865)*((uintptr_t)4294967295ULL))>>64;
x2947 = (x2944)+(x2941);
x2948 = (x2947)<(x2944);
x2949 = (x2948)+(x2942);
x2950 = (x2949)<(x2942);
x2951 = (x2949)+(x2939);
x2952 = (x2951)<(x2939);
x2953 = (x2950)+(x2952);
x2954 = (x2953)+(x2940);
x2955 = (x2954)<(x2940);
x2956 = (x2954)+(x2937);
x2957 = (x2956)<(x2937);
x2958 = (x2955)+(x2957);
x2959 = (x2958)+(x2938);
x2960 = (x2959)<(x2938);
x2961 = (x2959)+(x2935);
x2962 = (x2961)<(x2935);
x2963 = (x2960)+(x2962);
x2964 = (x2963)+(x2936);
x2965 = (x2964)<(x2936);
x2966 = (x2964)+(x2933);
x2967 = (x2966)<(x2933);
x2968 = (x2965)+(x2967);
x2969 = (x2968)+(x2934);
x2970 = (x2969)<(x2934);
x2971 = (x2969)+(x2931);
x2972 = (x2971)<(x2931);
x2973 = (x2970)+(x2972);
x2974 = (x2973)+(x2932);
x2975 = (x2974)<(x2932);
x2976 = (x2974)+(x2929);
x2977 = (x2976)<(x2929);
x2978 = (x2975)+(x2977);
x2979 = (x2978)+(x2930);
x2980 = (x2979)<(x2930);
x2981 = (x2979)+(x2927);
x2982 = (x2981)<(x2927);
x2983 = (x2980)+(x2982);
x2984 = (x2983)+(x2928);
x2985 = (x2865)+(x2945);
x2986 = (x2985)<(x2865);
x2987 = (x2986)+(x2869);
x2988 = (x2987)<(x2869);
x2989 = (x2987)+(x2946);
x2990 = (x2989)<(x2946);
x2991 = (x2988)+(x2990);
x2992 = (x2991)+(x2874);
x2993 = (x2992)<(x2874);
x2994 = (x2993)+(x2879);
x2995 = (x2994)<(x2879);
x2996 = (x2994)+(x2943);
x2997 = (x2996)<(x2943);
x2998 = (x2995)+(x2997);
x2999 = (x2998)+(x2884);
x3000 = (x2999)<(x2884);
x3001 = (x2999)+(x2947);
x3002 = (x3001)<(x2947);
x3003 = (x3000)+(x3002);
x3004 = (x3003)+(x2889);
x3005 = (x3004)<(x2889);
x3006 = (x3004)+(x2951);
x3007 = (x3006)<(x2951);
x3008 = (x3005)+(x3007);
x3009 = (x3008)+(x2894);
x3010 = (x3009)<(x2894);
x3011 = (x3009)+(x2956);
x3012 = (x3011)<(x2956);
x3013 = (x3010)+(x3012);
x3014 = (x3013)+(x2899);
x3015 = (x3014)<(x2899);
x3016 = (x3014)+(x2961);
x3017 = (x3016)<(x2961);
x3018 = (x3015)+(x3017);
x3019 = (x3018)+(x2904);
x3020 = (x3019)<(x2904);
x3021 = (x3019)+(x2966);
x3022 = (x3021)<(x2966);
x3023 = (x3020)+(x3022);
x3024 = (x3023)+(x2909);
x3025 = (x3024)<(x2909);
x3026 = (x3024)+(x2971);
x3027 = (x3026)<(x2971);
x3028 = (x3025)+(x3027);
x3029 = (x3028)+(x2914);
x3030 = (x3029)<(x2914);
x3031 = (x3029)+(x2976);
x3032 = (x3031)<(x2976);
x3033 = (x3030)+(x3032);
x3034 = (x3033)+(x2919);
x3035 = (x3034)<(x2919);
x3036 = (x3034)+(x2981);
x3037 = (x3036)<(x2981);
x3038 = (x3035)+(x3037);
x3039 = (x3038)+(x2924);
x3040 = (x3039)<(x2924);
x3041 = (x3039)+(x2984);
x3042 = (x3041)<(x2984);
x3043 = (x3040)+(x3042);
x3044 = (x3043)+(x2926);
x3045 = (x2989)-((uintptr_t)4294967295ULL);
x3046 = (x2989)<(x3045);
x3047 = (x3045)<(x3045);
x3048 = (x3046)+(x3047);
x3049 = (x2992)<(x2992);
x3050 = (x2992)-(x3048);
x3051 = (x2992)<(x3050);
x3052 = (x3049)+(x3051);
x3053 = (x2996)<(x2996);
x3054 = (x2996)-(x3052);
x3055 = (x2996)<(x3054);
x3056 = (x3053)+(x3055);
x3057 = (x3001)-((uintptr_t)4294967295ULL);
x3058 = (x3001)<(x3057);
x3059 = (x3057)-(x3056);
x3060 = (x3057)<(x3059);
x3061 = (x3058)+(x3060);
x3062 = (x3006)-((uintptr_t)4294967294ULL);
x3063 = (x3006)<(x3062);
x3064 = (x3062)-(x3061);
x3065 = (x3062)<(x3064);
x3066 = (x3063)+(x3065);
x3067 = (x3011)-((uintptr_t)4294967295ULL);
x3068 = (x3011)<(x3067);
x3069 = (x3067)-(x3066);
x3070 = (x3067)<(x3069);
x3071 = (x3068)+(x3070);
x3072 = (x3016)-((uintptr_t)4294967295ULL);
x3073 = (x3016)<(x3072);
x3074 = (x3072)-(x3071);
x3075 = (x3072)<(x3074);
x3076 = (x3073)+(x3075);
x3077 = (x3021)-((uintptr_t)4294967295ULL);
x3078 = (x3021)<(x3077);
x3079 = (x3077)-(x3076);
x3080 = (x3077)<(x3079);
x3081 = (x3078)+(x3080);
x3082 = (x3026)-((uintptr_t)4294967295ULL);
x3083 = (x3026)<(x3082);
x3084 = (x3082)-(x3081);
x3085 = (x3082)<(x3084);
x3086 = (x3083)+(x3085);
x3087 = (x3031)-((uintptr_t)4294967295ULL);
x3088 = (x3031)<(x3087);
x3089 = (x3087)-(x3086);
x3090 = (x3087)<(x3089);
x3091 = (x3088)+(x3090);
x3092 = (x3036)-((uintptr_t)4294967295ULL);
x3093 = (x3036)<(x3092);
x3094 = (x3092)-(x3091);
x3095 = (x3092)<(x3094);
x3096 = (x3093)+(x3095);
x3097 = (x3041)-((uintptr_t)4294967295ULL);
x3098 = (x3041)<(x3097);
x3099 = (x3097)-(x3096);
x3100 = (x3097)<(x3099);
x3101 = (x3098)+(x3100);
x3102 = (x3044)<(x3044);
x3103 = (x3044)-(x3101);
x3104 = (x3044)<(x3103);
x3105 = (x3102)+(x3104);
x3106 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3107 = (x3106)^((uintptr_t)4294967295ULL);
x3108 = ((x2989)&(x3106))|((x3045)&(x3107));
x3109 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3110 = (x3109)^((uintptr_t)4294967295ULL);
x3111 = ((x2992)&(x3109))|((x3050)&(x3110));
x3112 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3113 = (x3112)^((uintptr_t)4294967295ULL);
x3114 = ((x2996)&(x3112))|((x3054)&(x3113));
x3115 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3116 = (x3115)^((uintptr_t)4294967295ULL);
x3117 = ((x3001)&(x3115))|((x3059)&(x3116));
x3118 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3119 = (x3118)^((uintptr_t)4294967295ULL);
x3120 = ((x3006)&(x3118))|((x3064)&(x3119));
x3121 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3122 = (x3121)^((uintptr_t)4294967295ULL);
x3123 = ((x3011)&(x3121))|((x3069)&(x3122));
x3124 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3125 = (x3124)^((uintptr_t)4294967295ULL);
x3126 = ((x3016)&(x3124))|((x3074)&(x3125));
x3127 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3128 = (x3127)^((uintptr_t)4294967295ULL);
x3129 = ((x3021)&(x3127))|((x3079)&(x3128));
x3130 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3131 = (x3130)^((uintptr_t)4294967295ULL);
x3132 = ((x3026)&(x3130))|((x3084)&(x3131));
x3133 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3134 = (x3133)^((uintptr_t)4294967295ULL);
x3135 = ((x3031)&(x3133))|((x3089)&(x3134));
x3136 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3137 = (x3136)^((uintptr_t)4294967295ULL);
x3138 = ((x3036)&(x3136))|((x3094)&(x3137));
x3139 = ((uintptr_t)-1ULL)+((x3105)==((uintptr_t)0ULL));
x3140 = (x3139)^((uintptr_t)4294967295ULL);
x3141 = ((x3041)&(x3139))|((x3099)&(x3140));
x3142 = x3108;
x3143 = x3111;
x3144 = x3114;
x3145 = x3117;
x3146 = x3120;
x3147 = x3123;
x3148 = x3126;
x3149 = x3129;
x3150 = x3132;
x3151 = x3135;
x3152 = x3138;
x3153 = x3141;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x3142;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x3143;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x3144;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x3145;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x3146;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x3147;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x3148;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x3149;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x3150;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x3151;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x3152;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x3153;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_add(uintptr_t in0, uintptr_t in1, uintptr_t out0) {
uintptr_t x12, x0, x25, x1, x13, x27, x2, x14, x29, x3, x15, x31, x4, x16, x33, x5, x17, x35, x6, x18, x37, x7, x19, x39, x8, x20, x41, x9, x21, x43, x10, x22, x45, x11, x23, x51, x53, x55, x57, x59, x61, x63, x65, x47, x67, x24, x70, x48, x71, x26, x73, x49, x74, x28, x76, x50, x77, x30, x79, x52, x80, x32, x82, x54, x83, x34, x85, x56, x86, x36, x88, x58, x89, x38, x91, x60, x92, x40, x94, x62, x95, x42, x97, x64, x98, x44, x100, x66, x101, x69, x46, x103, x68, x104, x72, x75, x78, x81, x84, x87, x90, x93, x96, x99, x102, x105, x106, x107, x108, x109, x110, x111, x112, x113, x114, x115, x116, x117;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
x12 = *(uintptr_t*)((in1)+((uintptr_t)0ULL));
x13 = *(uintptr_t*)((in1)+((uintptr_t)4ULL));
x14 = *(uintptr_t*)((in1)+((uintptr_t)8ULL));
x15 = *(uintptr_t*)((in1)+((uintptr_t)12ULL));
x16 = *(uintptr_t*)((in1)+((uintptr_t)16ULL));
x17 = *(uintptr_t*)((in1)+((uintptr_t)20ULL));
x18 = *(uintptr_t*)((in1)+((uintptr_t)24ULL));
x19 = *(uintptr_t*)((in1)+((uintptr_t)28ULL));
x20 = *(uintptr_t*)((in1)+((uintptr_t)32ULL));
x21 = *(uintptr_t*)((in1)+((uintptr_t)36ULL));
x22 = *(uintptr_t*)((in1)+((uintptr_t)40ULL));
x23 = *(uintptr_t*)((in1)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x24 = (x0)+(x12);
x25 = ((x24)<(x0))+(x1);
x26 = (x25)+(x13);
x27 = (((x25)<(x1))+((x26)<(x13)))+(x2);
x28 = (x27)+(x14);
x29 = (((x27)<(x2))+((x28)<(x14)))+(x3);
x30 = (x29)+(x15);
x31 = (((x29)<(x3))+((x30)<(x15)))+(x4);
x32 = (x31)+(x16);
x33 = (((x31)<(x4))+((x32)<(x16)))+(x5);
x34 = (x33)+(x17);
x35 = (((x33)<(x5))+((x34)<(x17)))+(x6);
x36 = (x35)+(x18);
x37 = (((x35)<(x6))+((x36)<(x18)))+(x7);
x38 = (x37)+(x19);
x39 = (((x37)<(x7))+((x38)<(x19)))+(x8);
x40 = (x39)+(x20);
x41 = (((x39)<(x8))+((x40)<(x20)))+(x9);
x42 = (x41)+(x21);
x43 = (((x41)<(x9))+((x42)<(x21)))+(x10);
x44 = (x43)+(x22);
x45 = (((x43)<(x10))+((x44)<(x22)))+(x11);
x46 = (x45)+(x23);
x47 = ((x45)<(x11))+((x46)<(x23));
x48 = (x24)-((uintptr_t)4294967295ULL);
x49 = (x26)-(((x24)<(x48))+((x48)<(x48)));
x50 = (x28)-(((x26)<(x26))+((x26)<(x49)));
x51 = (x30)-((uintptr_t)4294967295ULL);
x52 = (x51)-(((x28)<(x28))+((x28)<(x50)));
x53 = (x32)-((uintptr_t)4294967294ULL);
x54 = (x53)-(((x30)<(x51))+((x51)<(x52)));
x55 = (x34)-((uintptr_t)4294967295ULL);
x56 = (x55)-(((x32)<(x53))+((x53)<(x54)));
x57 = (x36)-((uintptr_t)4294967295ULL);
x58 = (x57)-(((x34)<(x55))+((x55)<(x56)));
x59 = (x38)-((uintptr_t)4294967295ULL);
x60 = (x59)-(((x36)<(x57))+((x57)<(x58)));
x61 = (x40)-((uintptr_t)4294967295ULL);
x62 = (x61)-(((x38)<(x59))+((x59)<(x60)));
x63 = (x42)-((uintptr_t)4294967295ULL);
x64 = (x63)-(((x40)<(x61))+((x61)<(x62)));
x65 = (x44)-((uintptr_t)4294967295ULL);
x66 = (x65)-(((x42)<(x63))+((x63)<(x64)));
x67 = (x46)-((uintptr_t)4294967295ULL);
x68 = (x67)-(((x44)<(x65))+((x65)<(x66)));
x69 = ((x47)<(x47))+((x47)<((x47)-(((x46)<(x67))+((x67)<(x68)))));
x70 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x71 = (x70)^((uintptr_t)4294967295ULL);
x72 = ((x24)&(x70))|((x48)&(x71));
x73 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x74 = (x73)^((uintptr_t)4294967295ULL);
x75 = ((x26)&(x73))|((x49)&(x74));
x76 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x77 = (x76)^((uintptr_t)4294967295ULL);
x78 = ((x28)&(x76))|((x50)&(x77));
x79 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x80 = (x79)^((uintptr_t)4294967295ULL);
x81 = ((x30)&(x79))|((x52)&(x80));
x82 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x83 = (x82)^((uintptr_t)4294967295ULL);
x84 = ((x32)&(x82))|((x54)&(x83));
x85 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x86 = (x85)^((uintptr_t)4294967295ULL);
x87 = ((x34)&(x85))|((x56)&(x86));
x88 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x89 = (x88)^((uintptr_t)4294967295ULL);
x90 = ((x36)&(x88))|((x58)&(x89));
x91 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x92 = (x91)^((uintptr_t)4294967295ULL);
x93 = ((x38)&(x91))|((x60)&(x92));
x94 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x95 = (x94)^((uintptr_t)4294967295ULL);
x96 = ((x40)&(x94))|((x62)&(x95));
x97 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x98 = (x97)^((uintptr_t)4294967295ULL);
x99 = ((x42)&(x97))|((x64)&(x98));
x100 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x101 = (x100)^((uintptr_t)4294967295ULL);
x102 = ((x44)&(x100))|((x66)&(x101));
x103 = ((uintptr_t)-1ULL)+((x69)==((uintptr_t)0ULL));
x104 = (x103)^((uintptr_t)4294967295ULL);
x105 = ((x46)&(x103))|((x68)&(x104));
x106 = x72;
x107 = x75;
x108 = x78;
x109 = x81;
x110 = x84;
x111 = x87;
x112 = x90;
x113 = x93;
x114 = x96;
x115 = x99;
x116 = x102;
x117 = x105;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x106;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x107;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x108;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x109;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x110;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x111;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x112;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x113;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x114;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x115;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x116;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x117;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_sub(uintptr_t in0, uintptr_t in1, uintptr_t out0) {
uintptr_t x12, x13, x0, x14, x1, x25, x15, x2, x27, x16, x3, x29, x17, x4, x31, x18, x5, x33, x19, x6, x35, x20, x7, x37, x21, x8, x39, x22, x9, x41, x23, x10, x43, x11, x45, x24, x26, x28, x51, x30, x53, x32, x55, x34, x57, x36, x59, x38, x61, x40, x63, x42, x65, x44, x46, x47, x48, x49, x50, x52, x54, x56, x58, x60, x62, x64, x66, x67, x68, x69, x70, x71, x72, x73, x74, x75, x76, x77, x78, x79;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
x12 = *(uintptr_t*)((in1)+((uintptr_t)0ULL));
x13 = *(uintptr_t*)((in1)+((uintptr_t)4ULL));
x14 = *(uintptr_t*)((in1)+((uintptr_t)8ULL));
x15 = *(uintptr_t*)((in1)+((uintptr_t)12ULL));
x16 = *(uintptr_t*)((in1)+((uintptr_t)16ULL));
x17 = *(uintptr_t*)((in1)+((uintptr_t)20ULL));
x18 = *(uintptr_t*)((in1)+((uintptr_t)24ULL));
x19 = *(uintptr_t*)((in1)+((uintptr_t)28ULL));
x20 = *(uintptr_t*)((in1)+((uintptr_t)32ULL));
x21 = *(uintptr_t*)((in1)+((uintptr_t)36ULL));
x22 = *(uintptr_t*)((in1)+((uintptr_t)40ULL));
x23 = *(uintptr_t*)((in1)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x24 = (x0)-(x12);
x25 = (x1)-(x13);
x26 = (x25)-((x0)<(x24));
x27 = (x2)-(x14);
x28 = (x27)-(((x1)<(x25))+((x25)<(x26)));
x29 = (x3)-(x15);
x30 = (x29)-(((x2)<(x27))+((x27)<(x28)));
x31 = (x4)-(x16);
x32 = (x31)-(((x3)<(x29))+((x29)<(x30)));
x33 = (x5)-(x17);
x34 = (x33)-(((x4)<(x31))+((x31)<(x32)));
x35 = (x6)-(x18);
x36 = (x35)-(((x5)<(x33))+((x33)<(x34)));
x37 = (x7)-(x19);
x38 = (x37)-(((x6)<(x35))+((x35)<(x36)));
x39 = (x8)-(x20);
x40 = (x39)-(((x7)<(x37))+((x37)<(x38)));
x41 = (x9)-(x21);
x42 = (x41)-(((x8)<(x39))+((x39)<(x40)));
x43 = (x10)-(x22);
x44 = (x43)-(((x9)<(x41))+((x41)<(x42)));
x45 = (x11)-(x23);
x46 = (x45)-(((x10)<(x43))+((x43)<(x44)));
x47 = ((uintptr_t)-1ULL)+((((x11)<(x45))+((x45)<(x46)))==((uintptr_t)0ULL));
x48 = (x24)+((x47)&((uintptr_t)4294967295ULL));
x49 = ((x48)<(x24))+(x26);
x50 = ((x49)<(x26))+(x28);
x51 = ((x50)<(x28))+(x30);
x52 = (x51)+((x47)&((uintptr_t)4294967295ULL));
x53 = (((x51)<(x30))+((x52)<((x47)&((uintptr_t)4294967295ULL))))+(x32);
x54 = (x53)+((x47)&((uintptr_t)4294967294ULL));
x55 = (((x53)<(x32))+((x54)<((x47)&((uintptr_t)4294967294ULL))))+(x34);
x56 = (x55)+((x47)&((uintptr_t)4294967295ULL));
x57 = (((x55)<(x34))+((x56)<((x47)&((uintptr_t)4294967295ULL))))+(x36);
x58 = (x57)+((x47)&((uintptr_t)4294967295ULL));
x59 = (((x57)<(x36))+((x58)<((x47)&((uintptr_t)4294967295ULL))))+(x38);
x60 = (x59)+((x47)&((uintptr_t)4294967295ULL));
x61 = (((x59)<(x38))+((x60)<((x47)&((uintptr_t)4294967295ULL))))+(x40);
x62 = (x61)+((x47)&((uintptr_t)4294967295ULL));
x63 = (((x61)<(x40))+((x62)<((x47)&((uintptr_t)4294967295ULL))))+(x42);
x64 = (x63)+((x47)&((uintptr_t)4294967295ULL));
x65 = (((x63)<(x42))+((x64)<((x47)&((uintptr_t)4294967295ULL))))+(x44);
x66 = (x65)+((x47)&((uintptr_t)4294967295ULL));
x67 = ((((x65)<(x44))+((x66)<((x47)&((uintptr_t)4294967295ULL))))+(x46))+((x47)&((uintptr_t)4294967295ULL));
x68 = x48;
x69 = x49;
x70 = x50;
x71 = x52;
x72 = x54;
x73 = x56;
x74 = x58;
x75 = x60;
x76 = x62;
x77 = x64;
x78 = x66;
x79 = x67;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x68;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x69;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x70;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x71;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x72;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x73;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x74;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x75;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x76;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x77;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x78;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x79;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_opp(uintptr_t in0, uintptr_t out0) {
uintptr_t x0, x1, x2, x13, x3, x15, x4, x17, x5, x19, x6, x21, x7, x23, x8, x25, x9, x27, x10, x29, x11, x31, x33, x12, x14, x16, x39, x18, x41, x20, x43, x22, x45, x24, x47, x26, x49, x28, x51, x30, x53, x32, x34, x35, x36, x37, x38, x40, x42, x44, x46, x48, x50, x52, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64, x65, x66, x67;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x12 = ((uintptr_t)0ULL)-(x0);
x13 = ((uintptr_t)0ULL)-(x1);
x14 = (x13)-(((uintptr_t)0ULL)<(x12));
x15 = ((uintptr_t)0ULL)-(x2);
x16 = (x15)-((((uintptr_t)0ULL)<(x13))+((x13)<(x14)));
x17 = ((uintptr_t)0ULL)-(x3);
x18 = (x17)-((((uintptr_t)0ULL)<(x15))+((x15)<(x16)));
x19 = ((uintptr_t)0ULL)-(x4);
x20 = (x19)-((((uintptr_t)0ULL)<(x17))+((x17)<(x18)));
x21 = ((uintptr_t)0ULL)-(x5);
x22 = (x21)-((((uintptr_t)0ULL)<(x19))+((x19)<(x20)));
x23 = ((uintptr_t)0ULL)-(x6);
x24 = (x23)-((((uintptr_t)0ULL)<(x21))+((x21)<(x22)));
x25 = ((uintptr_t)0ULL)-(x7);
x26 = (x25)-((((uintptr_t)0ULL)<(x23))+((x23)<(x24)));
x27 = ((uintptr_t)0ULL)-(x8);
x28 = (x27)-((((uintptr_t)0ULL)<(x25))+((x25)<(x26)));
x29 = ((uintptr_t)0ULL)-(x9);
x30 = (x29)-((((uintptr_t)0ULL)<(x27))+((x27)<(x28)));
x31 = ((uintptr_t)0ULL)-(x10);
x32 = (x31)-((((uintptr_t)0ULL)<(x29))+((x29)<(x30)));
x33 = ((uintptr_t)0ULL)-(x11);
x34 = (x33)-((((uintptr_t)0ULL)<(x31))+((x31)<(x32)));
x35 = ((uintptr_t)-1ULL)+(((((uintptr_t)0ULL)<(x33))+((x33)<(x34)))==((uintptr_t)0ULL));
x36 = (x12)+((x35)&((uintptr_t)4294967295ULL));
x37 = ((x36)<(x12))+(x14);
x38 = ((x37)<(x14))+(x16);
x39 = ((x38)<(x16))+(x18);
x40 = (x39)+((x35)&((uintptr_t)4294967295ULL));
x41 = (((x39)<(x18))+((x40)<((x35)&((uintptr_t)4294967295ULL))))+(x20);
x42 = (x41)+((x35)&((uintptr_t)4294967294ULL));
x43 = (((x41)<(x20))+((x42)<((x35)&((uintptr_t)4294967294ULL))))+(x22);
x44 = (x43)+((x35)&((uintptr_t)4294967295ULL));
x45 = (((x43)<(x22))+((x44)<((x35)&((uintptr_t)4294967295ULL))))+(x24);
x46 = (x45)+((x35)&((uintptr_t)4294967295ULL));
x47 = (((x45)<(x24))+((x46)<((x35)&((uintptr_t)4294967295ULL))))+(x26);
x48 = (x47)+((x35)&((uintptr_t)4294967295ULL));
x49 = (((x47)<(x26))+((x48)<((x35)&((uintptr_t)4294967295ULL))))+(x28);
x50 = (x49)+((x35)&((uintptr_t)4294967295ULL));
x51 = (((x49)<(x28))+((x50)<((x35)&((uintptr_t)4294967295ULL))))+(x30);
x52 = (x51)+((x35)&((uintptr_t)4294967295ULL));
x53 = (((x51)<(x30))+((x52)<((x35)&((uintptr_t)4294967295ULL))))+(x32);
x54 = (x53)+((x35)&((uintptr_t)4294967295ULL));
x55 = ((((x53)<(x32))+((x54)<((x35)&((uintptr_t)4294967295ULL))))+(x34))+((x35)&((uintptr_t)4294967295ULL));
x56 = x36;
x57 = x37;
x58 = x38;
x59 = x40;
x60 = x42;
x61 = x44;
x62 = x46;
x63 = x48;
x64 = x50;
x65 = x52;
x66 = x54;
x67 = x55;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x56;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x57;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x58;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x59;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x60;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x61;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x62;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x63;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x64;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x65;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x66;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x67;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_from_montgomery(uintptr_t in0, uintptr_t out0) {
uintptr_t x0, x29, x32, x27, x25, x34, x26, x23, x36, x24, x21, x38, x22, x19, x40, x20, x17, x42, x18, x15, x44, x16, x13, x12, x1, x47, x30, x66, x69, x64, x62, x71, x63, x60, x73, x61, x58, x75, x59, x56, x77, x57, x54, x79, x55, x52, x81, x53, x50, x48, x84, x49, x67, x28, x87, x31, x65, x89, x33, x68, x91, x35, x70, x93, x37, x72, x95, x39, x74, x97, x41, x76, x99, x43, x78, x101, x45, x80, x103, x46, x14, x82, x83, x51, x2, x85, x86, x88, x90, x92, x94, x96, x98, x100, x102, x104, x105, x136, x139, x134, x132, x141, x133, x130, x143, x131, x128, x145, x129, x126, x147, x127, x124, x149, x125, x122, x151, x123, x120, x107, x154, x108, x137, x109, x157, x110, x135, x159, x111, x138, x161, x112, x140, x163, x113, x142, x165, x114, x144, x167, x115, x146, x169, x116, x148, x171, x117, x150, x173, x118, x152, x175, x119, x106, x153, x121, x3, x155, x156, x158, x160, x162, x164, x166, x168, x170, x172, x174, x176, x207, x210, x205, x203, x212, x204, x201, x214, x202, x199, x216, x200, x197, x218, x198, x195, x220, x196, x193, x222, x194, x191, x178, x225, x179, x208, x180, x228, x181, x206, x230, x182, x209, x232, x183, x211, x234, x184, x213, x236, x185, x215, x238, x186, x217, x240, x187, x219, x242, x188, x221, x244, x189, x223, x246, x190, x177, x224, x192, x4, x226, x227, x229, x231, x233, x235, x237, x239, x241, x243, x245, x247, x278, x281, x276, x274, x283, x275, x272, x285, x273, x270, x287, x271, x268, x289, x269, x266, x291, x267, x264, x293, x265, x262, x249, x296, x250, x279, x251, x299, x252, x277, x301, x253, x280, x303, x254, x282, x305, x255, x284, x307, x256, x286, x309, x257, x288, x311, x258, x290, x313, x259, x292, x315, x260, x294, x317, x261, x248, x295, x263, x5, x297, x298, x300, x302, x304, x306, x308, x310, x312, x314, x316, x318, x349, x352, x347, x345, x354, x346, x343, x356, x344, x341, x358, x342, x339, x360, x340, x337, x362, x338, x335, x364, x336, x333, x320, x367, x321, x350, x322, x370, x323, x348, x372, x324, x351, x374, x325, x353, x376, x326, x355, x378, x327, x357, x380, x328, x359, x382, x329, x361, x384, x330, x363, x386, x331, x365, x388, x332, x319, x366, x334, x6, x368, x369, x371, x373, x375, x377, x379, x381, x383, x385, x387, x389, x420, x423, x418, x416, x425, x417, x414, x427, x415, x412, x429, x413, x410, x431, x411, x408, x433, x409, x406, x435, x407, x404, x391, x438, x392, x421, x393, x441, x394, x419, x443, x395, x422, x445, x396, x424, x447, x397, x426, x449, x398, x428, x451, x399, x430, x453, x400, x432, x455, x401, x434, x457, x402, x436, x459, x403, x390, x437, x405, x7, x439, x440, x442, x444, x446, x448, x450, x452, x454, x456, x458, x460, x491, x494, x489, x487, x496, x488, x485, x498, x486, x483, x500, x484, x481, x502, x482, x479, x504, x480, x477, x506, x478, x475, x462, x509, x463, x492, x464, x512, x465, x490, x514, x466, x493, x516, x467, x495, x518, x468, x497, x520, x469, x499, x522, x470, x501, x524, x471, x503, x526, x472, x505, x528, x473, x507, x530, x474, x461, x508, x476, x8, x510, x511, x513, x515, x517, x519, x521, x523, x525, x527, x529, x531, x562, x565, x560, x558, x567, x559, x556, x569, x557, x554, x571, x555, x552, x573, x553, x550, x575, x551, x548, x577, x549, x546, x533, x580, x534, x563, x535, x583, x536, x561, x585, x537, x564, x587, x538, x566, x589, x539, x568, x591, x540, x570, x593, x541, x572, x595, x542, x574, x597, x543, x576, x599, x544, x578, x601, x545, x532, x579, x547, x9, x581, x582, x584, x586, x588, x590, x592, x594, x596, x598, x600, x602, x633, x636, x631, x629, x638, x630, x627, x640, x628, x625, x642, x626, x623, x644, x624, x621, x646, x622, x619, x648, x620, x617, x604, x651, x605, x634, x606, x654, x607, x632, x656, x608, x635, x658, x609, x637, x660, x610, x639, x662, x611, x641, x664, x612, x643, x666, x613, x645, x668, x614, x647, x670, x615, x649, x672, x616, x603, x650, x618, x10, x652, x653, x655, x657, x659, x661, x663, x665, x667, x669, x671, x673, x704, x707, x702, x700, x709, x701, x698, x711, x699, x696, x713, x697, x694, x715, x695, x692, x717, x693, x690, x719, x691, x688, x675, x722, x676, x705, x677, x725, x678, x703, x727, x679, x706, x729, x680, x708, x731, x681, x710, x733, x682, x712, x735, x683, x714, x737, x684, x716, x739, x685, x718, x741, x686, x720, x743, x687, x674, x721, x689, x11, x723, x724, x726, x728, x730, x732, x734, x736, x738, x740, x742, x744, x775, x778, x773, x771, x780, x772, x769, x782, x770, x767, x784, x768, x765, x786, x766, x763, x788, x764, x761, x790, x762, x759, x746, x793, x747, x776, x748, x796, x749, x774, x798, x750, x777, x800, x751, x779, x802, x752, x781, x804, x753, x783, x806, x754, x785, x808, x755, x787, x810, x756, x789, x812, x757, x791, x814, x758, x745, x792, x760, x820, x822, x824, x826, x828, x830, x832, x834, x816, x836, x794, x839, x817, x840, x795, x842, x818, x843, x797, x845, x819, x846, x799, x848, x821, x849, x801, x851, x823, x852, x803, x854, x825, x855, x805, x857, x827, x858, x807, x860, x829, x861, x809, x863, x831, x864, x811, x866, x833, x867, x813, x869, x835, x870, x838, x815, x872, x837, x873, x841, x844, x847, x850, x853, x856, x859, x862, x865, x868, x871, x874, x875, x876, x877, x878, x879, x880, x881, x882, x883, x884, x885, x886;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x12 = x0;
x13 = (x12)*((uintptr_t)4294967295ULL);
x14 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x15 = (x12)*((uintptr_t)4294967295ULL);
x16 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x17 = (x12)*((uintptr_t)4294967295ULL);
x18 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x19 = (x12)*((uintptr_t)4294967295ULL);
x20 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x21 = (x12)*((uintptr_t)4294967295ULL);
x22 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x23 = (x12)*((uintptr_t)4294967295ULL);
x24 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x25 = (x12)*((uintptr_t)4294967295ULL);
x26 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x27 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967294ULL))>>64;
x28 = (x12)*((uintptr_t)4294967295ULL);
x29 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x30 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967295ULL))>>64;
x31 = (x29)+((x12)*((uintptr_t)4294967294ULL));
x32 = ((x31)<(x29))+(x27);
x33 = (x32)+(x25);
x34 = (((x32)<(x27))+((x33)<(x25)))+(x26);
x35 = (x34)+(x23);
x36 = (((x34)<(x26))+((x35)<(x23)))+(x24);
x37 = (x36)+(x21);
x38 = (((x36)<(x24))+((x37)<(x21)))+(x22);
x39 = (x38)+(x19);
x40 = (((x38)<(x22))+((x39)<(x19)))+(x20);
x41 = (x40)+(x17);
x42 = (((x40)<(x20))+((x41)<(x17)))+(x18);
x43 = (x42)+(x15);
x44 = (((x42)<(x18))+((x43)<(x15)))+(x16);
x45 = (x44)+(x13);
x46 = ((x44)<(x16))+((x45)<(x13));
x47 = ((x12)+((x12)*((uintptr_t)4294967295ULL)))<(x12);
x48 = ((x47)+(x30))+(x1);
x49 = (x48)<((x47)+(x30));
x50 = (x48)*((uintptr_t)4294967295ULL);
x51 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x52 = (x48)*((uintptr_t)4294967295ULL);
x53 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x54 = (x48)*((uintptr_t)4294967295ULL);
x55 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x56 = (x48)*((uintptr_t)4294967295ULL);
x57 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x58 = (x48)*((uintptr_t)4294967295ULL);
x59 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x60 = (x48)*((uintptr_t)4294967295ULL);
x61 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x62 = (x48)*((uintptr_t)4294967295ULL);
x63 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x64 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967294ULL))>>64;
x65 = (x48)*((uintptr_t)4294967295ULL);
x66 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x67 = sizeof(intptr_t) == 4 ? ((uint64_t)(x48)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x48)*((uintptr_t)4294967295ULL))>>64;
x68 = (x66)+((x48)*((uintptr_t)4294967294ULL));
x69 = ((x68)<(x66))+(x64);
x70 = (x69)+(x62);
x71 = (((x69)<(x64))+((x70)<(x62)))+(x63);
x72 = (x71)+(x60);
x73 = (((x71)<(x63))+((x72)<(x60)))+(x61);
x74 = (x73)+(x58);
x75 = (((x73)<(x61))+((x74)<(x58)))+(x59);
x76 = (x75)+(x56);
x77 = (((x75)<(x59))+((x76)<(x56)))+(x57);
x78 = (x77)+(x54);
x79 = (((x77)<(x57))+((x78)<(x54)))+(x55);
x80 = (x79)+(x52);
x81 = (((x79)<(x55))+((x80)<(x52)))+(x53);
x82 = (x81)+(x50);
x83 = ((x81)<(x53))+((x82)<(x50));
x84 = (((x48)+((x48)*((uintptr_t)4294967295ULL)))<(x48))+(x49);
x85 = (x84)+(x67);
x86 = (((x84)<(x49))+((x85)<(x67)))+(x28);
x87 = ((x86)<(x28))+(x31);
x88 = (x87)+(x65);
x89 = (((x87)<(x31))+((x88)<(x65)))+(x33);
x90 = (x89)+(x68);
x91 = (((x89)<(x33))+((x90)<(x68)))+(x35);
x92 = (x91)+(x70);
x93 = (((x91)<(x35))+((x92)<(x70)))+(x37);
x94 = (x93)+(x72);
x95 = (((x93)<(x37))+((x94)<(x72)))+(x39);
x96 = (x95)+(x74);
x97 = (((x95)<(x39))+((x96)<(x74)))+(x41);
x98 = (x97)+(x76);
x99 = (((x97)<(x41))+((x98)<(x76)))+(x43);
x100 = (x99)+(x78);
x101 = (((x99)<(x43))+((x100)<(x78)))+(x45);
x102 = (x101)+(x80);
x103 = (((x101)<(x45))+((x102)<(x80)))+((x46)+(x14));
x104 = (x103)+(x82);
x105 = (((x103)<((x46)+(x14)))+((x104)<(x82)))+((x83)+(x51));
x106 = (x105)<((x83)+(x51));
x107 = (x85)+(x2);
x108 = ((x107)<(x85))+(x86);
x109 = ((x108)<(x86))+(x88);
x110 = ((x109)<(x88))+(x90);
x111 = ((x110)<(x90))+(x92);
x112 = ((x111)<(x92))+(x94);
x113 = ((x112)<(x94))+(x96);
x114 = ((x113)<(x96))+(x98);
x115 = ((x114)<(x98))+(x100);
x116 = ((x115)<(x100))+(x102);
x117 = ((x116)<(x102))+(x104);
x118 = ((x117)<(x104))+(x105);
x119 = (x118)<(x105);
x120 = (x107)*((uintptr_t)4294967295ULL);
x121 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x122 = (x107)*((uintptr_t)4294967295ULL);
x123 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x124 = (x107)*((uintptr_t)4294967295ULL);
x125 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x126 = (x107)*((uintptr_t)4294967295ULL);
x127 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x128 = (x107)*((uintptr_t)4294967295ULL);
x129 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x130 = (x107)*((uintptr_t)4294967295ULL);
x131 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x132 = (x107)*((uintptr_t)4294967295ULL);
x133 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x134 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967294ULL))>>64;
x135 = (x107)*((uintptr_t)4294967295ULL);
x136 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x137 = sizeof(intptr_t) == 4 ? ((uint64_t)(x107)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x107)*((uintptr_t)4294967295ULL))>>64;
x138 = (x136)+((x107)*((uintptr_t)4294967294ULL));
x139 = ((x138)<(x136))+(x134);
x140 = (x139)+(x132);
x141 = (((x139)<(x134))+((x140)<(x132)))+(x133);
x142 = (x141)+(x130);
x143 = (((x141)<(x133))+((x142)<(x130)))+(x131);
x144 = (x143)+(x128);
x145 = (((x143)<(x131))+((x144)<(x128)))+(x129);
x146 = (x145)+(x126);
x147 = (((x145)<(x129))+((x146)<(x126)))+(x127);
x148 = (x147)+(x124);
x149 = (((x147)<(x127))+((x148)<(x124)))+(x125);
x150 = (x149)+(x122);
x151 = (((x149)<(x125))+((x150)<(x122)))+(x123);
x152 = (x151)+(x120);
x153 = ((x151)<(x123))+((x152)<(x120));
x154 = (((x107)+((x107)*((uintptr_t)4294967295ULL)))<(x107))+(x108);
x155 = (x154)+(x137);
x156 = (((x154)<(x108))+((x155)<(x137)))+(x109);
x157 = ((x156)<(x109))+(x110);
x158 = (x157)+(x135);
x159 = (((x157)<(x110))+((x158)<(x135)))+(x111);
x160 = (x159)+(x138);
x161 = (((x159)<(x111))+((x160)<(x138)))+(x112);
x162 = (x161)+(x140);
x163 = (((x161)<(x112))+((x162)<(x140)))+(x113);
x164 = (x163)+(x142);
x165 = (((x163)<(x113))+((x164)<(x142)))+(x114);
x166 = (x165)+(x144);
x167 = (((x165)<(x114))+((x166)<(x144)))+(x115);
x168 = (x167)+(x146);
x169 = (((x167)<(x115))+((x168)<(x146)))+(x116);
x170 = (x169)+(x148);
x171 = (((x169)<(x116))+((x170)<(x148)))+(x117);
x172 = (x171)+(x150);
x173 = (((x171)<(x117))+((x172)<(x150)))+(x118);
x174 = (x173)+(x152);
x175 = (((x173)<(x118))+((x174)<(x152)))+((x119)+(x106));
x176 = (x175)+((x153)+(x121));
x177 = ((x175)<((x119)+(x106)))+((x176)<((x153)+(x121)));
x178 = (x155)+(x3);
x179 = ((x178)<(x155))+(x156);
x180 = ((x179)<(x156))+(x158);
x181 = ((x180)<(x158))+(x160);
x182 = ((x181)<(x160))+(x162);
x183 = ((x182)<(x162))+(x164);
x184 = ((x183)<(x164))+(x166);
x185 = ((x184)<(x166))+(x168);
x186 = ((x185)<(x168))+(x170);
x187 = ((x186)<(x170))+(x172);
x188 = ((x187)<(x172))+(x174);
x189 = ((x188)<(x174))+(x176);
x190 = (x189)<(x176);
x191 = (x178)*((uintptr_t)4294967295ULL);
x192 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x193 = (x178)*((uintptr_t)4294967295ULL);
x194 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x195 = (x178)*((uintptr_t)4294967295ULL);
x196 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x197 = (x178)*((uintptr_t)4294967295ULL);
x198 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x199 = (x178)*((uintptr_t)4294967295ULL);
x200 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x201 = (x178)*((uintptr_t)4294967295ULL);
x202 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x203 = (x178)*((uintptr_t)4294967295ULL);
x204 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x205 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967294ULL))>>64;
x206 = (x178)*((uintptr_t)4294967295ULL);
x207 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x208 = sizeof(intptr_t) == 4 ? ((uint64_t)(x178)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x178)*((uintptr_t)4294967295ULL))>>64;
x209 = (x207)+((x178)*((uintptr_t)4294967294ULL));
x210 = ((x209)<(x207))+(x205);
x211 = (x210)+(x203);
x212 = (((x210)<(x205))+((x211)<(x203)))+(x204);
x213 = (x212)+(x201);
x214 = (((x212)<(x204))+((x213)<(x201)))+(x202);
x215 = (x214)+(x199);
x216 = (((x214)<(x202))+((x215)<(x199)))+(x200);
x217 = (x216)+(x197);
x218 = (((x216)<(x200))+((x217)<(x197)))+(x198);
x219 = (x218)+(x195);
x220 = (((x218)<(x198))+((x219)<(x195)))+(x196);
x221 = (x220)+(x193);
x222 = (((x220)<(x196))+((x221)<(x193)))+(x194);
x223 = (x222)+(x191);
x224 = ((x222)<(x194))+((x223)<(x191));
x225 = (((x178)+((x178)*((uintptr_t)4294967295ULL)))<(x178))+(x179);
x226 = (x225)+(x208);
x227 = (((x225)<(x179))+((x226)<(x208)))+(x180);
x228 = ((x227)<(x180))+(x181);
x229 = (x228)+(x206);
x230 = (((x228)<(x181))+((x229)<(x206)))+(x182);
x231 = (x230)+(x209);
x232 = (((x230)<(x182))+((x231)<(x209)))+(x183);
x233 = (x232)+(x211);
x234 = (((x232)<(x183))+((x233)<(x211)))+(x184);
x235 = (x234)+(x213);
x236 = (((x234)<(x184))+((x235)<(x213)))+(x185);
x237 = (x236)+(x215);
x238 = (((x236)<(x185))+((x237)<(x215)))+(x186);
x239 = (x238)+(x217);
x240 = (((x238)<(x186))+((x239)<(x217)))+(x187);
x241 = (x240)+(x219);
x242 = (((x240)<(x187))+((x241)<(x219)))+(x188);
x243 = (x242)+(x221);
x244 = (((x242)<(x188))+((x243)<(x221)))+(x189);
x245 = (x244)+(x223);
x246 = (((x244)<(x189))+((x245)<(x223)))+((x190)+(x177));
x247 = (x246)+((x224)+(x192));
x248 = ((x246)<((x190)+(x177)))+((x247)<((x224)+(x192)));
x249 = (x226)+(x4);
x250 = ((x249)<(x226))+(x227);
x251 = ((x250)<(x227))+(x229);
x252 = ((x251)<(x229))+(x231);
x253 = ((x252)<(x231))+(x233);
x254 = ((x253)<(x233))+(x235);
x255 = ((x254)<(x235))+(x237);
x256 = ((x255)<(x237))+(x239);
x257 = ((x256)<(x239))+(x241);
x258 = ((x257)<(x241))+(x243);
x259 = ((x258)<(x243))+(x245);
x260 = ((x259)<(x245))+(x247);
x261 = (x260)<(x247);
x262 = (x249)*((uintptr_t)4294967295ULL);
x263 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x264 = (x249)*((uintptr_t)4294967295ULL);
x265 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x266 = (x249)*((uintptr_t)4294967295ULL);
x267 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x268 = (x249)*((uintptr_t)4294967295ULL);
x269 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x270 = (x249)*((uintptr_t)4294967295ULL);
x271 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x272 = (x249)*((uintptr_t)4294967295ULL);
x273 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x274 = (x249)*((uintptr_t)4294967295ULL);
x275 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x276 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967294ULL))>>64;
x277 = (x249)*((uintptr_t)4294967295ULL);
x278 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x279 = sizeof(intptr_t) == 4 ? ((uint64_t)(x249)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x249)*((uintptr_t)4294967295ULL))>>64;
x280 = (x278)+((x249)*((uintptr_t)4294967294ULL));
x281 = ((x280)<(x278))+(x276);
x282 = (x281)+(x274);
x283 = (((x281)<(x276))+((x282)<(x274)))+(x275);
x284 = (x283)+(x272);
x285 = (((x283)<(x275))+((x284)<(x272)))+(x273);
x286 = (x285)+(x270);
x287 = (((x285)<(x273))+((x286)<(x270)))+(x271);
x288 = (x287)+(x268);
x289 = (((x287)<(x271))+((x288)<(x268)))+(x269);
x290 = (x289)+(x266);
x291 = (((x289)<(x269))+((x290)<(x266)))+(x267);
x292 = (x291)+(x264);
x293 = (((x291)<(x267))+((x292)<(x264)))+(x265);
x294 = (x293)+(x262);
x295 = ((x293)<(x265))+((x294)<(x262));
x296 = (((x249)+((x249)*((uintptr_t)4294967295ULL)))<(x249))+(x250);
x297 = (x296)+(x279);
x298 = (((x296)<(x250))+((x297)<(x279)))+(x251);
x299 = ((x298)<(x251))+(x252);
x300 = (x299)+(x277);
x301 = (((x299)<(x252))+((x300)<(x277)))+(x253);
x302 = (x301)+(x280);
x303 = (((x301)<(x253))+((x302)<(x280)))+(x254);
x304 = (x303)+(x282);
x305 = (((x303)<(x254))+((x304)<(x282)))+(x255);
x306 = (x305)+(x284);
x307 = (((x305)<(x255))+((x306)<(x284)))+(x256);
x308 = (x307)+(x286);
x309 = (((x307)<(x256))+((x308)<(x286)))+(x257);
x310 = (x309)+(x288);
x311 = (((x309)<(x257))+((x310)<(x288)))+(x258);
x312 = (x311)+(x290);
x313 = (((x311)<(x258))+((x312)<(x290)))+(x259);
x314 = (x313)+(x292);
x315 = (((x313)<(x259))+((x314)<(x292)))+(x260);
x316 = (x315)+(x294);
x317 = (((x315)<(x260))+((x316)<(x294)))+((x261)+(x248));
x318 = (x317)+((x295)+(x263));
x319 = ((x317)<((x261)+(x248)))+((x318)<((x295)+(x263)));
x320 = (x297)+(x5);
x321 = ((x320)<(x297))+(x298);
x322 = ((x321)<(x298))+(x300);
x323 = ((x322)<(x300))+(x302);
x324 = ((x323)<(x302))+(x304);
x325 = ((x324)<(x304))+(x306);
x326 = ((x325)<(x306))+(x308);
x327 = ((x326)<(x308))+(x310);
x328 = ((x327)<(x310))+(x312);
x329 = ((x328)<(x312))+(x314);
x330 = ((x329)<(x314))+(x316);
x331 = ((x330)<(x316))+(x318);
x332 = (x331)<(x318);
x333 = (x320)*((uintptr_t)4294967295ULL);
x334 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x335 = (x320)*((uintptr_t)4294967295ULL);
x336 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x337 = (x320)*((uintptr_t)4294967295ULL);
x338 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x339 = (x320)*((uintptr_t)4294967295ULL);
x340 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x341 = (x320)*((uintptr_t)4294967295ULL);
x342 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x343 = (x320)*((uintptr_t)4294967295ULL);
x344 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x345 = (x320)*((uintptr_t)4294967295ULL);
x346 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x347 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967294ULL))>>64;
x348 = (x320)*((uintptr_t)4294967295ULL);
x349 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x350 = sizeof(intptr_t) == 4 ? ((uint64_t)(x320)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x320)*((uintptr_t)4294967295ULL))>>64;
x351 = (x349)+((x320)*((uintptr_t)4294967294ULL));
x352 = ((x351)<(x349))+(x347);
x353 = (x352)+(x345);
x354 = (((x352)<(x347))+((x353)<(x345)))+(x346);
x355 = (x354)+(x343);
x356 = (((x354)<(x346))+((x355)<(x343)))+(x344);
x357 = (x356)+(x341);
x358 = (((x356)<(x344))+((x357)<(x341)))+(x342);
x359 = (x358)+(x339);
x360 = (((x358)<(x342))+((x359)<(x339)))+(x340);
x361 = (x360)+(x337);
x362 = (((x360)<(x340))+((x361)<(x337)))+(x338);
x363 = (x362)+(x335);
x364 = (((x362)<(x338))+((x363)<(x335)))+(x336);
x365 = (x364)+(x333);
x366 = ((x364)<(x336))+((x365)<(x333));
x367 = (((x320)+((x320)*((uintptr_t)4294967295ULL)))<(x320))+(x321);
x368 = (x367)+(x350);
x369 = (((x367)<(x321))+((x368)<(x350)))+(x322);
x370 = ((x369)<(x322))+(x323);
x371 = (x370)+(x348);
x372 = (((x370)<(x323))+((x371)<(x348)))+(x324);
x373 = (x372)+(x351);
x374 = (((x372)<(x324))+((x373)<(x351)))+(x325);
x375 = (x374)+(x353);
x376 = (((x374)<(x325))+((x375)<(x353)))+(x326);
x377 = (x376)+(x355);
x378 = (((x376)<(x326))+((x377)<(x355)))+(x327);
x379 = (x378)+(x357);
x380 = (((x378)<(x327))+((x379)<(x357)))+(x328);
x381 = (x380)+(x359);
x382 = (((x380)<(x328))+((x381)<(x359)))+(x329);
x383 = (x382)+(x361);
x384 = (((x382)<(x329))+((x383)<(x361)))+(x330);
x385 = (x384)+(x363);
x386 = (((x384)<(x330))+((x385)<(x363)))+(x331);
x387 = (x386)+(x365);
x388 = (((x386)<(x331))+((x387)<(x365)))+((x332)+(x319));
x389 = (x388)+((x366)+(x334));
x390 = ((x388)<((x332)+(x319)))+((x389)<((x366)+(x334)));
x391 = (x368)+(x6);
x392 = ((x391)<(x368))+(x369);
x393 = ((x392)<(x369))+(x371);
x394 = ((x393)<(x371))+(x373);
x395 = ((x394)<(x373))+(x375);
x396 = ((x395)<(x375))+(x377);
x397 = ((x396)<(x377))+(x379);
x398 = ((x397)<(x379))+(x381);
x399 = ((x398)<(x381))+(x383);
x400 = ((x399)<(x383))+(x385);
x401 = ((x400)<(x385))+(x387);
x402 = ((x401)<(x387))+(x389);
x403 = (x402)<(x389);
x404 = (x391)*((uintptr_t)4294967295ULL);
x405 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x406 = (x391)*((uintptr_t)4294967295ULL);
x407 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x408 = (x391)*((uintptr_t)4294967295ULL);
x409 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x410 = (x391)*((uintptr_t)4294967295ULL);
x411 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x412 = (x391)*((uintptr_t)4294967295ULL);
x413 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x414 = (x391)*((uintptr_t)4294967295ULL);
x415 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x416 = (x391)*((uintptr_t)4294967295ULL);
x417 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x418 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967294ULL))>>64;
x419 = (x391)*((uintptr_t)4294967295ULL);
x420 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x421 = sizeof(intptr_t) == 4 ? ((uint64_t)(x391)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x391)*((uintptr_t)4294967295ULL))>>64;
x422 = (x420)+((x391)*((uintptr_t)4294967294ULL));
x423 = ((x422)<(x420))+(x418);
x424 = (x423)+(x416);
x425 = (((x423)<(x418))+((x424)<(x416)))+(x417);
x426 = (x425)+(x414);
x427 = (((x425)<(x417))+((x426)<(x414)))+(x415);
x428 = (x427)+(x412);
x429 = (((x427)<(x415))+((x428)<(x412)))+(x413);
x430 = (x429)+(x410);
x431 = (((x429)<(x413))+((x430)<(x410)))+(x411);
x432 = (x431)+(x408);
x433 = (((x431)<(x411))+((x432)<(x408)))+(x409);
x434 = (x433)+(x406);
x435 = (((x433)<(x409))+((x434)<(x406)))+(x407);
x436 = (x435)+(x404);
x437 = ((x435)<(x407))+((x436)<(x404));
x438 = (((x391)+((x391)*((uintptr_t)4294967295ULL)))<(x391))+(x392);
x439 = (x438)+(x421);
x440 = (((x438)<(x392))+((x439)<(x421)))+(x393);
x441 = ((x440)<(x393))+(x394);
x442 = (x441)+(x419);
x443 = (((x441)<(x394))+((x442)<(x419)))+(x395);
x444 = (x443)+(x422);
x445 = (((x443)<(x395))+((x444)<(x422)))+(x396);
x446 = (x445)+(x424);
x447 = (((x445)<(x396))+((x446)<(x424)))+(x397);
x448 = (x447)+(x426);
x449 = (((x447)<(x397))+((x448)<(x426)))+(x398);
x450 = (x449)+(x428);
x451 = (((x449)<(x398))+((x450)<(x428)))+(x399);
x452 = (x451)+(x430);
x453 = (((x451)<(x399))+((x452)<(x430)))+(x400);
x454 = (x453)+(x432);
x455 = (((x453)<(x400))+((x454)<(x432)))+(x401);
x456 = (x455)+(x434);
x457 = (((x455)<(x401))+((x456)<(x434)))+(x402);
x458 = (x457)+(x436);
x459 = (((x457)<(x402))+((x458)<(x436)))+((x403)+(x390));
x460 = (x459)+((x437)+(x405));
x461 = ((x459)<((x403)+(x390)))+((x460)<((x437)+(x405)));
x462 = (x439)+(x7);
x463 = ((x462)<(x439))+(x440);
x464 = ((x463)<(x440))+(x442);
x465 = ((x464)<(x442))+(x444);
x466 = ((x465)<(x444))+(x446);
x467 = ((x466)<(x446))+(x448);
x468 = ((x467)<(x448))+(x450);
x469 = ((x468)<(x450))+(x452);
x470 = ((x469)<(x452))+(x454);
x471 = ((x470)<(x454))+(x456);
x472 = ((x471)<(x456))+(x458);
x473 = ((x472)<(x458))+(x460);
x474 = (x473)<(x460);
x475 = (x462)*((uintptr_t)4294967295ULL);
x476 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x477 = (x462)*((uintptr_t)4294967295ULL);
x478 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x479 = (x462)*((uintptr_t)4294967295ULL);
x480 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x481 = (x462)*((uintptr_t)4294967295ULL);
x482 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x483 = (x462)*((uintptr_t)4294967295ULL);
x484 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x485 = (x462)*((uintptr_t)4294967295ULL);
x486 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x487 = (x462)*((uintptr_t)4294967295ULL);
x488 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x489 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967294ULL))>>64;
x490 = (x462)*((uintptr_t)4294967295ULL);
x491 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x492 = sizeof(intptr_t) == 4 ? ((uint64_t)(x462)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x462)*((uintptr_t)4294967295ULL))>>64;
x493 = (x491)+((x462)*((uintptr_t)4294967294ULL));
x494 = ((x493)<(x491))+(x489);
x495 = (x494)+(x487);
x496 = (((x494)<(x489))+((x495)<(x487)))+(x488);
x497 = (x496)+(x485);
x498 = (((x496)<(x488))+((x497)<(x485)))+(x486);
x499 = (x498)+(x483);
x500 = (((x498)<(x486))+((x499)<(x483)))+(x484);
x501 = (x500)+(x481);
x502 = (((x500)<(x484))+((x501)<(x481)))+(x482);
x503 = (x502)+(x479);
x504 = (((x502)<(x482))+((x503)<(x479)))+(x480);
x505 = (x504)+(x477);
x506 = (((x504)<(x480))+((x505)<(x477)))+(x478);
x507 = (x506)+(x475);
x508 = ((x506)<(x478))+((x507)<(x475));
x509 = (((x462)+((x462)*((uintptr_t)4294967295ULL)))<(x462))+(x463);
x510 = (x509)+(x492);
x511 = (((x509)<(x463))+((x510)<(x492)))+(x464);
x512 = ((x511)<(x464))+(x465);
x513 = (x512)+(x490);
x514 = (((x512)<(x465))+((x513)<(x490)))+(x466);
x515 = (x514)+(x493);
x516 = (((x514)<(x466))+((x515)<(x493)))+(x467);
x517 = (x516)+(x495);
x518 = (((x516)<(x467))+((x517)<(x495)))+(x468);
x519 = (x518)+(x497);
x520 = (((x518)<(x468))+((x519)<(x497)))+(x469);
x521 = (x520)+(x499);
x522 = (((x520)<(x469))+((x521)<(x499)))+(x470);
x523 = (x522)+(x501);
x524 = (((x522)<(x470))+((x523)<(x501)))+(x471);
x525 = (x524)+(x503);
x526 = (((x524)<(x471))+((x525)<(x503)))+(x472);
x527 = (x526)+(x505);
x528 = (((x526)<(x472))+((x527)<(x505)))+(x473);
x529 = (x528)+(x507);
x530 = (((x528)<(x473))+((x529)<(x507)))+((x474)+(x461));
x531 = (x530)+((x508)+(x476));
x532 = ((x530)<((x474)+(x461)))+((x531)<((x508)+(x476)));
x533 = (x510)+(x8);
x534 = ((x533)<(x510))+(x511);
x535 = ((x534)<(x511))+(x513);
x536 = ((x535)<(x513))+(x515);
x537 = ((x536)<(x515))+(x517);
x538 = ((x537)<(x517))+(x519);
x539 = ((x538)<(x519))+(x521);
x540 = ((x539)<(x521))+(x523);
x541 = ((x540)<(x523))+(x525);
x542 = ((x541)<(x525))+(x527);
x543 = ((x542)<(x527))+(x529);
x544 = ((x543)<(x529))+(x531);
x545 = (x544)<(x531);
x546 = (x533)*((uintptr_t)4294967295ULL);
x547 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x548 = (x533)*((uintptr_t)4294967295ULL);
x549 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x550 = (x533)*((uintptr_t)4294967295ULL);
x551 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x552 = (x533)*((uintptr_t)4294967295ULL);
x553 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x554 = (x533)*((uintptr_t)4294967295ULL);
x555 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x556 = (x533)*((uintptr_t)4294967295ULL);
x557 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x558 = (x533)*((uintptr_t)4294967295ULL);
x559 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x560 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967294ULL))>>64;
x561 = (x533)*((uintptr_t)4294967295ULL);
x562 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x563 = sizeof(intptr_t) == 4 ? ((uint64_t)(x533)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x533)*((uintptr_t)4294967295ULL))>>64;
x564 = (x562)+((x533)*((uintptr_t)4294967294ULL));
x565 = ((x564)<(x562))+(x560);
x566 = (x565)+(x558);
x567 = (((x565)<(x560))+((x566)<(x558)))+(x559);
x568 = (x567)+(x556);
x569 = (((x567)<(x559))+((x568)<(x556)))+(x557);
x570 = (x569)+(x554);
x571 = (((x569)<(x557))+((x570)<(x554)))+(x555);
x572 = (x571)+(x552);
x573 = (((x571)<(x555))+((x572)<(x552)))+(x553);
x574 = (x573)+(x550);
x575 = (((x573)<(x553))+((x574)<(x550)))+(x551);
x576 = (x575)+(x548);
x577 = (((x575)<(x551))+((x576)<(x548)))+(x549);
x578 = (x577)+(x546);
x579 = ((x577)<(x549))+((x578)<(x546));
x580 = (((x533)+((x533)*((uintptr_t)4294967295ULL)))<(x533))+(x534);
x581 = (x580)+(x563);
x582 = (((x580)<(x534))+((x581)<(x563)))+(x535);
x583 = ((x582)<(x535))+(x536);
x584 = (x583)+(x561);
x585 = (((x583)<(x536))+((x584)<(x561)))+(x537);
x586 = (x585)+(x564);
x587 = (((x585)<(x537))+((x586)<(x564)))+(x538);
x588 = (x587)+(x566);
x589 = (((x587)<(x538))+((x588)<(x566)))+(x539);
x590 = (x589)+(x568);
x591 = (((x589)<(x539))+((x590)<(x568)))+(x540);
x592 = (x591)+(x570);
x593 = (((x591)<(x540))+((x592)<(x570)))+(x541);
x594 = (x593)+(x572);
x595 = (((x593)<(x541))+((x594)<(x572)))+(x542);
x596 = (x595)+(x574);
x597 = (((x595)<(x542))+((x596)<(x574)))+(x543);
x598 = (x597)+(x576);
x599 = (((x597)<(x543))+((x598)<(x576)))+(x544);
x600 = (x599)+(x578);
x601 = (((x599)<(x544))+((x600)<(x578)))+((x545)+(x532));
x602 = (x601)+((x579)+(x547));
x603 = ((x601)<((x545)+(x532)))+((x602)<((x579)+(x547)));
x604 = (x581)+(x9);
x605 = ((x604)<(x581))+(x582);
x606 = ((x605)<(x582))+(x584);
x607 = ((x606)<(x584))+(x586);
x608 = ((x607)<(x586))+(x588);
x609 = ((x608)<(x588))+(x590);
x610 = ((x609)<(x590))+(x592);
x611 = ((x610)<(x592))+(x594);
x612 = ((x611)<(x594))+(x596);
x613 = ((x612)<(x596))+(x598);
x614 = ((x613)<(x598))+(x600);
x615 = ((x614)<(x600))+(x602);
x616 = (x615)<(x602);
x617 = (x604)*((uintptr_t)4294967295ULL);
x618 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x619 = (x604)*((uintptr_t)4294967295ULL);
x620 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x621 = (x604)*((uintptr_t)4294967295ULL);
x622 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x623 = (x604)*((uintptr_t)4294967295ULL);
x624 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x625 = (x604)*((uintptr_t)4294967295ULL);
x626 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x627 = (x604)*((uintptr_t)4294967295ULL);
x628 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x629 = (x604)*((uintptr_t)4294967295ULL);
x630 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x631 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967294ULL))>>64;
x632 = (x604)*((uintptr_t)4294967295ULL);
x633 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x634 = sizeof(intptr_t) == 4 ? ((uint64_t)(x604)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x604)*((uintptr_t)4294967295ULL))>>64;
x635 = (x633)+((x604)*((uintptr_t)4294967294ULL));
x636 = ((x635)<(x633))+(x631);
x637 = (x636)+(x629);
x638 = (((x636)<(x631))+((x637)<(x629)))+(x630);
x639 = (x638)+(x627);
x640 = (((x638)<(x630))+((x639)<(x627)))+(x628);
x641 = (x640)+(x625);
x642 = (((x640)<(x628))+((x641)<(x625)))+(x626);
x643 = (x642)+(x623);
x644 = (((x642)<(x626))+((x643)<(x623)))+(x624);
x645 = (x644)+(x621);
x646 = (((x644)<(x624))+((x645)<(x621)))+(x622);
x647 = (x646)+(x619);
x648 = (((x646)<(x622))+((x647)<(x619)))+(x620);
x649 = (x648)+(x617);
x650 = ((x648)<(x620))+((x649)<(x617));
x651 = (((x604)+((x604)*((uintptr_t)4294967295ULL)))<(x604))+(x605);
x652 = (x651)+(x634);
x653 = (((x651)<(x605))+((x652)<(x634)))+(x606);
x654 = ((x653)<(x606))+(x607);
x655 = (x654)+(x632);
x656 = (((x654)<(x607))+((x655)<(x632)))+(x608);
x657 = (x656)+(x635);
x658 = (((x656)<(x608))+((x657)<(x635)))+(x609);
x659 = (x658)+(x637);
x660 = (((x658)<(x609))+((x659)<(x637)))+(x610);
x661 = (x660)+(x639);
x662 = (((x660)<(x610))+((x661)<(x639)))+(x611);
x663 = (x662)+(x641);
x664 = (((x662)<(x611))+((x663)<(x641)))+(x612);
x665 = (x664)+(x643);
x666 = (((x664)<(x612))+((x665)<(x643)))+(x613);
x667 = (x666)+(x645);
x668 = (((x666)<(x613))+((x667)<(x645)))+(x614);
x669 = (x668)+(x647);
x670 = (((x668)<(x614))+((x669)<(x647)))+(x615);
x671 = (x670)+(x649);
x672 = (((x670)<(x615))+((x671)<(x649)))+((x616)+(x603));
x673 = (x672)+((x650)+(x618));
x674 = ((x672)<((x616)+(x603)))+((x673)<((x650)+(x618)));
x675 = (x652)+(x10);
x676 = ((x675)<(x652))+(x653);
x677 = ((x676)<(x653))+(x655);
x678 = ((x677)<(x655))+(x657);
x679 = ((x678)<(x657))+(x659);
x680 = ((x679)<(x659))+(x661);
x681 = ((x680)<(x661))+(x663);
x682 = ((x681)<(x663))+(x665);
x683 = ((x682)<(x665))+(x667);
x684 = ((x683)<(x667))+(x669);
x685 = ((x684)<(x669))+(x671);
x686 = ((x685)<(x671))+(x673);
x687 = (x686)<(x673);
x688 = (x675)*((uintptr_t)4294967295ULL);
x689 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x690 = (x675)*((uintptr_t)4294967295ULL);
x691 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x692 = (x675)*((uintptr_t)4294967295ULL);
x693 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x694 = (x675)*((uintptr_t)4294967295ULL);
x695 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x696 = (x675)*((uintptr_t)4294967295ULL);
x697 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x698 = (x675)*((uintptr_t)4294967295ULL);
x699 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x700 = (x675)*((uintptr_t)4294967295ULL);
x701 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x702 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967294ULL))>>64;
x703 = (x675)*((uintptr_t)4294967295ULL);
x704 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x705 = sizeof(intptr_t) == 4 ? ((uint64_t)(x675)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x675)*((uintptr_t)4294967295ULL))>>64;
x706 = (x704)+((x675)*((uintptr_t)4294967294ULL));
x707 = ((x706)<(x704))+(x702);
x708 = (x707)+(x700);
x709 = (((x707)<(x702))+((x708)<(x700)))+(x701);
x710 = (x709)+(x698);
x711 = (((x709)<(x701))+((x710)<(x698)))+(x699);
x712 = (x711)+(x696);
x713 = (((x711)<(x699))+((x712)<(x696)))+(x697);
x714 = (x713)+(x694);
x715 = (((x713)<(x697))+((x714)<(x694)))+(x695);
x716 = (x715)+(x692);
x717 = (((x715)<(x695))+((x716)<(x692)))+(x693);
x718 = (x717)+(x690);
x719 = (((x717)<(x693))+((x718)<(x690)))+(x691);
x720 = (x719)+(x688);
x721 = ((x719)<(x691))+((x720)<(x688));
x722 = (((x675)+((x675)*((uintptr_t)4294967295ULL)))<(x675))+(x676);
x723 = (x722)+(x705);
x724 = (((x722)<(x676))+((x723)<(x705)))+(x677);
x725 = ((x724)<(x677))+(x678);
x726 = (x725)+(x703);
x727 = (((x725)<(x678))+((x726)<(x703)))+(x679);
x728 = (x727)+(x706);
x729 = (((x727)<(x679))+((x728)<(x706)))+(x680);
x730 = (x729)+(x708);
x731 = (((x729)<(x680))+((x730)<(x708)))+(x681);
x732 = (x731)+(x710);
x733 = (((x731)<(x681))+((x732)<(x710)))+(x682);
x734 = (x733)+(x712);
x735 = (((x733)<(x682))+((x734)<(x712)))+(x683);
x736 = (x735)+(x714);
x737 = (((x735)<(x683))+((x736)<(x714)))+(x684);
x738 = (x737)+(x716);
x739 = (((x737)<(x684))+((x738)<(x716)))+(x685);
x740 = (x739)+(x718);
x741 = (((x739)<(x685))+((x740)<(x718)))+(x686);
x742 = (x741)+(x720);
x743 = (((x741)<(x686))+((x742)<(x720)))+((x687)+(x674));
x744 = (x743)+((x721)+(x689));
x745 = ((x743)<((x687)+(x674)))+((x744)<((x721)+(x689)));
x746 = (x723)+(x11);
x747 = ((x746)<(x723))+(x724);
x748 = ((x747)<(x724))+(x726);
x749 = ((x748)<(x726))+(x728);
x750 = ((x749)<(x728))+(x730);
x751 = ((x750)<(x730))+(x732);
x752 = ((x751)<(x732))+(x734);
x753 = ((x752)<(x734))+(x736);
x754 = ((x753)<(x736))+(x738);
x755 = ((x754)<(x738))+(x740);
x756 = ((x755)<(x740))+(x742);
x757 = ((x756)<(x742))+(x744);
x758 = (x757)<(x744);
x759 = (x746)*((uintptr_t)4294967295ULL);
x760 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x761 = (x746)*((uintptr_t)4294967295ULL);
x762 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x763 = (x746)*((uintptr_t)4294967295ULL);
x764 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x765 = (x746)*((uintptr_t)4294967295ULL);
x766 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x767 = (x746)*((uintptr_t)4294967295ULL);
x768 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x769 = (x746)*((uintptr_t)4294967295ULL);
x770 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x771 = (x746)*((uintptr_t)4294967295ULL);
x772 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x773 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967294ULL))>>64;
x774 = (x746)*((uintptr_t)4294967295ULL);
x775 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x776 = sizeof(intptr_t) == 4 ? ((uint64_t)(x746)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x746)*((uintptr_t)4294967295ULL))>>64;
x777 = (x775)+((x746)*((uintptr_t)4294967294ULL));
x778 = ((x777)<(x775))+(x773);
x779 = (x778)+(x771);
x780 = (((x778)<(x773))+((x779)<(x771)))+(x772);
x781 = (x780)+(x769);
x782 = (((x780)<(x772))+((x781)<(x769)))+(x770);
x783 = (x782)+(x767);
x784 = (((x782)<(x770))+((x783)<(x767)))+(x768);
x785 = (x784)+(x765);
x786 = (((x784)<(x768))+((x785)<(x765)))+(x766);
x787 = (x786)+(x763);
x788 = (((x786)<(x766))+((x787)<(x763)))+(x764);
x789 = (x788)+(x761);
x790 = (((x788)<(x764))+((x789)<(x761)))+(x762);
x791 = (x790)+(x759);
x792 = ((x790)<(x762))+((x791)<(x759));
x793 = (((x746)+((x746)*((uintptr_t)4294967295ULL)))<(x746))+(x747);
x794 = (x793)+(x776);
x795 = (((x793)<(x747))+((x794)<(x776)))+(x748);
x796 = ((x795)<(x748))+(x749);
x797 = (x796)+(x774);
x798 = (((x796)<(x749))+((x797)<(x774)))+(x750);
x799 = (x798)+(x777);
x800 = (((x798)<(x750))+((x799)<(x777)))+(x751);
x801 = (x800)+(x779);
x802 = (((x800)<(x751))+((x801)<(x779)))+(x752);
x803 = (x802)+(x781);
x804 = (((x802)<(x752))+((x803)<(x781)))+(x753);
x805 = (x804)+(x783);
x806 = (((x804)<(x753))+((x805)<(x783)))+(x754);
x807 = (x806)+(x785);
x808 = (((x806)<(x754))+((x807)<(x785)))+(x755);
x809 = (x808)+(x787);
x810 = (((x808)<(x755))+((x809)<(x787)))+(x756);
x811 = (x810)+(x789);
x812 = (((x810)<(x756))+((x811)<(x789)))+(x757);
x813 = (x812)+(x791);
x814 = (((x812)<(x757))+((x813)<(x791)))+((x758)+(x745));
x815 = (x814)+((x792)+(x760));
x816 = ((x814)<((x758)+(x745)))+((x815)<((x792)+(x760)));
x817 = (x794)-((uintptr_t)4294967295ULL);
x818 = (x795)-(((x794)<(x817))+((x817)<(x817)));
x819 = (x797)-(((x795)<(x795))+((x795)<(x818)));
x820 = (x799)-((uintptr_t)4294967295ULL);
x821 = (x820)-(((x797)<(x797))+((x797)<(x819)));
x822 = (x801)-((uintptr_t)4294967294ULL);
x823 = (x822)-(((x799)<(x820))+((x820)<(x821)));
x824 = (x803)-((uintptr_t)4294967295ULL);
x825 = (x824)-(((x801)<(x822))+((x822)<(x823)));
x826 = (x805)-((uintptr_t)4294967295ULL);
x827 = (x826)-(((x803)<(x824))+((x824)<(x825)));
x828 = (x807)-((uintptr_t)4294967295ULL);
x829 = (x828)-(((x805)<(x826))+((x826)<(x827)));
x830 = (x809)-((uintptr_t)4294967295ULL);
x831 = (x830)-(((x807)<(x828))+((x828)<(x829)));
x832 = (x811)-((uintptr_t)4294967295ULL);
x833 = (x832)-(((x809)<(x830))+((x830)<(x831)));
x834 = (x813)-((uintptr_t)4294967295ULL);
x835 = (x834)-(((x811)<(x832))+((x832)<(x833)));
x836 = (x815)-((uintptr_t)4294967295ULL);
x837 = (x836)-(((x813)<(x834))+((x834)<(x835)));
x838 = ((x816)<(x816))+((x816)<((x816)-(((x815)<(x836))+((x836)<(x837)))));
x839 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x840 = (x839)^((uintptr_t)4294967295ULL);
x841 = ((x794)&(x839))|((x817)&(x840));
x842 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x843 = (x842)^((uintptr_t)4294967295ULL);
x844 = ((x795)&(x842))|((x818)&(x843));
x845 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x846 = (x845)^((uintptr_t)4294967295ULL);
x847 = ((x797)&(x845))|((x819)&(x846));
x848 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x849 = (x848)^((uintptr_t)4294967295ULL);
x850 = ((x799)&(x848))|((x821)&(x849));
x851 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x852 = (x851)^((uintptr_t)4294967295ULL);
x853 = ((x801)&(x851))|((x823)&(x852));
x854 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x855 = (x854)^((uintptr_t)4294967295ULL);
x856 = ((x803)&(x854))|((x825)&(x855));
x857 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x858 = (x857)^((uintptr_t)4294967295ULL);
x859 = ((x805)&(x857))|((x827)&(x858));
x860 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x861 = (x860)^((uintptr_t)4294967295ULL);
x862 = ((x807)&(x860))|((x829)&(x861));
x863 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x864 = (x863)^((uintptr_t)4294967295ULL);
x865 = ((x809)&(x863))|((x831)&(x864));
x866 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x867 = (x866)^((uintptr_t)4294967295ULL);
x868 = ((x811)&(x866))|((x833)&(x867));
x869 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x870 = (x869)^((uintptr_t)4294967295ULL);
x871 = ((x813)&(x869))|((x835)&(x870));
x872 = ((uintptr_t)-1ULL)+((x838)==((uintptr_t)0ULL));
x873 = (x872)^((uintptr_t)4294967295ULL);
x874 = ((x815)&(x872))|((x837)&(x873));
x875 = x841;
x876 = x844;
x877 = x847;
x878 = x850;
x879 = x853;
x880 = x856;
x881 = x859;
x882 = x862;
x883 = x865;
x884 = x868;
x885 = x871;
x886 = x874;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x875;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x876;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x877;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x878;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x879;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x880;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x881;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x882;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x883;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x884;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x885;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x886;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_to_montgomery(uintptr_t in0, uintptr_t out0) {
uintptr_t x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x0, x25, x49, x52, x48, x46, x54, x47, x44, x56, x45, x42, x58, x43, x40, x60, x41, x38, x62, x39, x36, x64, x37, x34, x67, x30, x50, x23, x28, x71, x29, x51, x73, x26, x53, x75, x27, x55, x77, x24, x57, x79, x32, x59, x81, x33, x61, x63, x65, x66, x35, x88, x12, x68, x98, x69, x31, x93, x100, x70, x94, x102, x72, x91, x104, x74, x92, x106, x76, x89, x108, x78, x90, x110, x80, x87, x112, x82, x95, x114, x83, x96, x84, x85, x135, x138, x133, x131, x140, x132, x129, x142, x130, x127, x144, x128, x125, x146, x126, x123, x148, x124, x121, x150, x122, x119, x97, x153, x99, x136, x101, x156, x103, x134, x158, x105, x137, x160, x107, x139, x162, x109, x141, x164, x111, x143, x166, x113, x145, x168, x115, x147, x170, x116, x149, x172, x117, x151, x174, x118, x86, x152, x120, x178, x13, x154, x188, x155, x183, x190, x157, x184, x192, x159, x181, x194, x161, x182, x196, x163, x179, x198, x165, x180, x200, x167, x177, x202, x169, x185, x204, x171, x186, x173, x175, x225, x228, x223, x221, x230, x222, x219, x232, x220, x217, x234, x218, x215, x236, x216, x213, x238, x214, x211, x240, x212, x209, x187, x243, x189, x226, x191, x246, x193, x224, x248, x195, x227, x250, x197, x229, x252, x199, x231, x254, x201, x233, x256, x203, x235, x258, x205, x237, x260, x206, x239, x262, x207, x241, x264, x208, x176, x242, x210, x268, x14, x244, x278, x245, x273, x280, x247, x274, x282, x249, x271, x284, x251, x272, x286, x253, x269, x288, x255, x270, x290, x257, x267, x292, x259, x275, x294, x261, x276, x263, x265, x315, x318, x313, x311, x320, x312, x309, x322, x310, x307, x324, x308, x305, x326, x306, x303, x328, x304, x301, x330, x302, x299, x277, x333, x279, x316, x281, x336, x283, x314, x338, x285, x317, x340, x287, x319, x342, x289, x321, x344, x291, x323, x346, x293, x325, x348, x295, x327, x350, x296, x329, x352, x297, x331, x354, x298, x266, x332, x300, x358, x15, x334, x368, x335, x363, x370, x337, x364, x372, x339, x361, x374, x341, x362, x376, x343, x359, x378, x345, x360, x380, x347, x357, x382, x349, x365, x384, x351, x366, x353, x355, x405, x408, x403, x401, x410, x402, x399, x412, x400, x397, x414, x398, x395, x416, x396, x393, x418, x394, x391, x420, x392, x389, x367, x423, x369, x406, x371, x426, x373, x404, x428, x375, x407, x430, x377, x409, x432, x379, x411, x434, x381, x413, x436, x383, x415, x438, x385, x417, x440, x386, x419, x442, x387, x421, x444, x388, x356, x422, x390, x448, x16, x424, x458, x425, x453, x460, x427, x454, x462, x429, x451, x464, x431, x452, x466, x433, x449, x468, x435, x450, x470, x437, x447, x472, x439, x455, x474, x441, x456, x443, x445, x495, x498, x493, x491, x500, x492, x489, x502, x490, x487, x504, x488, x485, x506, x486, x483, x508, x484, x481, x510, x482, x479, x457, x513, x459, x496, x461, x516, x463, x494, x518, x465, x497, x520, x467, x499, x522, x469, x501, x524, x471, x503, x526, x473, x505, x528, x475, x507, x530, x476, x509, x532, x477, x511, x534, x478, x446, x512, x480, x538, x17, x514, x548, x515, x543, x550, x517, x544, x552, x519, x541, x554, x521, x542, x556, x523, x539, x558, x525, x540, x560, x527, x537, x562, x529, x545, x564, x531, x546, x533, x535, x585, x588, x583, x581, x590, x582, x579, x592, x580, x577, x594, x578, x575, x596, x576, x573, x598, x574, x571, x600, x572, x569, x547, x603, x549, x586, x551, x606, x553, x584, x608, x555, x587, x610, x557, x589, x612, x559, x591, x614, x561, x593, x616, x563, x595, x618, x565, x597, x620, x566, x599, x622, x567, x601, x624, x568, x536, x602, x570, x628, x18, x604, x638, x605, x633, x640, x607, x634, x642, x609, x631, x644, x611, x632, x646, x613, x629, x648, x615, x630, x650, x617, x627, x652, x619, x635, x654, x621, x636, x623, x625, x675, x678, x673, x671, x680, x672, x669, x682, x670, x667, x684, x668, x665, x686, x666, x663, x688, x664, x661, x690, x662, x659, x637, x693, x639, x676, x641, x696, x643, x674, x698, x645, x677, x700, x647, x679, x702, x649, x681, x704, x651, x683, x706, x653, x685, x708, x655, x687, x710, x656, x689, x712, x657, x691, x714, x658, x626, x692, x660, x718, x19, x694, x728, x695, x723, x730, x697, x724, x732, x699, x721, x734, x701, x722, x736, x703, x719, x738, x705, x720, x740, x707, x717, x742, x709, x725, x744, x711, x726, x713, x715, x765, x768, x763, x761, x770, x762, x759, x772, x760, x757, x774, x758, x755, x776, x756, x753, x778, x754, x751, x780, x752, x749, x727, x783, x729, x766, x731, x786, x733, x764, x788, x735, x767, x790, x737, x769, x792, x739, x771, x794, x741, x773, x796, x743, x775, x798, x745, x777, x800, x746, x779, x802, x747, x781, x804, x748, x716, x782, x750, x808, x20, x784, x818, x785, x813, x820, x787, x814, x822, x789, x811, x824, x791, x812, x826, x793, x809, x828, x795, x810, x830, x797, x807, x832, x799, x815, x834, x801, x816, x803, x805, x855, x858, x853, x851, x860, x852, x849, x862, x850, x847, x864, x848, x845, x866, x846, x843, x868, x844, x841, x870, x842, x839, x817, x873, x819, x856, x821, x876, x823, x854, x878, x825, x857, x880, x827, x859, x882, x829, x861, x884, x831, x863, x886, x833, x865, x888, x835, x867, x890, x836, x869, x892, x837, x871, x894, x838, x806, x872, x840, x898, x21, x874, x908, x875, x903, x910, x877, x904, x912, x879, x901, x914, x881, x902, x916, x883, x899, x918, x885, x900, x920, x887, x897, x922, x889, x905, x924, x891, x906, x893, x895, x945, x948, x943, x941, x950, x942, x939, x952, x940, x937, x954, x938, x935, x956, x936, x933, x958, x934, x931, x960, x932, x929, x907, x963, x909, x946, x911, x966, x913, x944, x968, x915, x947, x970, x917, x949, x972, x919, x951, x974, x921, x953, x976, x923, x955, x978, x925, x957, x980, x926, x959, x982, x927, x961, x984, x928, x896, x962, x930, x988, x22, x964, x998, x965, x993, x1000, x967, x994, x1002, x969, x991, x1004, x971, x992, x1006, x973, x989, x1008, x975, x990, x1010, x977, x987, x1012, x979, x995, x1014, x981, x996, x983, x985, x1035, x1038, x1033, x1031, x1040, x1032, x1029, x1042, x1030, x1027, x1044, x1028, x1025, x1046, x1026, x1023, x1048, x1024, x1021, x1050, x1022, x1019, x997, x1053, x999, x1036, x1001, x1056, x1003, x1034, x1058, x1005, x1037, x1060, x1007, x1039, x1062, x1009, x1041, x1064, x1011, x1043, x1066, x1013, x1045, x1068, x1015, x1047, x1070, x1016, x1049, x1072, x1017, x1051, x1074, x1018, x986, x1052, x1020, x1080, x1082, x1084, x1086, x1088, x1090, x1092, x1094, x1076, x1096, x1054, x1099, x1077, x1100, x1055, x1102, x1078, x1103, x1057, x1105, x1079, x1106, x1059, x1108, x1081, x1109, x1061, x1111, x1083, x1112, x1063, x1114, x1085, x1115, x1065, x1117, x1087, x1118, x1067, x1120, x1089, x1121, x1069, x1123, x1091, x1124, x1071, x1126, x1093, x1127, x1073, x1129, x1095, x1130, x1098, x1075, x1132, x1097, x1133, x1101, x1104, x1107, x1110, x1113, x1116, x1119, x1122, x1125, x1128, x1131, x1134, x1135, x1136, x1137, x1138, x1139, x1140, x1141, x1142, x1143, x1144, x1145, x1146;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x12 = x1;
x13 = x2;
x14 = x3;
x15 = x4;
x16 = x5;
x17 = x6;
x18 = x7;
x19 = x8;
x20 = x9;
x21 = x10;
x22 = x11;
x23 = x0;
x24 = (x23)*((uintptr_t)2ULL);
x25 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)2ULL))>>64;
x26 = (x23)*((uintptr_t)4294967294ULL);
x27 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967294ULL))>>64;
x28 = (x23)*((uintptr_t)2ULL);
x29 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)2ULL))>>64;
x30 = (x23)*((uintptr_t)4294967294ULL);
x31 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967294ULL))>>64;
x32 = (x25)+(x23);
x33 = (x32)<(x25);
x34 = (x23)*((uintptr_t)4294967295ULL);
x35 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x36 = (x23)*((uintptr_t)4294967295ULL);
x37 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x38 = (x23)*((uintptr_t)4294967295ULL);
x39 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x40 = (x23)*((uintptr_t)4294967295ULL);
x41 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x42 = (x23)*((uintptr_t)4294967295ULL);
x43 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x44 = (x23)*((uintptr_t)4294967295ULL);
x45 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x46 = (x23)*((uintptr_t)4294967295ULL);
x47 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x48 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967294ULL))>>64;
x49 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x50 = sizeof(intptr_t) == 4 ? ((uint64_t)(x23)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x23)*((uintptr_t)4294967295ULL))>>64;
x51 = (x49)+((x23)*((uintptr_t)4294967294ULL));
x52 = ((x51)<(x49))+(x48);
x53 = (x52)+(x46);
x54 = (((x52)<(x48))+((x53)<(x46)))+(x47);
x55 = (x54)+(x44);
x56 = (((x54)<(x47))+((x55)<(x44)))+(x45);
x57 = (x56)+(x42);
x58 = (((x56)<(x45))+((x57)<(x42)))+(x43);
x59 = (x58)+(x40);
x60 = (((x58)<(x43))+((x59)<(x40)))+(x41);
x61 = (x60)+(x38);
x62 = (((x60)<(x41))+((x61)<(x38)))+(x39);
x63 = (x62)+(x36);
x64 = (((x62)<(x39))+((x63)<(x36)))+(x37);
x65 = (x64)+(x34);
x66 = ((x64)<(x37))+((x65)<(x34));
x67 = (((x23)+((x23)*((uintptr_t)4294967295ULL)))<(x23))+(x30);
x68 = (x67)+(x50);
x69 = ((x67)<(x30))+((x68)<(x50));
x70 = (x28)+((x23)*((uintptr_t)4294967295ULL));
x71 = ((x70)<(x28))+(x29);
x72 = (x71)+(x51);
x73 = (((x71)<(x29))+((x72)<(x51)))+(x26);
x74 = (x73)+(x53);
x75 = (((x73)<(x26))+((x74)<(x53)))+(x27);
x76 = (x75)+(x55);
x77 = (((x75)<(x27))+((x76)<(x55)))+(x24);
x78 = (x77)+(x57);
x79 = (((x77)<(x24))+((x78)<(x57)))+(x32);
x80 = (x79)+(x59);
x81 = (((x79)<(x32))+((x80)<(x59)))+(x33);
x82 = (x81)+(x61);
x83 = (((x81)<(x33))+((x82)<(x61)))+(x63);
x84 = ((x83)<(x63))+(x65);
x85 = ((x84)<(x65))+((x66)+(x35));
x86 = (x85)<((x66)+(x35));
x87 = (x12)*((uintptr_t)2ULL);
x88 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2ULL))>>64;
x89 = (x12)*((uintptr_t)4294967294ULL);
x90 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967294ULL))>>64;
x91 = (x12)*((uintptr_t)2ULL);
x92 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)2ULL))>>64;
x93 = (x12)*((uintptr_t)4294967294ULL);
x94 = sizeof(intptr_t) == 4 ? ((uint64_t)(x12)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x12)*((uintptr_t)4294967294ULL))>>64;
x95 = (x88)+(x12);
x96 = (x95)<(x88);
x97 = (x68)+(x12);
x98 = ((x97)<(x68))+((x69)+(x31));
x99 = (x98)+(x93);
x100 = (((x98)<((x69)+(x31)))+((x99)<(x93)))+(x70);
x101 = (x100)+(x94);
x102 = (((x100)<(x70))+((x101)<(x94)))+(x72);
x103 = (x102)+(x91);
x104 = (((x102)<(x72))+((x103)<(x91)))+(x74);
x105 = (x104)+(x92);
x106 = (((x104)<(x74))+((x105)<(x92)))+(x76);
x107 = (x106)+(x89);
x108 = (((x106)<(x76))+((x107)<(x89)))+(x78);
x109 = (x108)+(x90);
x110 = (((x108)<(x78))+((x109)<(x90)))+(x80);
x111 = (x110)+(x87);
x112 = (((x110)<(x80))+((x111)<(x87)))+(x82);
x113 = (x112)+(x95);
x114 = (((x112)<(x82))+((x113)<(x95)))+(x83);
x115 = (x114)+(x96);
x116 = (((x114)<(x83))+((x115)<(x96)))+(x84);
x117 = ((x116)<(x84))+(x85);
x118 = (x117)<(x85);
x119 = (x97)*((uintptr_t)4294967295ULL);
x120 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x121 = (x97)*((uintptr_t)4294967295ULL);
x122 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x123 = (x97)*((uintptr_t)4294967295ULL);
x124 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x125 = (x97)*((uintptr_t)4294967295ULL);
x126 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x127 = (x97)*((uintptr_t)4294967295ULL);
x128 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x129 = (x97)*((uintptr_t)4294967295ULL);
x130 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x131 = (x97)*((uintptr_t)4294967295ULL);
x132 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x133 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967294ULL))>>64;
x134 = (x97)*((uintptr_t)4294967295ULL);
x135 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x136 = sizeof(intptr_t) == 4 ? ((uint64_t)(x97)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x97)*((uintptr_t)4294967295ULL))>>64;
x137 = (x135)+((x97)*((uintptr_t)4294967294ULL));
x138 = ((x137)<(x135))+(x133);
x139 = (x138)+(x131);
x140 = (((x138)<(x133))+((x139)<(x131)))+(x132);
x141 = (x140)+(x129);
x142 = (((x140)<(x132))+((x141)<(x129)))+(x130);
x143 = (x142)+(x127);
x144 = (((x142)<(x130))+((x143)<(x127)))+(x128);
x145 = (x144)+(x125);
x146 = (((x144)<(x128))+((x145)<(x125)))+(x126);
x147 = (x146)+(x123);
x148 = (((x146)<(x126))+((x147)<(x123)))+(x124);
x149 = (x148)+(x121);
x150 = (((x148)<(x124))+((x149)<(x121)))+(x122);
x151 = (x150)+(x119);
x152 = ((x150)<(x122))+((x151)<(x119));
x153 = (((x97)+((x97)*((uintptr_t)4294967295ULL)))<(x97))+(x99);
x154 = (x153)+(x136);
x155 = (((x153)<(x99))+((x154)<(x136)))+(x101);
x156 = ((x155)<(x101))+(x103);
x157 = (x156)+(x134);
x158 = (((x156)<(x103))+((x157)<(x134)))+(x105);
x159 = (x158)+(x137);
x160 = (((x158)<(x105))+((x159)<(x137)))+(x107);
x161 = (x160)+(x139);
x162 = (((x160)<(x107))+((x161)<(x139)))+(x109);
x163 = (x162)+(x141);
x164 = (((x162)<(x109))+((x163)<(x141)))+(x111);
x165 = (x164)+(x143);
x166 = (((x164)<(x111))+((x165)<(x143)))+(x113);
x167 = (x166)+(x145);
x168 = (((x166)<(x113))+((x167)<(x145)))+(x115);
x169 = (x168)+(x147);
x170 = (((x168)<(x115))+((x169)<(x147)))+(x116);
x171 = (x170)+(x149);
x172 = (((x170)<(x116))+((x171)<(x149)))+(x117);
x173 = (x172)+(x151);
x174 = (((x172)<(x117))+((x173)<(x151)))+((x118)+(x86));
x175 = (x174)+((x152)+(x120));
x176 = ((x174)<((x118)+(x86)))+((x175)<((x152)+(x120)));
x177 = (x13)*((uintptr_t)2ULL);
x178 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2ULL))>>64;
x179 = (x13)*((uintptr_t)4294967294ULL);
x180 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967294ULL))>>64;
x181 = (x13)*((uintptr_t)2ULL);
x182 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)2ULL))>>64;
x183 = (x13)*((uintptr_t)4294967294ULL);
x184 = sizeof(intptr_t) == 4 ? ((uint64_t)(x13)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x13)*((uintptr_t)4294967294ULL))>>64;
x185 = (x178)+(x13);
x186 = (x185)<(x178);
x187 = (x154)+(x13);
x188 = ((x187)<(x154))+(x155);
x189 = (x188)+(x183);
x190 = (((x188)<(x155))+((x189)<(x183)))+(x157);
x191 = (x190)+(x184);
x192 = (((x190)<(x157))+((x191)<(x184)))+(x159);
x193 = (x192)+(x181);
x194 = (((x192)<(x159))+((x193)<(x181)))+(x161);
x195 = (x194)+(x182);
x196 = (((x194)<(x161))+((x195)<(x182)))+(x163);
x197 = (x196)+(x179);
x198 = (((x196)<(x163))+((x197)<(x179)))+(x165);
x199 = (x198)+(x180);
x200 = (((x198)<(x165))+((x199)<(x180)))+(x167);
x201 = (x200)+(x177);
x202 = (((x200)<(x167))+((x201)<(x177)))+(x169);
x203 = (x202)+(x185);
x204 = (((x202)<(x169))+((x203)<(x185)))+(x171);
x205 = (x204)+(x186);
x206 = (((x204)<(x171))+((x205)<(x186)))+(x173);
x207 = ((x206)<(x173))+(x175);
x208 = (x207)<(x175);
x209 = (x187)*((uintptr_t)4294967295ULL);
x210 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x211 = (x187)*((uintptr_t)4294967295ULL);
x212 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x213 = (x187)*((uintptr_t)4294967295ULL);
x214 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x215 = (x187)*((uintptr_t)4294967295ULL);
x216 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x217 = (x187)*((uintptr_t)4294967295ULL);
x218 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x219 = (x187)*((uintptr_t)4294967295ULL);
x220 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x221 = (x187)*((uintptr_t)4294967295ULL);
x222 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x223 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967294ULL))>>64;
x224 = (x187)*((uintptr_t)4294967295ULL);
x225 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x226 = sizeof(intptr_t) == 4 ? ((uint64_t)(x187)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x187)*((uintptr_t)4294967295ULL))>>64;
x227 = (x225)+((x187)*((uintptr_t)4294967294ULL));
x228 = ((x227)<(x225))+(x223);
x229 = (x228)+(x221);
x230 = (((x228)<(x223))+((x229)<(x221)))+(x222);
x231 = (x230)+(x219);
x232 = (((x230)<(x222))+((x231)<(x219)))+(x220);
x233 = (x232)+(x217);
x234 = (((x232)<(x220))+((x233)<(x217)))+(x218);
x235 = (x234)+(x215);
x236 = (((x234)<(x218))+((x235)<(x215)))+(x216);
x237 = (x236)+(x213);
x238 = (((x236)<(x216))+((x237)<(x213)))+(x214);
x239 = (x238)+(x211);
x240 = (((x238)<(x214))+((x239)<(x211)))+(x212);
x241 = (x240)+(x209);
x242 = ((x240)<(x212))+((x241)<(x209));
x243 = (((x187)+((x187)*((uintptr_t)4294967295ULL)))<(x187))+(x189);
x244 = (x243)+(x226);
x245 = (((x243)<(x189))+((x244)<(x226)))+(x191);
x246 = ((x245)<(x191))+(x193);
x247 = (x246)+(x224);
x248 = (((x246)<(x193))+((x247)<(x224)))+(x195);
x249 = (x248)+(x227);
x250 = (((x248)<(x195))+((x249)<(x227)))+(x197);
x251 = (x250)+(x229);
x252 = (((x250)<(x197))+((x251)<(x229)))+(x199);
x253 = (x252)+(x231);
x254 = (((x252)<(x199))+((x253)<(x231)))+(x201);
x255 = (x254)+(x233);
x256 = (((x254)<(x201))+((x255)<(x233)))+(x203);
x257 = (x256)+(x235);
x258 = (((x256)<(x203))+((x257)<(x235)))+(x205);
x259 = (x258)+(x237);
x260 = (((x258)<(x205))+((x259)<(x237)))+(x206);
x261 = (x260)+(x239);
x262 = (((x260)<(x206))+((x261)<(x239)))+(x207);
x263 = (x262)+(x241);
x264 = (((x262)<(x207))+((x263)<(x241)))+((x208)+(x176));
x265 = (x264)+((x242)+(x210));
x266 = ((x264)<((x208)+(x176)))+((x265)<((x242)+(x210)));
x267 = (x14)*((uintptr_t)2ULL);
x268 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2ULL))>>64;
x269 = (x14)*((uintptr_t)4294967294ULL);
x270 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)4294967294ULL))>>64;
x271 = (x14)*((uintptr_t)2ULL);
x272 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)2ULL))>>64;
x273 = (x14)*((uintptr_t)4294967294ULL);
x274 = sizeof(intptr_t) == 4 ? ((uint64_t)(x14)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x14)*((uintptr_t)4294967294ULL))>>64;
x275 = (x268)+(x14);
x276 = (x275)<(x268);
x277 = (x244)+(x14);
x278 = ((x277)<(x244))+(x245);
x279 = (x278)+(x273);
x280 = (((x278)<(x245))+((x279)<(x273)))+(x247);
x281 = (x280)+(x274);
x282 = (((x280)<(x247))+((x281)<(x274)))+(x249);
x283 = (x282)+(x271);
x284 = (((x282)<(x249))+((x283)<(x271)))+(x251);
x285 = (x284)+(x272);
x286 = (((x284)<(x251))+((x285)<(x272)))+(x253);
x287 = (x286)+(x269);
x288 = (((x286)<(x253))+((x287)<(x269)))+(x255);
x289 = (x288)+(x270);
x290 = (((x288)<(x255))+((x289)<(x270)))+(x257);
x291 = (x290)+(x267);
x292 = (((x290)<(x257))+((x291)<(x267)))+(x259);
x293 = (x292)+(x275);
x294 = (((x292)<(x259))+((x293)<(x275)))+(x261);
x295 = (x294)+(x276);
x296 = (((x294)<(x261))+((x295)<(x276)))+(x263);
x297 = ((x296)<(x263))+(x265);
x298 = (x297)<(x265);
x299 = (x277)*((uintptr_t)4294967295ULL);
x300 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x301 = (x277)*((uintptr_t)4294967295ULL);
x302 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x303 = (x277)*((uintptr_t)4294967295ULL);
x304 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x305 = (x277)*((uintptr_t)4294967295ULL);
x306 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x307 = (x277)*((uintptr_t)4294967295ULL);
x308 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x309 = (x277)*((uintptr_t)4294967295ULL);
x310 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x311 = (x277)*((uintptr_t)4294967295ULL);
x312 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x313 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967294ULL))>>64;
x314 = (x277)*((uintptr_t)4294967295ULL);
x315 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x316 = sizeof(intptr_t) == 4 ? ((uint64_t)(x277)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x277)*((uintptr_t)4294967295ULL))>>64;
x317 = (x315)+((x277)*((uintptr_t)4294967294ULL));
x318 = ((x317)<(x315))+(x313);
x319 = (x318)+(x311);
x320 = (((x318)<(x313))+((x319)<(x311)))+(x312);
x321 = (x320)+(x309);
x322 = (((x320)<(x312))+((x321)<(x309)))+(x310);
x323 = (x322)+(x307);
x324 = (((x322)<(x310))+((x323)<(x307)))+(x308);
x325 = (x324)+(x305);
x326 = (((x324)<(x308))+((x325)<(x305)))+(x306);
x327 = (x326)+(x303);
x328 = (((x326)<(x306))+((x327)<(x303)))+(x304);
x329 = (x328)+(x301);
x330 = (((x328)<(x304))+((x329)<(x301)))+(x302);
x331 = (x330)+(x299);
x332 = ((x330)<(x302))+((x331)<(x299));
x333 = (((x277)+((x277)*((uintptr_t)4294967295ULL)))<(x277))+(x279);
x334 = (x333)+(x316);
x335 = (((x333)<(x279))+((x334)<(x316)))+(x281);
x336 = ((x335)<(x281))+(x283);
x337 = (x336)+(x314);
x338 = (((x336)<(x283))+((x337)<(x314)))+(x285);
x339 = (x338)+(x317);
x340 = (((x338)<(x285))+((x339)<(x317)))+(x287);
x341 = (x340)+(x319);
x342 = (((x340)<(x287))+((x341)<(x319)))+(x289);
x343 = (x342)+(x321);
x344 = (((x342)<(x289))+((x343)<(x321)))+(x291);
x345 = (x344)+(x323);
x346 = (((x344)<(x291))+((x345)<(x323)))+(x293);
x347 = (x346)+(x325);
x348 = (((x346)<(x293))+((x347)<(x325)))+(x295);
x349 = (x348)+(x327);
x350 = (((x348)<(x295))+((x349)<(x327)))+(x296);
x351 = (x350)+(x329);
x352 = (((x350)<(x296))+((x351)<(x329)))+(x297);
x353 = (x352)+(x331);
x354 = (((x352)<(x297))+((x353)<(x331)))+((x298)+(x266));
x355 = (x354)+((x332)+(x300));
x356 = ((x354)<((x298)+(x266)))+((x355)<((x332)+(x300)));
x357 = (x15)*((uintptr_t)2ULL);
x358 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2ULL))>>64;
x359 = (x15)*((uintptr_t)4294967294ULL);
x360 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)4294967294ULL))>>64;
x361 = (x15)*((uintptr_t)2ULL);
x362 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)2ULL))>>64;
x363 = (x15)*((uintptr_t)4294967294ULL);
x364 = sizeof(intptr_t) == 4 ? ((uint64_t)(x15)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x15)*((uintptr_t)4294967294ULL))>>64;
x365 = (x358)+(x15);
x366 = (x365)<(x358);
x367 = (x334)+(x15);
x368 = ((x367)<(x334))+(x335);
x369 = (x368)+(x363);
x370 = (((x368)<(x335))+((x369)<(x363)))+(x337);
x371 = (x370)+(x364);
x372 = (((x370)<(x337))+((x371)<(x364)))+(x339);
x373 = (x372)+(x361);
x374 = (((x372)<(x339))+((x373)<(x361)))+(x341);
x375 = (x374)+(x362);
x376 = (((x374)<(x341))+((x375)<(x362)))+(x343);
x377 = (x376)+(x359);
x378 = (((x376)<(x343))+((x377)<(x359)))+(x345);
x379 = (x378)+(x360);
x380 = (((x378)<(x345))+((x379)<(x360)))+(x347);
x381 = (x380)+(x357);
x382 = (((x380)<(x347))+((x381)<(x357)))+(x349);
x383 = (x382)+(x365);
x384 = (((x382)<(x349))+((x383)<(x365)))+(x351);
x385 = (x384)+(x366);
x386 = (((x384)<(x351))+((x385)<(x366)))+(x353);
x387 = ((x386)<(x353))+(x355);
x388 = (x387)<(x355);
x389 = (x367)*((uintptr_t)4294967295ULL);
x390 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x391 = (x367)*((uintptr_t)4294967295ULL);
x392 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x393 = (x367)*((uintptr_t)4294967295ULL);
x394 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x395 = (x367)*((uintptr_t)4294967295ULL);
x396 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x397 = (x367)*((uintptr_t)4294967295ULL);
x398 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x399 = (x367)*((uintptr_t)4294967295ULL);
x400 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x401 = (x367)*((uintptr_t)4294967295ULL);
x402 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x403 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967294ULL))>>64;
x404 = (x367)*((uintptr_t)4294967295ULL);
x405 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x406 = sizeof(intptr_t) == 4 ? ((uint64_t)(x367)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x367)*((uintptr_t)4294967295ULL))>>64;
x407 = (x405)+((x367)*((uintptr_t)4294967294ULL));
x408 = ((x407)<(x405))+(x403);
x409 = (x408)+(x401);
x410 = (((x408)<(x403))+((x409)<(x401)))+(x402);
x411 = (x410)+(x399);
x412 = (((x410)<(x402))+((x411)<(x399)))+(x400);
x413 = (x412)+(x397);
x414 = (((x412)<(x400))+((x413)<(x397)))+(x398);
x415 = (x414)+(x395);
x416 = (((x414)<(x398))+((x415)<(x395)))+(x396);
x417 = (x416)+(x393);
x418 = (((x416)<(x396))+((x417)<(x393)))+(x394);
x419 = (x418)+(x391);
x420 = (((x418)<(x394))+((x419)<(x391)))+(x392);
x421 = (x420)+(x389);
x422 = ((x420)<(x392))+((x421)<(x389));
x423 = (((x367)+((x367)*((uintptr_t)4294967295ULL)))<(x367))+(x369);
x424 = (x423)+(x406);
x425 = (((x423)<(x369))+((x424)<(x406)))+(x371);
x426 = ((x425)<(x371))+(x373);
x427 = (x426)+(x404);
x428 = (((x426)<(x373))+((x427)<(x404)))+(x375);
x429 = (x428)+(x407);
x430 = (((x428)<(x375))+((x429)<(x407)))+(x377);
x431 = (x430)+(x409);
x432 = (((x430)<(x377))+((x431)<(x409)))+(x379);
x433 = (x432)+(x411);
x434 = (((x432)<(x379))+((x433)<(x411)))+(x381);
x435 = (x434)+(x413);
x436 = (((x434)<(x381))+((x435)<(x413)))+(x383);
x437 = (x436)+(x415);
x438 = (((x436)<(x383))+((x437)<(x415)))+(x385);
x439 = (x438)+(x417);
x440 = (((x438)<(x385))+((x439)<(x417)))+(x386);
x441 = (x440)+(x419);
x442 = (((x440)<(x386))+((x441)<(x419)))+(x387);
x443 = (x442)+(x421);
x444 = (((x442)<(x387))+((x443)<(x421)))+((x388)+(x356));
x445 = (x444)+((x422)+(x390));
x446 = ((x444)<((x388)+(x356)))+((x445)<((x422)+(x390)));
x447 = (x16)*((uintptr_t)2ULL);
x448 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)2ULL))>>64;
x449 = (x16)*((uintptr_t)4294967294ULL);
x450 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)4294967294ULL))>>64;
x451 = (x16)*((uintptr_t)2ULL);
x452 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)2ULL))>>64;
x453 = (x16)*((uintptr_t)4294967294ULL);
x454 = sizeof(intptr_t) == 4 ? ((uint64_t)(x16)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x16)*((uintptr_t)4294967294ULL))>>64;
x455 = (x448)+(x16);
x456 = (x455)<(x448);
x457 = (x424)+(x16);
x458 = ((x457)<(x424))+(x425);
x459 = (x458)+(x453);
x460 = (((x458)<(x425))+((x459)<(x453)))+(x427);
x461 = (x460)+(x454);
x462 = (((x460)<(x427))+((x461)<(x454)))+(x429);
x463 = (x462)+(x451);
x464 = (((x462)<(x429))+((x463)<(x451)))+(x431);
x465 = (x464)+(x452);
x466 = (((x464)<(x431))+((x465)<(x452)))+(x433);
x467 = (x466)+(x449);
x468 = (((x466)<(x433))+((x467)<(x449)))+(x435);
x469 = (x468)+(x450);
x470 = (((x468)<(x435))+((x469)<(x450)))+(x437);
x471 = (x470)+(x447);
x472 = (((x470)<(x437))+((x471)<(x447)))+(x439);
x473 = (x472)+(x455);
x474 = (((x472)<(x439))+((x473)<(x455)))+(x441);
x475 = (x474)+(x456);
x476 = (((x474)<(x441))+((x475)<(x456)))+(x443);
x477 = ((x476)<(x443))+(x445);
x478 = (x477)<(x445);
x479 = (x457)*((uintptr_t)4294967295ULL);
x480 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x481 = (x457)*((uintptr_t)4294967295ULL);
x482 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x483 = (x457)*((uintptr_t)4294967295ULL);
x484 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x485 = (x457)*((uintptr_t)4294967295ULL);
x486 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x487 = (x457)*((uintptr_t)4294967295ULL);
x488 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x489 = (x457)*((uintptr_t)4294967295ULL);
x490 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x491 = (x457)*((uintptr_t)4294967295ULL);
x492 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x493 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967294ULL))>>64;
x494 = (x457)*((uintptr_t)4294967295ULL);
x495 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x496 = sizeof(intptr_t) == 4 ? ((uint64_t)(x457)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x457)*((uintptr_t)4294967295ULL))>>64;
x497 = (x495)+((x457)*((uintptr_t)4294967294ULL));
x498 = ((x497)<(x495))+(x493);
x499 = (x498)+(x491);
x500 = (((x498)<(x493))+((x499)<(x491)))+(x492);
x501 = (x500)+(x489);
x502 = (((x500)<(x492))+((x501)<(x489)))+(x490);
x503 = (x502)+(x487);
x504 = (((x502)<(x490))+((x503)<(x487)))+(x488);
x505 = (x504)+(x485);
x506 = (((x504)<(x488))+((x505)<(x485)))+(x486);
x507 = (x506)+(x483);
x508 = (((x506)<(x486))+((x507)<(x483)))+(x484);
x509 = (x508)+(x481);
x510 = (((x508)<(x484))+((x509)<(x481)))+(x482);
x511 = (x510)+(x479);
x512 = ((x510)<(x482))+((x511)<(x479));
x513 = (((x457)+((x457)*((uintptr_t)4294967295ULL)))<(x457))+(x459);
x514 = (x513)+(x496);
x515 = (((x513)<(x459))+((x514)<(x496)))+(x461);
x516 = ((x515)<(x461))+(x463);
x517 = (x516)+(x494);
x518 = (((x516)<(x463))+((x517)<(x494)))+(x465);
x519 = (x518)+(x497);
x520 = (((x518)<(x465))+((x519)<(x497)))+(x467);
x521 = (x520)+(x499);
x522 = (((x520)<(x467))+((x521)<(x499)))+(x469);
x523 = (x522)+(x501);
x524 = (((x522)<(x469))+((x523)<(x501)))+(x471);
x525 = (x524)+(x503);
x526 = (((x524)<(x471))+((x525)<(x503)))+(x473);
x527 = (x526)+(x505);
x528 = (((x526)<(x473))+((x527)<(x505)))+(x475);
x529 = (x528)+(x507);
x530 = (((x528)<(x475))+((x529)<(x507)))+(x476);
x531 = (x530)+(x509);
x532 = (((x530)<(x476))+((x531)<(x509)))+(x477);
x533 = (x532)+(x511);
x534 = (((x532)<(x477))+((x533)<(x511)))+((x478)+(x446));
x535 = (x534)+((x512)+(x480));
x536 = ((x534)<((x478)+(x446)))+((x535)<((x512)+(x480)));
x537 = (x17)*((uintptr_t)2ULL);
x538 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)2ULL))>>64;
x539 = (x17)*((uintptr_t)4294967294ULL);
x540 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)4294967294ULL))>>64;
x541 = (x17)*((uintptr_t)2ULL);
x542 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)2ULL))>>64;
x543 = (x17)*((uintptr_t)4294967294ULL);
x544 = sizeof(intptr_t) == 4 ? ((uint64_t)(x17)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x17)*((uintptr_t)4294967294ULL))>>64;
x545 = (x538)+(x17);
x546 = (x545)<(x538);
x547 = (x514)+(x17);
x548 = ((x547)<(x514))+(x515);
x549 = (x548)+(x543);
x550 = (((x548)<(x515))+((x549)<(x543)))+(x517);
x551 = (x550)+(x544);
x552 = (((x550)<(x517))+((x551)<(x544)))+(x519);
x553 = (x552)+(x541);
x554 = (((x552)<(x519))+((x553)<(x541)))+(x521);
x555 = (x554)+(x542);
x556 = (((x554)<(x521))+((x555)<(x542)))+(x523);
x557 = (x556)+(x539);
x558 = (((x556)<(x523))+((x557)<(x539)))+(x525);
x559 = (x558)+(x540);
x560 = (((x558)<(x525))+((x559)<(x540)))+(x527);
x561 = (x560)+(x537);
x562 = (((x560)<(x527))+((x561)<(x537)))+(x529);
x563 = (x562)+(x545);
x564 = (((x562)<(x529))+((x563)<(x545)))+(x531);
x565 = (x564)+(x546);
x566 = (((x564)<(x531))+((x565)<(x546)))+(x533);
x567 = ((x566)<(x533))+(x535);
x568 = (x567)<(x535);
x569 = (x547)*((uintptr_t)4294967295ULL);
x570 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x571 = (x547)*((uintptr_t)4294967295ULL);
x572 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x573 = (x547)*((uintptr_t)4294967295ULL);
x574 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x575 = (x547)*((uintptr_t)4294967295ULL);
x576 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x577 = (x547)*((uintptr_t)4294967295ULL);
x578 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x579 = (x547)*((uintptr_t)4294967295ULL);
x580 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x581 = (x547)*((uintptr_t)4294967295ULL);
x582 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x583 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967294ULL))>>64;
x584 = (x547)*((uintptr_t)4294967295ULL);
x585 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x586 = sizeof(intptr_t) == 4 ? ((uint64_t)(x547)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x547)*((uintptr_t)4294967295ULL))>>64;
x587 = (x585)+((x547)*((uintptr_t)4294967294ULL));
x588 = ((x587)<(x585))+(x583);
x589 = (x588)+(x581);
x590 = (((x588)<(x583))+((x589)<(x581)))+(x582);
x591 = (x590)+(x579);
x592 = (((x590)<(x582))+((x591)<(x579)))+(x580);
x593 = (x592)+(x577);
x594 = (((x592)<(x580))+((x593)<(x577)))+(x578);
x595 = (x594)+(x575);
x596 = (((x594)<(x578))+((x595)<(x575)))+(x576);
x597 = (x596)+(x573);
x598 = (((x596)<(x576))+((x597)<(x573)))+(x574);
x599 = (x598)+(x571);
x600 = (((x598)<(x574))+((x599)<(x571)))+(x572);
x601 = (x600)+(x569);
x602 = ((x600)<(x572))+((x601)<(x569));
x603 = (((x547)+((x547)*((uintptr_t)4294967295ULL)))<(x547))+(x549);
x604 = (x603)+(x586);
x605 = (((x603)<(x549))+((x604)<(x586)))+(x551);
x606 = ((x605)<(x551))+(x553);
x607 = (x606)+(x584);
x608 = (((x606)<(x553))+((x607)<(x584)))+(x555);
x609 = (x608)+(x587);
x610 = (((x608)<(x555))+((x609)<(x587)))+(x557);
x611 = (x610)+(x589);
x612 = (((x610)<(x557))+((x611)<(x589)))+(x559);
x613 = (x612)+(x591);
x614 = (((x612)<(x559))+((x613)<(x591)))+(x561);
x615 = (x614)+(x593);
x616 = (((x614)<(x561))+((x615)<(x593)))+(x563);
x617 = (x616)+(x595);
x618 = (((x616)<(x563))+((x617)<(x595)))+(x565);
x619 = (x618)+(x597);
x620 = (((x618)<(x565))+((x619)<(x597)))+(x566);
x621 = (x620)+(x599);
x622 = (((x620)<(x566))+((x621)<(x599)))+(x567);
x623 = (x622)+(x601);
x624 = (((x622)<(x567))+((x623)<(x601)))+((x568)+(x536));
x625 = (x624)+((x602)+(x570));
x626 = ((x624)<((x568)+(x536)))+((x625)<((x602)+(x570)));
x627 = (x18)*((uintptr_t)2ULL);
x628 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)2ULL))>>64;
x629 = (x18)*((uintptr_t)4294967294ULL);
x630 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)4294967294ULL))>>64;
x631 = (x18)*((uintptr_t)2ULL);
x632 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)2ULL))>>64;
x633 = (x18)*((uintptr_t)4294967294ULL);
x634 = sizeof(intptr_t) == 4 ? ((uint64_t)(x18)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x18)*((uintptr_t)4294967294ULL))>>64;
x635 = (x628)+(x18);
x636 = (x635)<(x628);
x637 = (x604)+(x18);
x638 = ((x637)<(x604))+(x605);
x639 = (x638)+(x633);
x640 = (((x638)<(x605))+((x639)<(x633)))+(x607);
x641 = (x640)+(x634);
x642 = (((x640)<(x607))+((x641)<(x634)))+(x609);
x643 = (x642)+(x631);
x644 = (((x642)<(x609))+((x643)<(x631)))+(x611);
x645 = (x644)+(x632);
x646 = (((x644)<(x611))+((x645)<(x632)))+(x613);
x647 = (x646)+(x629);
x648 = (((x646)<(x613))+((x647)<(x629)))+(x615);
x649 = (x648)+(x630);
x650 = (((x648)<(x615))+((x649)<(x630)))+(x617);
x651 = (x650)+(x627);
x652 = (((x650)<(x617))+((x651)<(x627)))+(x619);
x653 = (x652)+(x635);
x654 = (((x652)<(x619))+((x653)<(x635)))+(x621);
x655 = (x654)+(x636);
x656 = (((x654)<(x621))+((x655)<(x636)))+(x623);
x657 = ((x656)<(x623))+(x625);
x658 = (x657)<(x625);
x659 = (x637)*((uintptr_t)4294967295ULL);
x660 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x661 = (x637)*((uintptr_t)4294967295ULL);
x662 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x663 = (x637)*((uintptr_t)4294967295ULL);
x664 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x665 = (x637)*((uintptr_t)4294967295ULL);
x666 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x667 = (x637)*((uintptr_t)4294967295ULL);
x668 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x669 = (x637)*((uintptr_t)4294967295ULL);
x670 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x671 = (x637)*((uintptr_t)4294967295ULL);
x672 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x673 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967294ULL))>>64;
x674 = (x637)*((uintptr_t)4294967295ULL);
x675 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x676 = sizeof(intptr_t) == 4 ? ((uint64_t)(x637)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x637)*((uintptr_t)4294967295ULL))>>64;
x677 = (x675)+((x637)*((uintptr_t)4294967294ULL));
x678 = ((x677)<(x675))+(x673);
x679 = (x678)+(x671);
x680 = (((x678)<(x673))+((x679)<(x671)))+(x672);
x681 = (x680)+(x669);
x682 = (((x680)<(x672))+((x681)<(x669)))+(x670);
x683 = (x682)+(x667);
x684 = (((x682)<(x670))+((x683)<(x667)))+(x668);
x685 = (x684)+(x665);
x686 = (((x684)<(x668))+((x685)<(x665)))+(x666);
x687 = (x686)+(x663);
x688 = (((x686)<(x666))+((x687)<(x663)))+(x664);
x689 = (x688)+(x661);
x690 = (((x688)<(x664))+((x689)<(x661)))+(x662);
x691 = (x690)+(x659);
x692 = ((x690)<(x662))+((x691)<(x659));
x693 = (((x637)+((x637)*((uintptr_t)4294967295ULL)))<(x637))+(x639);
x694 = (x693)+(x676);
x695 = (((x693)<(x639))+((x694)<(x676)))+(x641);
x696 = ((x695)<(x641))+(x643);
x697 = (x696)+(x674);
x698 = (((x696)<(x643))+((x697)<(x674)))+(x645);
x699 = (x698)+(x677);
x700 = (((x698)<(x645))+((x699)<(x677)))+(x647);
x701 = (x700)+(x679);
x702 = (((x700)<(x647))+((x701)<(x679)))+(x649);
x703 = (x702)+(x681);
x704 = (((x702)<(x649))+((x703)<(x681)))+(x651);
x705 = (x704)+(x683);
x706 = (((x704)<(x651))+((x705)<(x683)))+(x653);
x707 = (x706)+(x685);
x708 = (((x706)<(x653))+((x707)<(x685)))+(x655);
x709 = (x708)+(x687);
x710 = (((x708)<(x655))+((x709)<(x687)))+(x656);
x711 = (x710)+(x689);
x712 = (((x710)<(x656))+((x711)<(x689)))+(x657);
x713 = (x712)+(x691);
x714 = (((x712)<(x657))+((x713)<(x691)))+((x658)+(x626));
x715 = (x714)+((x692)+(x660));
x716 = ((x714)<((x658)+(x626)))+((x715)<((x692)+(x660)));
x717 = (x19)*((uintptr_t)2ULL);
x718 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)2ULL))>>64;
x719 = (x19)*((uintptr_t)4294967294ULL);
x720 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)4294967294ULL))>>64;
x721 = (x19)*((uintptr_t)2ULL);
x722 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)2ULL))>>64;
x723 = (x19)*((uintptr_t)4294967294ULL);
x724 = sizeof(intptr_t) == 4 ? ((uint64_t)(x19)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x19)*((uintptr_t)4294967294ULL))>>64;
x725 = (x718)+(x19);
x726 = (x725)<(x718);
x727 = (x694)+(x19);
x728 = ((x727)<(x694))+(x695);
x729 = (x728)+(x723);
x730 = (((x728)<(x695))+((x729)<(x723)))+(x697);
x731 = (x730)+(x724);
x732 = (((x730)<(x697))+((x731)<(x724)))+(x699);
x733 = (x732)+(x721);
x734 = (((x732)<(x699))+((x733)<(x721)))+(x701);
x735 = (x734)+(x722);
x736 = (((x734)<(x701))+((x735)<(x722)))+(x703);
x737 = (x736)+(x719);
x738 = (((x736)<(x703))+((x737)<(x719)))+(x705);
x739 = (x738)+(x720);
x740 = (((x738)<(x705))+((x739)<(x720)))+(x707);
x741 = (x740)+(x717);
x742 = (((x740)<(x707))+((x741)<(x717)))+(x709);
x743 = (x742)+(x725);
x744 = (((x742)<(x709))+((x743)<(x725)))+(x711);
x745 = (x744)+(x726);
x746 = (((x744)<(x711))+((x745)<(x726)))+(x713);
x747 = ((x746)<(x713))+(x715);
x748 = (x747)<(x715);
x749 = (x727)*((uintptr_t)4294967295ULL);
x750 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x751 = (x727)*((uintptr_t)4294967295ULL);
x752 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x753 = (x727)*((uintptr_t)4294967295ULL);
x754 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x755 = (x727)*((uintptr_t)4294967295ULL);
x756 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x757 = (x727)*((uintptr_t)4294967295ULL);
x758 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x759 = (x727)*((uintptr_t)4294967295ULL);
x760 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x761 = (x727)*((uintptr_t)4294967295ULL);
x762 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x763 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967294ULL))>>64;
x764 = (x727)*((uintptr_t)4294967295ULL);
x765 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x766 = sizeof(intptr_t) == 4 ? ((uint64_t)(x727)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x727)*((uintptr_t)4294967295ULL))>>64;
x767 = (x765)+((x727)*((uintptr_t)4294967294ULL));
x768 = ((x767)<(x765))+(x763);
x769 = (x768)+(x761);
x770 = (((x768)<(x763))+((x769)<(x761)))+(x762);
x771 = (x770)+(x759);
x772 = (((x770)<(x762))+((x771)<(x759)))+(x760);
x773 = (x772)+(x757);
x774 = (((x772)<(x760))+((x773)<(x757)))+(x758);
x775 = (x774)+(x755);
x776 = (((x774)<(x758))+((x775)<(x755)))+(x756);
x777 = (x776)+(x753);
x778 = (((x776)<(x756))+((x777)<(x753)))+(x754);
x779 = (x778)+(x751);
x780 = (((x778)<(x754))+((x779)<(x751)))+(x752);
x781 = (x780)+(x749);
x782 = ((x780)<(x752))+((x781)<(x749));
x783 = (((x727)+((x727)*((uintptr_t)4294967295ULL)))<(x727))+(x729);
x784 = (x783)+(x766);
x785 = (((x783)<(x729))+((x784)<(x766)))+(x731);
x786 = ((x785)<(x731))+(x733);
x787 = (x786)+(x764);
x788 = (((x786)<(x733))+((x787)<(x764)))+(x735);
x789 = (x788)+(x767);
x790 = (((x788)<(x735))+((x789)<(x767)))+(x737);
x791 = (x790)+(x769);
x792 = (((x790)<(x737))+((x791)<(x769)))+(x739);
x793 = (x792)+(x771);
x794 = (((x792)<(x739))+((x793)<(x771)))+(x741);
x795 = (x794)+(x773);
x796 = (((x794)<(x741))+((x795)<(x773)))+(x743);
x797 = (x796)+(x775);
x798 = (((x796)<(x743))+((x797)<(x775)))+(x745);
x799 = (x798)+(x777);
x800 = (((x798)<(x745))+((x799)<(x777)))+(x746);
x801 = (x800)+(x779);
x802 = (((x800)<(x746))+((x801)<(x779)))+(x747);
x803 = (x802)+(x781);
x804 = (((x802)<(x747))+((x803)<(x781)))+((x748)+(x716));
x805 = (x804)+((x782)+(x750));
x806 = ((x804)<((x748)+(x716)))+((x805)<((x782)+(x750)));
x807 = (x20)*((uintptr_t)2ULL);
x808 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)2ULL))>>64;
x809 = (x20)*((uintptr_t)4294967294ULL);
x810 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)4294967294ULL))>>64;
x811 = (x20)*((uintptr_t)2ULL);
x812 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)2ULL))>>64;
x813 = (x20)*((uintptr_t)4294967294ULL);
x814 = sizeof(intptr_t) == 4 ? ((uint64_t)(x20)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x20)*((uintptr_t)4294967294ULL))>>64;
x815 = (x808)+(x20);
x816 = (x815)<(x808);
x817 = (x784)+(x20);
x818 = ((x817)<(x784))+(x785);
x819 = (x818)+(x813);
x820 = (((x818)<(x785))+((x819)<(x813)))+(x787);
x821 = (x820)+(x814);
x822 = (((x820)<(x787))+((x821)<(x814)))+(x789);
x823 = (x822)+(x811);
x824 = (((x822)<(x789))+((x823)<(x811)))+(x791);
x825 = (x824)+(x812);
x826 = (((x824)<(x791))+((x825)<(x812)))+(x793);
x827 = (x826)+(x809);
x828 = (((x826)<(x793))+((x827)<(x809)))+(x795);
x829 = (x828)+(x810);
x830 = (((x828)<(x795))+((x829)<(x810)))+(x797);
x831 = (x830)+(x807);
x832 = (((x830)<(x797))+((x831)<(x807)))+(x799);
x833 = (x832)+(x815);
x834 = (((x832)<(x799))+((x833)<(x815)))+(x801);
x835 = (x834)+(x816);
x836 = (((x834)<(x801))+((x835)<(x816)))+(x803);
x837 = ((x836)<(x803))+(x805);
x838 = (x837)<(x805);
x839 = (x817)*((uintptr_t)4294967295ULL);
x840 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x841 = (x817)*((uintptr_t)4294967295ULL);
x842 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x843 = (x817)*((uintptr_t)4294967295ULL);
x844 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x845 = (x817)*((uintptr_t)4294967295ULL);
x846 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x847 = (x817)*((uintptr_t)4294967295ULL);
x848 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x849 = (x817)*((uintptr_t)4294967295ULL);
x850 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x851 = (x817)*((uintptr_t)4294967295ULL);
x852 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x853 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967294ULL))>>64;
x854 = (x817)*((uintptr_t)4294967295ULL);
x855 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x856 = sizeof(intptr_t) == 4 ? ((uint64_t)(x817)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x817)*((uintptr_t)4294967295ULL))>>64;
x857 = (x855)+((x817)*((uintptr_t)4294967294ULL));
x858 = ((x857)<(x855))+(x853);
x859 = (x858)+(x851);
x860 = (((x858)<(x853))+((x859)<(x851)))+(x852);
x861 = (x860)+(x849);
x862 = (((x860)<(x852))+((x861)<(x849)))+(x850);
x863 = (x862)+(x847);
x864 = (((x862)<(x850))+((x863)<(x847)))+(x848);
x865 = (x864)+(x845);
x866 = (((x864)<(x848))+((x865)<(x845)))+(x846);
x867 = (x866)+(x843);
x868 = (((x866)<(x846))+((x867)<(x843)))+(x844);
x869 = (x868)+(x841);
x870 = (((x868)<(x844))+((x869)<(x841)))+(x842);
x871 = (x870)+(x839);
x872 = ((x870)<(x842))+((x871)<(x839));
x873 = (((x817)+((x817)*((uintptr_t)4294967295ULL)))<(x817))+(x819);
x874 = (x873)+(x856);
x875 = (((x873)<(x819))+((x874)<(x856)))+(x821);
x876 = ((x875)<(x821))+(x823);
x877 = (x876)+(x854);
x878 = (((x876)<(x823))+((x877)<(x854)))+(x825);
x879 = (x878)+(x857);
x880 = (((x878)<(x825))+((x879)<(x857)))+(x827);
x881 = (x880)+(x859);
x882 = (((x880)<(x827))+((x881)<(x859)))+(x829);
x883 = (x882)+(x861);
x884 = (((x882)<(x829))+((x883)<(x861)))+(x831);
x885 = (x884)+(x863);
x886 = (((x884)<(x831))+((x885)<(x863)))+(x833);
x887 = (x886)+(x865);
x888 = (((x886)<(x833))+((x887)<(x865)))+(x835);
x889 = (x888)+(x867);
x890 = (((x888)<(x835))+((x889)<(x867)))+(x836);
x891 = (x890)+(x869);
x892 = (((x890)<(x836))+((x891)<(x869)))+(x837);
x893 = (x892)+(x871);
x894 = (((x892)<(x837))+((x893)<(x871)))+((x838)+(x806));
x895 = (x894)+((x872)+(x840));
x896 = ((x894)<((x838)+(x806)))+((x895)<((x872)+(x840)));
x897 = (x21)*((uintptr_t)2ULL);
x898 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)2ULL))>>64;
x899 = (x21)*((uintptr_t)4294967294ULL);
x900 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)4294967294ULL))>>64;
x901 = (x21)*((uintptr_t)2ULL);
x902 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)2ULL))>>64;
x903 = (x21)*((uintptr_t)4294967294ULL);
x904 = sizeof(intptr_t) == 4 ? ((uint64_t)(x21)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x21)*((uintptr_t)4294967294ULL))>>64;
x905 = (x898)+(x21);
x906 = (x905)<(x898);
x907 = (x874)+(x21);
x908 = ((x907)<(x874))+(x875);
x909 = (x908)+(x903);
x910 = (((x908)<(x875))+((x909)<(x903)))+(x877);
x911 = (x910)+(x904);
x912 = (((x910)<(x877))+((x911)<(x904)))+(x879);
x913 = (x912)+(x901);
x914 = (((x912)<(x879))+((x913)<(x901)))+(x881);
x915 = (x914)+(x902);
x916 = (((x914)<(x881))+((x915)<(x902)))+(x883);
x917 = (x916)+(x899);
x918 = (((x916)<(x883))+((x917)<(x899)))+(x885);
x919 = (x918)+(x900);
x920 = (((x918)<(x885))+((x919)<(x900)))+(x887);
x921 = (x920)+(x897);
x922 = (((x920)<(x887))+((x921)<(x897)))+(x889);
x923 = (x922)+(x905);
x924 = (((x922)<(x889))+((x923)<(x905)))+(x891);
x925 = (x924)+(x906);
x926 = (((x924)<(x891))+((x925)<(x906)))+(x893);
x927 = ((x926)<(x893))+(x895);
x928 = (x927)<(x895);
x929 = (x907)*((uintptr_t)4294967295ULL);
x930 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x931 = (x907)*((uintptr_t)4294967295ULL);
x932 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x933 = (x907)*((uintptr_t)4294967295ULL);
x934 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x935 = (x907)*((uintptr_t)4294967295ULL);
x936 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x937 = (x907)*((uintptr_t)4294967295ULL);
x938 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x939 = (x907)*((uintptr_t)4294967295ULL);
x940 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x941 = (x907)*((uintptr_t)4294967295ULL);
x942 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x943 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967294ULL))>>64;
x944 = (x907)*((uintptr_t)4294967295ULL);
x945 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x946 = sizeof(intptr_t) == 4 ? ((uint64_t)(x907)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x907)*((uintptr_t)4294967295ULL))>>64;
x947 = (x945)+((x907)*((uintptr_t)4294967294ULL));
x948 = ((x947)<(x945))+(x943);
x949 = (x948)+(x941);
x950 = (((x948)<(x943))+((x949)<(x941)))+(x942);
x951 = (x950)+(x939);
x952 = (((x950)<(x942))+((x951)<(x939)))+(x940);
x953 = (x952)+(x937);
x954 = (((x952)<(x940))+((x953)<(x937)))+(x938);
x955 = (x954)+(x935);
x956 = (((x954)<(x938))+((x955)<(x935)))+(x936);
x957 = (x956)+(x933);
x958 = (((x956)<(x936))+((x957)<(x933)))+(x934);
x959 = (x958)+(x931);
x960 = (((x958)<(x934))+((x959)<(x931)))+(x932);
x961 = (x960)+(x929);
x962 = ((x960)<(x932))+((x961)<(x929));
x963 = (((x907)+((x907)*((uintptr_t)4294967295ULL)))<(x907))+(x909);
x964 = (x963)+(x946);
x965 = (((x963)<(x909))+((x964)<(x946)))+(x911);
x966 = ((x965)<(x911))+(x913);
x967 = (x966)+(x944);
x968 = (((x966)<(x913))+((x967)<(x944)))+(x915);
x969 = (x968)+(x947);
x970 = (((x968)<(x915))+((x969)<(x947)))+(x917);
x971 = (x970)+(x949);
x972 = (((x970)<(x917))+((x971)<(x949)))+(x919);
x973 = (x972)+(x951);
x974 = (((x972)<(x919))+((x973)<(x951)))+(x921);
x975 = (x974)+(x953);
x976 = (((x974)<(x921))+((x975)<(x953)))+(x923);
x977 = (x976)+(x955);
x978 = (((x976)<(x923))+((x977)<(x955)))+(x925);
x979 = (x978)+(x957);
x980 = (((x978)<(x925))+((x979)<(x957)))+(x926);
x981 = (x980)+(x959);
x982 = (((x980)<(x926))+((x981)<(x959)))+(x927);
x983 = (x982)+(x961);
x984 = (((x982)<(x927))+((x983)<(x961)))+((x928)+(x896));
x985 = (x984)+((x962)+(x930));
x986 = ((x984)<((x928)+(x896)))+((x985)<((x962)+(x930)));
x987 = (x22)*((uintptr_t)2ULL);
x988 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)2ULL))>>64;
x989 = (x22)*((uintptr_t)4294967294ULL);
x990 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)4294967294ULL))>>64;
x991 = (x22)*((uintptr_t)2ULL);
x992 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)2ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)2ULL))>>64;
x993 = (x22)*((uintptr_t)4294967294ULL);
x994 = sizeof(intptr_t) == 4 ? ((uint64_t)(x22)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x22)*((uintptr_t)4294967294ULL))>>64;
x995 = (x988)+(x22);
x996 = (x995)<(x988);
x997 = (x964)+(x22);
x998 = ((x997)<(x964))+(x965);
x999 = (x998)+(x993);
x1000 = (((x998)<(x965))+((x999)<(x993)))+(x967);
x1001 = (x1000)+(x994);
x1002 = (((x1000)<(x967))+((x1001)<(x994)))+(x969);
x1003 = (x1002)+(x991);
x1004 = (((x1002)<(x969))+((x1003)<(x991)))+(x971);
x1005 = (x1004)+(x992);
x1006 = (((x1004)<(x971))+((x1005)<(x992)))+(x973);
x1007 = (x1006)+(x989);
x1008 = (((x1006)<(x973))+((x1007)<(x989)))+(x975);
x1009 = (x1008)+(x990);
x1010 = (((x1008)<(x975))+((x1009)<(x990)))+(x977);
x1011 = (x1010)+(x987);
x1012 = (((x1010)<(x977))+((x1011)<(x987)))+(x979);
x1013 = (x1012)+(x995);
x1014 = (((x1012)<(x979))+((x1013)<(x995)))+(x981);
x1015 = (x1014)+(x996);
x1016 = (((x1014)<(x981))+((x1015)<(x996)))+(x983);
x1017 = ((x1016)<(x983))+(x985);
x1018 = (x1017)<(x985);
x1019 = (x997)*((uintptr_t)4294967295ULL);
x1020 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1021 = (x997)*((uintptr_t)4294967295ULL);
x1022 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1023 = (x997)*((uintptr_t)4294967295ULL);
x1024 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1025 = (x997)*((uintptr_t)4294967295ULL);
x1026 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1027 = (x997)*((uintptr_t)4294967295ULL);
x1028 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1029 = (x997)*((uintptr_t)4294967295ULL);
x1030 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1031 = (x997)*((uintptr_t)4294967295ULL);
x1032 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1033 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967294ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967294ULL))>>64;
x1034 = (x997)*((uintptr_t)4294967295ULL);
x1035 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1036 = sizeof(intptr_t) == 4 ? ((uint64_t)(x997)*((uintptr_t)4294967295ULL))>>32 : ((__uint128_t)(x997)*((uintptr_t)4294967295ULL))>>64;
x1037 = (x1035)+((x997)*((uintptr_t)4294967294ULL));
x1038 = ((x1037)<(x1035))+(x1033);
x1039 = (x1038)+(x1031);
x1040 = (((x1038)<(x1033))+((x1039)<(x1031)))+(x1032);
x1041 = (x1040)+(x1029);
x1042 = (((x1040)<(x1032))+((x1041)<(x1029)))+(x1030);
x1043 = (x1042)+(x1027);
x1044 = (((x1042)<(x1030))+((x1043)<(x1027)))+(x1028);
x1045 = (x1044)+(x1025);
x1046 = (((x1044)<(x1028))+((x1045)<(x1025)))+(x1026);
x1047 = (x1046)+(x1023);
x1048 = (((x1046)<(x1026))+((x1047)<(x1023)))+(x1024);
x1049 = (x1048)+(x1021);
x1050 = (((x1048)<(x1024))+((x1049)<(x1021)))+(x1022);
x1051 = (x1050)+(x1019);
x1052 = ((x1050)<(x1022))+((x1051)<(x1019));
x1053 = (((x997)+((x997)*((uintptr_t)4294967295ULL)))<(x997))+(x999);
x1054 = (x1053)+(x1036);
x1055 = (((x1053)<(x999))+((x1054)<(x1036)))+(x1001);
x1056 = ((x1055)<(x1001))+(x1003);
x1057 = (x1056)+(x1034);
x1058 = (((x1056)<(x1003))+((x1057)<(x1034)))+(x1005);
x1059 = (x1058)+(x1037);
x1060 = (((x1058)<(x1005))+((x1059)<(x1037)))+(x1007);
x1061 = (x1060)+(x1039);
x1062 = (((x1060)<(x1007))+((x1061)<(x1039)))+(x1009);
x1063 = (x1062)+(x1041);
x1064 = (((x1062)<(x1009))+((x1063)<(x1041)))+(x1011);
x1065 = (x1064)+(x1043);
x1066 = (((x1064)<(x1011))+((x1065)<(x1043)))+(x1013);
x1067 = (x1066)+(x1045);
x1068 = (((x1066)<(x1013))+((x1067)<(x1045)))+(x1015);
x1069 = (x1068)+(x1047);
x1070 = (((x1068)<(x1015))+((x1069)<(x1047)))+(x1016);
x1071 = (x1070)+(x1049);
x1072 = (((x1070)<(x1016))+((x1071)<(x1049)))+(x1017);
x1073 = (x1072)+(x1051);
x1074 = (((x1072)<(x1017))+((x1073)<(x1051)))+((x1018)+(x986));
x1075 = (x1074)+((x1052)+(x1020));
x1076 = ((x1074)<((x1018)+(x986)))+((x1075)<((x1052)+(x1020)));
x1077 = (x1054)-((uintptr_t)4294967295ULL);
x1078 = (x1055)-(((x1054)<(x1077))+((x1077)<(x1077)));
x1079 = (x1057)-(((x1055)<(x1055))+((x1055)<(x1078)));
x1080 = (x1059)-((uintptr_t)4294967295ULL);
x1081 = (x1080)-(((x1057)<(x1057))+((x1057)<(x1079)));
x1082 = (x1061)-((uintptr_t)4294967294ULL);
x1083 = (x1082)-(((x1059)<(x1080))+((x1080)<(x1081)));
x1084 = (x1063)-((uintptr_t)4294967295ULL);
x1085 = (x1084)-(((x1061)<(x1082))+((x1082)<(x1083)));
x1086 = (x1065)-((uintptr_t)4294967295ULL);
x1087 = (x1086)-(((x1063)<(x1084))+((x1084)<(x1085)));
x1088 = (x1067)-((uintptr_t)4294967295ULL);
x1089 = (x1088)-(((x1065)<(x1086))+((x1086)<(x1087)));
x1090 = (x1069)-((uintptr_t)4294967295ULL);
x1091 = (x1090)-(((x1067)<(x1088))+((x1088)<(x1089)));
x1092 = (x1071)-((uintptr_t)4294967295ULL);
x1093 = (x1092)-(((x1069)<(x1090))+((x1090)<(x1091)));
x1094 = (x1073)-((uintptr_t)4294967295ULL);
x1095 = (x1094)-(((x1071)<(x1092))+((x1092)<(x1093)));
x1096 = (x1075)-((uintptr_t)4294967295ULL);
x1097 = (x1096)-(((x1073)<(x1094))+((x1094)<(x1095)));
x1098 = ((x1076)<(x1076))+((x1076)<((x1076)-(((x1075)<(x1096))+((x1096)<(x1097)))));
x1099 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1100 = (x1099)^((uintptr_t)4294967295ULL);
x1101 = ((x1054)&(x1099))|((x1077)&(x1100));
x1102 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1103 = (x1102)^((uintptr_t)4294967295ULL);
x1104 = ((x1055)&(x1102))|((x1078)&(x1103));
x1105 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1106 = (x1105)^((uintptr_t)4294967295ULL);
x1107 = ((x1057)&(x1105))|((x1079)&(x1106));
x1108 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1109 = (x1108)^((uintptr_t)4294967295ULL);
x1110 = ((x1059)&(x1108))|((x1081)&(x1109));
x1111 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1112 = (x1111)^((uintptr_t)4294967295ULL);
x1113 = ((x1061)&(x1111))|((x1083)&(x1112));
x1114 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1115 = (x1114)^((uintptr_t)4294967295ULL);
x1116 = ((x1063)&(x1114))|((x1085)&(x1115));
x1117 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1118 = (x1117)^((uintptr_t)4294967295ULL);
x1119 = ((x1065)&(x1117))|((x1087)&(x1118));
x1120 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1121 = (x1120)^((uintptr_t)4294967295ULL);
x1122 = ((x1067)&(x1120))|((x1089)&(x1121));
x1123 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1124 = (x1123)^((uintptr_t)4294967295ULL);
x1125 = ((x1069)&(x1123))|((x1091)&(x1124));
x1126 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1127 = (x1126)^((uintptr_t)4294967295ULL);
x1128 = ((x1071)&(x1126))|((x1093)&(x1127));
x1129 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1130 = (x1129)^((uintptr_t)4294967295ULL);
x1131 = ((x1073)&(x1129))|((x1095)&(x1130));
x1132 = ((uintptr_t)-1ULL)+((x1098)==((uintptr_t)0ULL));
x1133 = (x1132)^((uintptr_t)4294967295ULL);
x1134 = ((x1075)&(x1132))|((x1097)&(x1133));
x1135 = x1101;
x1136 = x1104;
x1137 = x1107;
x1138 = x1110;
x1139 = x1113;
x1140 = x1116;
x1141 = x1119;
x1142 = x1122;
x1143 = x1125;
x1144 = x1128;
x1145 = x1131;
x1146 = x1134;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x1135;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x1136;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x1137;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x1138;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x1139;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x1140;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x1141;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x1142;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x1143;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x1144;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x1145;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x1146;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [0x0 ~> 0xffffffff]
*/
uintptr_t fiat_p384_nonzero(uintptr_t in0) {
uintptr_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, out0, x13;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x12 = (x0)|((x1)|((x2)|((x3)|((x4)|((x5)|((x6)|((x7)|((x8)|((x9)|((x10)|((x11)|((uintptr_t)0ULL))))))))))));
x13 = x12;
out0 = x13;
return out0;
}
/*
* Input Bounds:
* in0: [0x0 ~> 0x1]
* in1: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* in2: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_selectznz(uintptr_t in0, uintptr_t in1, uintptr_t in2, uintptr_t out0) {
uintptr_t x12, x24, x0, x25, x13, x27, x1, x28, x14, x30, x2, x31, x15, x33, x3, x34, x16, x36, x4, x37, x17, x39, x5, x40, x18, x42, x6, x43, x19, x45, x7, x46, x20, x48, x8, x49, x21, x51, x9, x52, x22, x54, x10, x55, x23, x57, x11, x58, x26, x29, x32, x35, x38, x41, x44, x47, x50, x53, x56, x59, x60, x61, x62, x63, x64, x65, x66, x67, x68, x69, x70, x71;
/*skip*/
x0 = *(uintptr_t*)((in1)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in1)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in1)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in1)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in1)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in1)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in1)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in1)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in1)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in1)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in1)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in1)+((uintptr_t)44ULL));
/*skip*/
x12 = *(uintptr_t*)((in2)+((uintptr_t)0ULL));
x13 = *(uintptr_t*)((in2)+((uintptr_t)4ULL));
x14 = *(uintptr_t*)((in2)+((uintptr_t)8ULL));
x15 = *(uintptr_t*)((in2)+((uintptr_t)12ULL));
x16 = *(uintptr_t*)((in2)+((uintptr_t)16ULL));
x17 = *(uintptr_t*)((in2)+((uintptr_t)20ULL));
x18 = *(uintptr_t*)((in2)+((uintptr_t)24ULL));
x19 = *(uintptr_t*)((in2)+((uintptr_t)28ULL));
x20 = *(uintptr_t*)((in2)+((uintptr_t)32ULL));
x21 = *(uintptr_t*)((in2)+((uintptr_t)36ULL));
x22 = *(uintptr_t*)((in2)+((uintptr_t)40ULL));
x23 = *(uintptr_t*)((in2)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x24 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x25 = (x24)^((uintptr_t)4294967295ULL);
x26 = ((x12)&(x24))|((x0)&(x25));
x27 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x28 = (x27)^((uintptr_t)4294967295ULL);
x29 = ((x13)&(x27))|((x1)&(x28));
x30 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x31 = (x30)^((uintptr_t)4294967295ULL);
x32 = ((x14)&(x30))|((x2)&(x31));
x33 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x34 = (x33)^((uintptr_t)4294967295ULL);
x35 = ((x15)&(x33))|((x3)&(x34));
x36 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x37 = (x36)^((uintptr_t)4294967295ULL);
x38 = ((x16)&(x36))|((x4)&(x37));
x39 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x40 = (x39)^((uintptr_t)4294967295ULL);
x41 = ((x17)&(x39))|((x5)&(x40));
x42 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x43 = (x42)^((uintptr_t)4294967295ULL);
x44 = ((x18)&(x42))|((x6)&(x43));
x45 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x46 = (x45)^((uintptr_t)4294967295ULL);
x47 = ((x19)&(x45))|((x7)&(x46));
x48 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x49 = (x48)^((uintptr_t)4294967295ULL);
x50 = ((x20)&(x48))|((x8)&(x49));
x51 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x52 = (x51)^((uintptr_t)4294967295ULL);
x53 = ((x21)&(x51))|((x9)&(x52));
x54 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x55 = (x54)^((uintptr_t)4294967295ULL);
x56 = ((x22)&(x54))|((x10)&(x55));
x57 = ((uintptr_t)-1ULL)+((in0)==((uintptr_t)0ULL));
x58 = (x57)^((uintptr_t)4294967295ULL);
x59 = ((x23)&(x57))|((x11)&(x58));
x60 = x26;
x61 = x29;
x62 = x32;
x63 = x35;
x64 = x38;
x65 = x41;
x66 = x44;
x67 = x47;
x68 = x50;
x69 = x53;
x70 = x56;
x71 = x59;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x60;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x61;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x62;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x63;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x64;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x65;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x66;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x67;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x68;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x69;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x70;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x71;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
* Output Bounds:
* out0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
*/
void fiat_p384_to_bytes(uintptr_t in0, uintptr_t out0) {
uintptr_t x11, x10, x9, x8, x7, x6, x5, x4, x3, x2, x1, x0, x23, x24, x26, x28, x22, x31, x33, x35, x21, x38, x40, x42, x20, x45, x47, x49, x19, x52, x54, x56, x18, x59, x61, x63, x17, x66, x68, x70, x16, x73, x75, x77, x15, x80, x82, x84, x14, x87, x89, x91, x13, x94, x96, x98, x12, x101, x103, x25, x27, x29, x30, x32, x34, x36, x37, x39, x41, x43, x44, x46, x48, x50, x51, x53, x55, x57, x58, x60, x62, x64, x65, x67, x69, x71, x72, x74, x76, x78, x79, x81, x83, x85, x86, x88, x90, x92, x93, x95, x97, x99, x100, x102, x104, x106, x105, 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, x144, x145, x146, x147, x148, x149, x150, x151, x152, x153, x154;
x0 = *(uintptr_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uintptr_t*)((in0)+((uintptr_t)4ULL));
x2 = *(uintptr_t*)((in0)+((uintptr_t)8ULL));
x3 = *(uintptr_t*)((in0)+((uintptr_t)12ULL));
x4 = *(uintptr_t*)((in0)+((uintptr_t)16ULL));
x5 = *(uintptr_t*)((in0)+((uintptr_t)20ULL));
x6 = *(uintptr_t*)((in0)+((uintptr_t)24ULL));
x7 = *(uintptr_t*)((in0)+((uintptr_t)28ULL));
x8 = *(uintptr_t*)((in0)+((uintptr_t)32ULL));
x9 = *(uintptr_t*)((in0)+((uintptr_t)36ULL));
x10 = *(uintptr_t*)((in0)+((uintptr_t)40ULL));
x11 = *(uintptr_t*)((in0)+((uintptr_t)44ULL));
/*skip*/
/*skip*/
x12 = x11;
x13 = x10;
x14 = x9;
x15 = x8;
x16 = x7;
x17 = x6;
x18 = x5;
x19 = x4;
x20 = x3;
x21 = x2;
x22 = x1;
x23 = x0;
x24 = (x23)>>((uintptr_t)8ULL);
x25 = (x23)&((uintptr_t)255ULL);
x26 = (x24)>>((uintptr_t)8ULL);
x27 = (x24)&((uintptr_t)255ULL);
x28 = (x26)>>((uintptr_t)8ULL);
x29 = (x26)&((uintptr_t)255ULL);
x30 = (x28)&((uintptr_t)255ULL);
x31 = (x22)>>((uintptr_t)8ULL);
x32 = (x22)&((uintptr_t)255ULL);
x33 = (x31)>>((uintptr_t)8ULL);
x34 = (x31)&((uintptr_t)255ULL);
x35 = (x33)>>((uintptr_t)8ULL);
x36 = (x33)&((uintptr_t)255ULL);
x37 = (x35)&((uintptr_t)255ULL);
x38 = (x21)>>((uintptr_t)8ULL);
x39 = (x21)&((uintptr_t)255ULL);
x40 = (x38)>>((uintptr_t)8ULL);
x41 = (x38)&((uintptr_t)255ULL);
x42 = (x40)>>((uintptr_t)8ULL);
x43 = (x40)&((uintptr_t)255ULL);
x44 = (x42)&((uintptr_t)255ULL);
x45 = (x20)>>((uintptr_t)8ULL);
x46 = (x20)&((uintptr_t)255ULL);
x47 = (x45)>>((uintptr_t)8ULL);
x48 = (x45)&((uintptr_t)255ULL);
x49 = (x47)>>((uintptr_t)8ULL);
x50 = (x47)&((uintptr_t)255ULL);
x51 = (x49)&((uintptr_t)255ULL);
x52 = (x19)>>((uintptr_t)8ULL);
x53 = (x19)&((uintptr_t)255ULL);
x54 = (x52)>>((uintptr_t)8ULL);
x55 = (x52)&((uintptr_t)255ULL);
x56 = (x54)>>((uintptr_t)8ULL);
x57 = (x54)&((uintptr_t)255ULL);
x58 = (x56)&((uintptr_t)255ULL);
x59 = (x18)>>((uintptr_t)8ULL);
x60 = (x18)&((uintptr_t)255ULL);
x61 = (x59)>>((uintptr_t)8ULL);
x62 = (x59)&((uintptr_t)255ULL);
x63 = (x61)>>((uintptr_t)8ULL);
x64 = (x61)&((uintptr_t)255ULL);
x65 = (x63)&((uintptr_t)255ULL);
x66 = (x17)>>((uintptr_t)8ULL);
x67 = (x17)&((uintptr_t)255ULL);
x68 = (x66)>>((uintptr_t)8ULL);
x69 = (x66)&((uintptr_t)255ULL);
x70 = (x68)>>((uintptr_t)8ULL);
x71 = (x68)&((uintptr_t)255ULL);
x72 = (x70)&((uintptr_t)255ULL);
x73 = (x16)>>((uintptr_t)8ULL);
x74 = (x16)&((uintptr_t)255ULL);
x75 = (x73)>>((uintptr_t)8ULL);
x76 = (x73)&((uintptr_t)255ULL);
x77 = (x75)>>((uintptr_t)8ULL);
x78 = (x75)&((uintptr_t)255ULL);
x79 = (x77)&((uintptr_t)255ULL);
x80 = (x15)>>((uintptr_t)8ULL);
x81 = (x15)&((uintptr_t)255ULL);
x82 = (x80)>>((uintptr_t)8ULL);
x83 = (x80)&((uintptr_t)255ULL);
x84 = (x82)>>((uintptr_t)8ULL);
x85 = (x82)&((uintptr_t)255ULL);
x86 = (x84)&((uintptr_t)255ULL);
x87 = (x14)>>((uintptr_t)8ULL);
x88 = (x14)&((uintptr_t)255ULL);
x89 = (x87)>>((uintptr_t)8ULL);
x90 = (x87)&((uintptr_t)255ULL);
x91 = (x89)>>((uintptr_t)8ULL);
x92 = (x89)&((uintptr_t)255ULL);
x93 = (x91)&((uintptr_t)255ULL);
x94 = (x13)>>((uintptr_t)8ULL);
x95 = (x13)&((uintptr_t)255ULL);
x96 = (x94)>>((uintptr_t)8ULL);
x97 = (x94)&((uintptr_t)255ULL);
x98 = (x96)>>((uintptr_t)8ULL);
x99 = (x96)&((uintptr_t)255ULL);
x100 = (x98)&((uintptr_t)255ULL);
x101 = (x12)>>((uintptr_t)8ULL);
x102 = (x12)&((uintptr_t)255ULL);
x103 = (x101)>>((uintptr_t)8ULL);
x104 = (x101)&((uintptr_t)255ULL);
x105 = (x103)>>((uintptr_t)8ULL);
x106 = (x103)&((uintptr_t)255ULL);
x107 = x25;
x108 = x27;
x109 = x29;
x110 = x30;
x111 = x32;
x112 = x34;
x113 = x36;
x114 = x37;
x115 = x39;
x116 = x41;
x117 = x43;
x118 = x44;
x119 = x46;
x120 = x48;
x121 = x50;
x122 = x51;
x123 = x53;
x124 = x55;
x125 = x57;
x126 = x58;
x127 = x60;
x128 = x62;
x129 = x64;
x130 = x65;
x131 = x67;
x132 = x69;
x133 = x71;
x134 = x72;
x135 = x74;
x136 = x76;
x137 = x78;
x138 = x79;
x139 = x81;
x140 = x83;
x141 = x85;
x142 = x86;
x143 = x88;
x144 = x90;
x145 = x92;
x146 = x93;
x147 = x95;
x148 = x97;
x149 = x99;
x150 = x100;
x151 = x102;
x152 = x104;
x153 = x106;
x154 = x105;
/*skip*/
*(uint8_t*)((out0)+((uintptr_t)0ULL)) = x107;
*(uint8_t*)((out0)+((uintptr_t)1ULL)) = x108;
*(uint8_t*)((out0)+((uintptr_t)2ULL)) = x109;
*(uint8_t*)((out0)+((uintptr_t)3ULL)) = x110;
*(uint8_t*)((out0)+((uintptr_t)4ULL)) = x111;
*(uint8_t*)((out0)+((uintptr_t)5ULL)) = x112;
*(uint8_t*)((out0)+((uintptr_t)6ULL)) = x113;
*(uint8_t*)((out0)+((uintptr_t)7ULL)) = x114;
*(uint8_t*)((out0)+((uintptr_t)8ULL)) = x115;
*(uint8_t*)((out0)+((uintptr_t)9ULL)) = x116;
*(uint8_t*)((out0)+((uintptr_t)10ULL)) = x117;
*(uint8_t*)((out0)+((uintptr_t)11ULL)) = x118;
*(uint8_t*)((out0)+((uintptr_t)12ULL)) = x119;
*(uint8_t*)((out0)+((uintptr_t)13ULL)) = x120;
*(uint8_t*)((out0)+((uintptr_t)14ULL)) = x121;
*(uint8_t*)((out0)+((uintptr_t)15ULL)) = x122;
*(uint8_t*)((out0)+((uintptr_t)16ULL)) = x123;
*(uint8_t*)((out0)+((uintptr_t)17ULL)) = x124;
*(uint8_t*)((out0)+((uintptr_t)18ULL)) = x125;
*(uint8_t*)((out0)+((uintptr_t)19ULL)) = x126;
*(uint8_t*)((out0)+((uintptr_t)20ULL)) = x127;
*(uint8_t*)((out0)+((uintptr_t)21ULL)) = x128;
*(uint8_t*)((out0)+((uintptr_t)22ULL)) = x129;
*(uint8_t*)((out0)+((uintptr_t)23ULL)) = x130;
*(uint8_t*)((out0)+((uintptr_t)24ULL)) = x131;
*(uint8_t*)((out0)+((uintptr_t)25ULL)) = x132;
*(uint8_t*)((out0)+((uintptr_t)26ULL)) = x133;
*(uint8_t*)((out0)+((uintptr_t)27ULL)) = x134;
*(uint8_t*)((out0)+((uintptr_t)28ULL)) = x135;
*(uint8_t*)((out0)+((uintptr_t)29ULL)) = x136;
*(uint8_t*)((out0)+((uintptr_t)30ULL)) = x137;
*(uint8_t*)((out0)+((uintptr_t)31ULL)) = x138;
*(uint8_t*)((out0)+((uintptr_t)32ULL)) = x139;
*(uint8_t*)((out0)+((uintptr_t)33ULL)) = x140;
*(uint8_t*)((out0)+((uintptr_t)34ULL)) = x141;
*(uint8_t*)((out0)+((uintptr_t)35ULL)) = x142;
*(uint8_t*)((out0)+((uintptr_t)36ULL)) = x143;
*(uint8_t*)((out0)+((uintptr_t)37ULL)) = x144;
*(uint8_t*)((out0)+((uintptr_t)38ULL)) = x145;
*(uint8_t*)((out0)+((uintptr_t)39ULL)) = x146;
*(uint8_t*)((out0)+((uintptr_t)40ULL)) = x147;
*(uint8_t*)((out0)+((uintptr_t)41ULL)) = x148;
*(uint8_t*)((out0)+((uintptr_t)42ULL)) = x149;
*(uint8_t*)((out0)+((uintptr_t)43ULL)) = x150;
*(uint8_t*)((out0)+((uintptr_t)44ULL)) = x151;
*(uint8_t*)((out0)+((uintptr_t)45ULL)) = x152;
*(uint8_t*)((out0)+((uintptr_t)46ULL)) = x153;
*(uint8_t*)((out0)+((uintptr_t)47ULL)) = x154;
/*skip*/
return;
}
/*
* Input Bounds:
* in0: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff]]
* Output Bounds:
* out0: [[0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff], [0x0 ~> 0xffffffff]]
*/
void fiat_p384_from_bytes(uintptr_t in0, uintptr_t out0) {
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, x95, x94, x93, x92, x96, x51, x50, x49, x48, x55, x54, x53, x52, x59, x58, x57, x56, x63, x62, x61, x60, x67, x66, x65, x64, x71, x70, x69, x68, x75, x74, x73, x72, x79, x78, x77, x76, x83, x82, x81, x80, x87, x86, x85, x84, x91, x90, x89, x88, x108, x107, x106, x105, x104, x103, x102, x101, x100, x99, x97, x109, x110, x111, x112, x113, x114, x115, x116, x117, x118, x98, x119, x120, x121, x122, x123, x124, x125, x126, x127, x128, x129, x130;
x0 = *(uint8_t*)((in0)+((uintptr_t)0ULL));
x1 = *(uint8_t*)((in0)+((uintptr_t)1ULL));
x2 = *(uint8_t*)((in0)+((uintptr_t)2ULL));
x3 = *(uint8_t*)((in0)+((uintptr_t)3ULL));
x4 = *(uint8_t*)((in0)+((uintptr_t)4ULL));
x5 = *(uint8_t*)((in0)+((uintptr_t)5ULL));
x6 = *(uint8_t*)((in0)+((uintptr_t)6ULL));
x7 = *(uint8_t*)((in0)+((uintptr_t)7ULL));
x8 = *(uint8_t*)((in0)+((uintptr_t)8ULL));
x9 = *(uint8_t*)((in0)+((uintptr_t)9ULL));
x10 = *(uint8_t*)((in0)+((uintptr_t)10ULL));
x11 = *(uint8_t*)((in0)+((uintptr_t)11ULL));
x12 = *(uint8_t*)((in0)+((uintptr_t)12ULL));
x13 = *(uint8_t*)((in0)+((uintptr_t)13ULL));
x14 = *(uint8_t*)((in0)+((uintptr_t)14ULL));
x15 = *(uint8_t*)((in0)+((uintptr_t)15ULL));
x16 = *(uint8_t*)((in0)+((uintptr_t)16ULL));
x17 = *(uint8_t*)((in0)+((uintptr_t)17ULL));
x18 = *(uint8_t*)((in0)+((uintptr_t)18ULL));
x19 = *(uint8_t*)((in0)+((uintptr_t)19ULL));
x20 = *(uint8_t*)((in0)+((uintptr_t)20ULL));
x21 = *(uint8_t*)((in0)+((uintptr_t)21ULL));
x22 = *(uint8_t*)((in0)+((uintptr_t)22ULL));
x23 = *(uint8_t*)((in0)+((uintptr_t)23ULL));
x24 = *(uint8_t*)((in0)+((uintptr_t)24ULL));
x25 = *(uint8_t*)((in0)+((uintptr_t)25ULL));
x26 = *(uint8_t*)((in0)+((uintptr_t)26ULL));
x27 = *(uint8_t*)((in0)+((uintptr_t)27ULL));
x28 = *(uint8_t*)((in0)+((uintptr_t)28ULL));
x29 = *(uint8_t*)((in0)+((uintptr_t)29ULL));
x30 = *(uint8_t*)((in0)+((uintptr_t)30ULL));
x31 = *(uint8_t*)((in0)+((uintptr_t)31ULL));
x32 = *(uint8_t*)((in0)+((uintptr_t)32ULL));
x33 = *(uint8_t*)((in0)+((uintptr_t)33ULL));
x34 = *(uint8_t*)((in0)+((uintptr_t)34ULL));
x35 = *(uint8_t*)((in0)+((uintptr_t)35ULL));
x36 = *(uint8_t*)((in0)+((uintptr_t)36ULL));
x37 = *(uint8_t*)((in0)+((uintptr_t)37ULL));
x38 = *(uint8_t*)((in0)+((uintptr_t)38ULL));
x39 = *(uint8_t*)((in0)+((uintptr_t)39ULL));
x40 = *(uint8_t*)((in0)+((uintptr_t)40ULL));
x41 = *(uint8_t*)((in0)+((uintptr_t)41ULL));
x42 = *(uint8_t*)((in0)+((uintptr_t)42ULL));
x43 = *(uint8_t*)((in0)+((uintptr_t)43ULL));
x44 = *(uint8_t*)((in0)+((uintptr_t)44ULL));
x45 = *(uint8_t*)((in0)+((uintptr_t)45ULL));
x46 = *(uint8_t*)((in0)+((uintptr_t)46ULL));
x47 = *(uint8_t*)((in0)+((uintptr_t)47ULL));
/*skip*/
/*skip*/
x48 = (x47)<<((uintptr_t)24ULL);
x49 = (x46)<<((uintptr_t)16ULL);
x50 = (x45)<<((uintptr_t)8ULL);
x51 = x44;
x52 = (x43)<<((uintptr_t)24ULL);
x53 = (x42)<<((uintptr_t)16ULL);
x54 = (x41)<<((uintptr_t)8ULL);
x55 = x40;
x56 = (x39)<<((uintptr_t)24ULL);
x57 = (x38)<<((uintptr_t)16ULL);
x58 = (x37)<<((uintptr_t)8ULL);
x59 = x36;
x60 = (x35)<<((uintptr_t)24ULL);
x61 = (x34)<<((uintptr_t)16ULL);
x62 = (x33)<<((uintptr_t)8ULL);
x63 = x32;
x64 = (x31)<<((uintptr_t)24ULL);
x65 = (x30)<<((uintptr_t)16ULL);
x66 = (x29)<<((uintptr_t)8ULL);
x67 = x28;
x68 = (x27)<<((uintptr_t)24ULL);
x69 = (x26)<<((uintptr_t)16ULL);
x70 = (x25)<<((uintptr_t)8ULL);
x71 = x24;
x72 = (x23)<<((uintptr_t)24ULL);
x73 = (x22)<<((uintptr_t)16ULL);
x74 = (x21)<<((uintptr_t)8ULL);
x75 = x20;
x76 = (x19)<<((uintptr_t)24ULL);
x77 = (x18)<<((uintptr_t)16ULL);
x78 = (x17)<<((uintptr_t)8ULL);
x79 = x16;
x80 = (x15)<<((uintptr_t)24ULL);
x81 = (x14)<<((uintptr_t)16ULL);
x82 = (x13)<<((uintptr_t)8ULL);
x83 = x12;
x84 = (x11)<<((uintptr_t)24ULL);
x85 = (x10)<<((uintptr_t)16ULL);
x86 = (x9)<<((uintptr_t)8ULL);
x87 = x8;
x88 = (x7)<<((uintptr_t)24ULL);
x89 = (x6)<<((uintptr_t)16ULL);
x90 = (x5)<<((uintptr_t)8ULL);
x91 = x4;
x92 = (x3)<<((uintptr_t)24ULL);
x93 = (x2)<<((uintptr_t)16ULL);
x94 = (x1)<<((uintptr_t)8ULL);
x95 = x0;
x96 = (x95)+((x94)+((x93)+(x92)));
x97 = (x96)&((uintptr_t)4294967295ULL);
x98 = (x51)+((x50)+((x49)+(x48)));
x99 = (x55)+((x54)+((x53)+(x52)));
x100 = (x59)+((x58)+((x57)+(x56)));
x101 = (x63)+((x62)+((x61)+(x60)));
x102 = (x67)+((x66)+((x65)+(x64)));
x103 = (x71)+((x70)+((x69)+(x68)));
x104 = (x75)+((x74)+((x73)+(x72)));
x105 = (x79)+((x78)+((x77)+(x76)));
x106 = (x83)+((x82)+((x81)+(x80)));
x107 = (x87)+((x86)+((x85)+(x84)));
x108 = (x91)+((x90)+((x89)+(x88)));
x109 = (x108)&((uintptr_t)4294967295ULL);
x110 = (x107)&((uintptr_t)4294967295ULL);
x111 = (x106)&((uintptr_t)4294967295ULL);
x112 = (x105)&((uintptr_t)4294967295ULL);
x113 = (x104)&((uintptr_t)4294967295ULL);
x114 = (x103)&((uintptr_t)4294967295ULL);
x115 = (x102)&((uintptr_t)4294967295ULL);
x116 = (x101)&((uintptr_t)4294967295ULL);
x117 = (x100)&((uintptr_t)4294967295ULL);
x118 = (x99)&((uintptr_t)4294967295ULL);
x119 = x97;
x120 = x109;
x121 = x110;
x122 = x111;
x123 = x112;
x124 = x113;
x125 = x114;
x126 = x115;
x127 = x116;
x128 = x117;
x129 = x118;
x130 = x98;
/*skip*/
*(uintptr_t*)((out0)+((uintptr_t)0ULL)) = x119;
*(uintptr_t*)((out0)+((uintptr_t)4ULL)) = x120;
*(uintptr_t*)((out0)+((uintptr_t)8ULL)) = x121;
*(uintptr_t*)((out0)+((uintptr_t)12ULL)) = x122;
*(uintptr_t*)((out0)+((uintptr_t)16ULL)) = x123;
*(uintptr_t*)((out0)+((uintptr_t)20ULL)) = x124;
*(uintptr_t*)((out0)+((uintptr_t)24ULL)) = x125;
*(uintptr_t*)((out0)+((uintptr_t)28ULL)) = x126;
*(uintptr_t*)((out0)+((uintptr_t)32ULL)) = x127;
*(uintptr_t*)((out0)+((uintptr_t)36ULL)) = x128;
*(uintptr_t*)((out0)+((uintptr_t)40ULL)) = x129;
*(uintptr_t*)((out0)+((uintptr_t)44ULL)) = x130;
/*skip*/
return;
}
|
the_stack_data/72012883.c | /*
* This file is part of the µOS++ distribution.
* (https://github.com/micro-os-plus)
* Copyright (c) 2014 Liviu Ionescu.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
// ----------------------------------------------------------------------------
#if defined(TRACE)
#include "cmsis_device.h"
#include "diag/trace.h"
// ----------------------------------------------------------------------------
// One of these definitions must be passed via the compiler command line
// Note: small Cortex-M0/M0+ might implement a simplified debug interface.
//#define OS_USE_TRACE_ITM
//#define OS_USE_TRACE_SEMIHOSTING_DEBUG
//#define OS_USE_TRACE_SEMIHOSTING_STDOUT
#if !(defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))
#if defined(OS_USE_TRACE_ITM)
#undef OS_USE_TRACE_ITM
#warning "ITM unavailable"
#endif // defined(OS_USE_TRACE_ITM)
#endif // !(defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__))
#if defined(OS_DEBUG_SEMIHOSTING_FAULTS)
#if defined(OS_USE_TRACE_SEMIHOSTING_STDOUT) || defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
#error "Cannot debug semihosting using semihosting trace; use OS_USE_TRACE_ITM"
#endif
#endif
// ----------------------------------------------------------------------------
// Forward definitions.
#if defined(OS_USE_TRACE_ITM)
static ssize_t
_trace_write_itm (const char* buf, size_t nbyte);
#endif
#if defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
static ssize_t
_trace_write_semihosting_stdout(const char* buf, size_t nbyte);
#endif
#if defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
static ssize_t
_trace_write_semihosting_debug(const char* buf, size_t nbyte);
#endif
// ----------------------------------------------------------------------------
void
trace_initialize(void)
{
// For regular ITM / semihosting, no inits required.
}
// ----------------------------------------------------------------------------
// This function is called from _write() for fd==1 or fd==2 and from some
// of the trace_* functions.
ssize_t
trace_write (const char* buf __attribute__((unused)),
size_t nbyte __attribute__((unused)))
{
#if defined(OS_USE_TRACE_ITM)
return _trace_write_itm (buf, nbyte);
#elif defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
return _trace_write_semihosting_stdout(buf, nbyte);
#elif defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
return _trace_write_semihosting_debug(buf, nbyte);
#endif
return -1;
}
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_ITM)
#if defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
// ITM is the ARM standard mechanism, running over SWD/SWO on Cortex-M3/M4
// devices, and is the recommended setting, if available.
//
// The JLink probe and the GDB server fully support SWD/SWO
// and the JLink Debugging plug-in enables it by default.
// The current OpenOCD does not include support to parse the SWO stream,
// so this configuration will not work on OpenOCD (will not crash, but
// nothing will be displayed in the output console).
#if !defined(OS_INTEGER_TRACE_ITM_STIMULUS_PORT)
#define OS_INTEGER_TRACE_ITM_STIMULUS_PORT (0)
#endif
static ssize_t
_trace_write_itm (const char* buf, size_t nbyte)
{
for (size_t i = 0; i < nbyte; i++)
{
// Check if ITM or the stimulus port are not enabled
if (((ITM->TCR & ITM_TCR_ITMENA_Msk) == 0)
|| ((ITM->TER & (1UL << OS_INTEGER_TRACE_ITM_STIMULUS_PORT)) == 0))
{
return (ssize_t)i; // return the number of sent characters (may be 0)
}
// Wait until STIMx is ready...
while (ITM->PORT[OS_INTEGER_TRACE_ITM_STIMULUS_PORT].u32 == 0)
;
// then send data, one byte at a time
ITM->PORT[OS_INTEGER_TRACE_ITM_STIMULUS_PORT].u8 = (uint8_t) (*buf++);
}
return (ssize_t)nbyte; // all characters successfully sent
}
#endif // defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__)
#endif // OS_USE_TRACE_ITM
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_SEMIHOSTING_DEBUG) || defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
#include "arm/semihosting.h"
// Semihosting is the other output channel that can be used for the trace
// messages. It comes in two flavours: STDOUT and DEBUG. The STDOUT channel
// is the equivalent of the stdout in POSIX and in most cases it is forwarded
// to the GDB server stdout stream. The debug channel is a separate
// channel. STDOUT is buffered, so nothing is displayed until a \n;
// DEBUG is not buffered, but can be slow.
//
// Choosing between semihosting stdout and debug depends on the capabilities
// of your GDB server, and also on specific needs. It is recommended to test
// DEBUG first, and if too slow, try STDOUT.
//
// The JLink GDB server fully support semihosting, and both configurations
// are available; to activate it, use "monitor semihosting enable" or check
// the corresponding button in the JLink Debugging plug-in.
// In OpenOCD, support for semihosting can be enabled using
// "monitor arm semihosting enable".
//
// Note: Applications built with semihosting output active normally cannot
// be executed without the debugger connected and active, since they use
// BKPT to communicate with the host. However, with a carefully written
// HardFault_Handler, the semihosting BKPT calls can be processed, making
// possible to run semihosting applications as standalone, without being
// terminated with hardware faults.
#endif // OS_USE_TRACE_SEMIHOSTING_DEBUG_*
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_SEMIHOSTING_STDOUT)
static ssize_t
_trace_write_semihosting_stdout (const char* buf, size_t nbyte)
{
static int handle;
void* block[3];
int ret;
if (handle == 0)
{
// On the first call get the file handle from the host
block[0] = ":tt"; // special filename to be used for stdin/out/err
block[1] = (void*) 4; // mode "w"
// length of ":tt", except null terminator
block[2] = (void*) (sizeof(":tt") - 1);
ret = call_host (SEMIHOSTING_SYS_OPEN, (void*) block);
if (ret == -1)
return -1;
handle = ret;
}
block[0] = (void*) handle;
block[1] = (void*) buf;
block[2] = (void*) nbyte;
// send character array to host file/device
ret = call_host (SEMIHOSTING_SYS_WRITE, (void*) block);
// this call returns the number of bytes NOT written (0 if all ok)
// -1 is not a legal value, but SEGGER seems to return it
if (ret == -1)
return -1;
// The compliant way of returning errors
if (ret == (int) nbyte)
return -1;
// Return the number of bytes written
return (ssize_t) (nbyte) - (ssize_t) ret;
}
#endif // OS_USE_TRACE_SEMIHOSTING_STDOUT
// ----------------------------------------------------------------------------
#if defined(OS_USE_TRACE_SEMIHOSTING_DEBUG)
#define OS_INTEGER_TRACE_TMP_ARRAY_SIZE (16)
static ssize_t
_trace_write_semihosting_debug (const char* buf, size_t nbyte)
{
// Since the single character debug channel is quite slow, try to
// optimise and send a null terminated string, if possible.
if (buf[nbyte] == '\0')
{
// send string
call_host (SEMIHOSTING_SYS_WRITE0, (void*) buf);
}
else
{
// If not, use a local buffer to speed things up
char tmp[OS_INTEGER_TRACE_TMP_ARRAY_SIZE];
size_t togo = nbyte;
while (togo > 0)
{
unsigned int n = ((togo < sizeof(tmp)) ? togo : sizeof(tmp));
unsigned int i = 0;
for (; i < n; ++i, ++buf)
{
tmp[i] = *buf;
}
tmp[i] = '\0';
call_host (SEMIHOSTING_SYS_WRITE0, (void*) tmp);
togo -= n;
}
}
// All bytes written
return (ssize_t) nbyte;
}
#endif // OS_USE_TRACE_SEMIHOSTING_DEBUG
#endif // TRACE
// ----------------------------------------------------------------------------
|
the_stack_data/35292.c | #include <stdio.h>
int main() {
unsigned int e, i, cifra;
unsigned char str[51];
scanf("%d", &e);
while(e--) {
scanf("%s", str);
scanf("%d", &cifra);
for(i = 0; str[i] != '\0'; i++) {
str[i] -= cifra;
if(str[i] < 'A')
str[i] += 26;
}
printf("%s\n", str);
}
return 0;
}
|
the_stack_data/1244859.c | #ifdef __i386__
/* -----------------------------------------------------------------------
ffi.c - Copyright (c) 1996, 1998, 1999, 2001 Red Hat, Inc.
Copyright (c) 2002 Ranjit Mathew
Copyright (c) 2002 Bo Thorsen
Copyright (c) 2002 Roger Sayle
x86 Foreign Function Interface
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
``Software''), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
----------------------------------------------------------------------- */
#include <ffi.h>
#include <ffi_common.h>
#include <stdlib.h>
/* ffi_prep_args is called by the assembly routine once stack space
has been allocated for the function's arguments */
void ffi_prep_args(char *stack, extended_cif *ecif);
void ffi_prep_args(char *stack, extended_cif *ecif)
{
register unsigned int i;
register void **p_argv;
register char *argp;
register ffi_type **p_arg;
argp = stack;
if (ecif->cif->flags == FFI_TYPE_STRUCT)
{
*(void **) argp = ecif->rvalue;
argp += 4;
}
p_argv = ecif->avalue;
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
i != 0;
i--, p_arg++)
{
size_t z;
/* Align if necessary */
if ((sizeof(int) - 1) & (unsigned) argp)
argp = (char *) ALIGN(argp, sizeof(int));
z = (*p_arg)->size;
if (z < sizeof(int))
{
z = sizeof(int);
switch ((*p_arg)->type)
{
case FFI_TYPE_SINT8:
*(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
break;
case FFI_TYPE_UINT8:
*(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
break;
case FFI_TYPE_SINT16:
*(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
break;
case FFI_TYPE_UINT16:
*(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
break;
case FFI_TYPE_SINT32:
*(signed int *) argp = (signed int)*(SINT32 *)(* p_argv);
break;
case FFI_TYPE_UINT32:
*(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
break;
case FFI_TYPE_STRUCT:
*(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
break;
default:
FFI_ASSERT(0);
}
}
else
{
memcpy(argp, *p_argv, z);
}
p_argv++;
argp += z;
}
return;
}
/* Perform machine dependent cif processing */
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
{
/* Set the return type flag */
switch (cif->rtype->type)
{
case FFI_TYPE_VOID:
#ifdef X86
case FFI_TYPE_STRUCT:
case FFI_TYPE_UINT8:
case FFI_TYPE_UINT16:
case FFI_TYPE_SINT8:
case FFI_TYPE_SINT16:
#endif
case FFI_TYPE_SINT64:
case FFI_TYPE_FLOAT:
case FFI_TYPE_DOUBLE:
case FFI_TYPE_LONGDOUBLE:
cif->flags = (unsigned) cif->rtype->type;
break;
case FFI_TYPE_UINT64:
cif->flags = FFI_TYPE_SINT64;
break;
#ifndef X86
case FFI_TYPE_STRUCT:
if (cif->rtype->size == 1)
{
cif->flags = FFI_TYPE_SINT8; /* same as char size */
}
else if (cif->rtype->size == 2)
{
cif->flags = FFI_TYPE_SINT16; /* same as short size */
}
else if (cif->rtype->size == 4)
{
cif->flags = FFI_TYPE_INT; /* same as int type */
}
else if (cif->rtype->size == 8)
{
cif->flags = FFI_TYPE_SINT64; /* same as int64 type */
}
else
{
cif->flags = FFI_TYPE_STRUCT;
}
break;
#endif
default:
cif->flags = FFI_TYPE_INT;
break;
}
#ifdef X86_DARWIN
cif->bytes = (cif->bytes + 15) & ~0xF;
#endif
return FFI_OK;
}
extern void ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *,
unsigned, unsigned, unsigned *, void (*fn)());
#ifdef X86_WIN32
extern void ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *,
unsigned, unsigned, unsigned *, void (*fn)());
#endif /* X86_WIN32 */
void ffi_call(ffi_cif *cif, void (*fn)(), void *rvalue, void **avalue)
{
extended_cif ecif;
ecif.cif = cif;
ecif.avalue = avalue;
/* If the return value is a struct and we don't have a return */
/* value address then we need to make one */
if ((rvalue == NULL) &&
(cif->flags == FFI_TYPE_STRUCT))
{
ecif.rvalue = alloca(cif->rtype->size);
}
else
ecif.rvalue = rvalue;
switch (cif->abi)
{
case FFI_SYSV:
ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes, cif->flags, ecif.rvalue,
fn);
break;
#ifdef X86_WIN32
case FFI_STDCALL:
ffi_call_STDCALL(ffi_prep_args, &ecif, cif->bytes, cif->flags,
ecif.rvalue, fn);
break;
#endif /* X86_WIN32 */
default:
FFI_ASSERT(0);
break;
}
}
/** private members **/
static void ffi_prep_incoming_args_SYSV (char *stack, void **ret,
void** args, ffi_cif* cif);
void FFI_HIDDEN ffi_closure_SYSV (ffi_closure *)
__attribute__ ((regparm(1)));
unsigned int FFI_HIDDEN ffi_closure_SYSV_inner (ffi_closure *, void **, void *)
__attribute__ ((regparm(1)));
void FFI_HIDDEN ffi_closure_raw_SYSV (ffi_raw_closure *)
__attribute__ ((regparm(1)));
/* This function is jumped to by the trampoline */
unsigned int FFI_HIDDEN
ffi_closure_SYSV_inner (closure, respp, args)
ffi_closure *closure;
void **respp;
void *args;
{
// our various things...
ffi_cif *cif;
void **arg_area;
cif = closure->cif;
arg_area = (void**) alloca (cif->nargs * sizeof (void*));
/* this call will initialize ARG_AREA, such that each
* element in that array points to the corresponding
* value on the stack; and if the function returns
* a structure, it will re-set RESP to point to the
* structure return address. */
ffi_prep_incoming_args_SYSV(args, respp, arg_area, cif);
(closure->fun) (cif, *respp, arg_area, closure->user_data);
return cif->flags;
}
static void
ffi_prep_incoming_args_SYSV(char *stack, void **rvalue, void **avalue,
ffi_cif *cif)
{
register unsigned int i;
register void **p_argv;
register char *argp;
register ffi_type **p_arg;
argp = stack;
if ( cif->flags == FFI_TYPE_STRUCT ) {
*rvalue = *(void **) argp;
argp += 4;
}
p_argv = avalue;
for (i = cif->nargs, p_arg = cif->arg_types; (i != 0); i--, p_arg++)
{
size_t z;
/* Align if necessary */
if ((sizeof(int) - 1) & (unsigned) argp) {
argp = (char *) ALIGN(argp, sizeof(int));
}
z = (*p_arg)->size;
/* because we're little endian, this is what it turns into. */
*p_argv = (void*) argp;
p_argv++;
argp += z;
}
return;
}
/* How to make a trampoline. Derived from gcc/config/i386/i386.c. */
#define FFI_INIT_TRAMPOLINE(TRAMP,FUN,CTX) \
({ unsigned char *__tramp = (unsigned char*)(TRAMP); \
unsigned int __fun = (unsigned int)(FUN); \
unsigned int __ctx = (unsigned int)(CTX); \
unsigned int __dis = __fun - (__ctx + FFI_TRAMPOLINE_SIZE); \
*(unsigned char*) &__tramp[0] = 0xb8; \
*(unsigned int*) &__tramp[1] = __ctx; /* movl __ctx, %eax */ \
*(unsigned char *) &__tramp[5] = 0xe9; \
*(unsigned int*) &__tramp[6] = __dis; /* jmp __fun */ \
})
/* the cif must already be prep'ed */
ffi_status
ffi_prep_closure (ffi_closure* closure,
ffi_cif* cif,
void (*fun)(ffi_cif*,void*,void**,void*),
void *user_data)
{
if (cif->abi != FFI_SYSV)
return FFI_BAD_ABI;
FFI_INIT_TRAMPOLINE (&closure->tramp[0], \
&ffi_closure_SYSV, \
(void*)closure);
closure->cif = cif;
closure->user_data = user_data;
closure->fun = fun;
return FFI_OK;
}
/* ------- Native raw API support -------------------------------- */
#if !FFI_NO_RAW_API
ffi_status
ffi_prep_raw_closure_loc (ffi_raw_closure* closure,
ffi_cif* cif,
void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
void *user_data,
void *codeloc)
{
int i;
FFI_ASSERT (cif->abi == FFI_SYSV);
// we currently don't support certain kinds of arguments for raw
// closures. This should be implemented by a separate assembly language
// routine, since it would require argument processing, something we
// don't do now for performance.
for (i = cif->nargs-1; i >= 0; i--)
{
FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_STRUCT);
FFI_ASSERT (cif->arg_types[i]->type != FFI_TYPE_LONGDOUBLE);
}
FFI_INIT_TRAMPOLINE (&closure->tramp[0], &ffi_closure_raw_SYSV,
codeloc);
closure->cif = cif;
closure->user_data = user_data;
closure->fun = fun;
return FFI_OK;
}
static void
ffi_prep_args_raw(char *stack, extended_cif *ecif)
{
memcpy (stack, ecif->avalue, ecif->cif->bytes);
}
/* we borrow this routine from libffi (it must be changed, though, to
* actually call the function passed in the first argument. as of
* libffi-1.20, this is not the case.)
*/
extern void
ffi_call_SYSV(void (*)(char *, extended_cif *), extended_cif *, unsigned,
unsigned, unsigned *, void (*fn)());
#ifdef X86_WIN32
extern void
ffi_call_STDCALL(void (*)(char *, extended_cif *), extended_cif *, unsigned,
unsigned, unsigned *, void (*fn)());
#endif /* X86_WIN32 */
void
ffi_raw_call(ffi_cif *cif, void (*fn)(), void *rvalue, ffi_raw *fake_avalue)
{
extended_cif ecif;
void **avalue = (void **)fake_avalue;
ecif.cif = cif;
ecif.avalue = avalue;
/* If the return value is a struct and we don't have a return */
/* value address then we need to make one */
if ((rvalue == NULL) &&
(cif->rtype->type == FFI_TYPE_STRUCT))
{
ecif.rvalue = alloca(cif->rtype->size);
}
else
ecif.rvalue = rvalue;
switch (cif->abi)
{
case FFI_SYSV:
ffi_call_SYSV(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags,
ecif.rvalue, fn);
break;
#ifdef X86_WIN32
case FFI_STDCALL:
ffi_call_STDCALL(ffi_prep_args_raw, &ecif, cif->bytes, cif->flags,
ecif.rvalue, fn);
break;
#endif /* X86_WIN32 */
default:
FFI_ASSERT(0);
break;
}
}
#endif
#endif // __i386__
|
the_stack_data/907344.c | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
/*
* LIBRARY CODE FOR VERY USEFULL STUFF
*/
typedef int (*preprocessor_t)(int input_value);
int magic_numbers[] = {10, 100, 10, 50, 22, 8};
void print_magic_numbers(preprocessor_t preprocessor_func) {
int i;
for (i = 0; i < sizeof(magic_numbers) / sizeof(magic_numbers[0]); i++) {
printf("Number %d is %d\n", i, preprocessor_func(magic_numbers[i]));
}
}
/*
* OUR CODE
*/
struct addBias;
typedef int (*addBiasFunc_t)(struct addBias, int);
struct addBias {
int bias;
addBiasFunc_t func;
} addBias1, addBias20;
int addExactBiasFunc(struct addBias addBias, int value) {
return value + addBias.bias;
}
int addNoisyBiasFunc(struct addBias addBias, int value) {
return value + (((long)addBias.bias*rand())/RAND_MAX);
}
struct addBias addExactBiasCreate(int bias) {
struct addBias b;
b.bias = bias;
b.func = addExactBiasFunc;
return b;
}
struct addBias addNoisyBiasCreate(int bias) {
struct addBias b;
b.bias = bias;
b.func = addNoisyBiasFunc;
return b;
}
int bias_preprocessor_1(int input_value) {
return addBias1.func(addBias1, input_value);
}
int bias_preprocessor_20(int input_value) {
return addBias20.func(addBias20, input_value);
}
int main() {
addBias1 = addExactBiasCreate(1);
addBias20 = addNoisyBiasCreate(20);
srand(time(NULL));
printf("Values with bias = 1:\n");
print_magic_numbers(bias_preprocessor_1);
printf("Values with bias = ~20:\n");
print_magic_numbers(bias_preprocessor_20);
return 0;
}
/*
* Comnpile: gcc -Wall -Werror -pedantic addBias_6.c
* Run: ./a.out
*
* Terminal output:
* Values with bias = 1:
* Number 0 is 11
* Number 1 is 101
* Number 2 is 11
* Number 3 is 51
* Number 4 is 23
* Number 5 is 9
* Values with bias = ~20:
* Number 0 is 16
* Number 1 is 117
* Number 2 is 13
* Number 3 is 56
* Number 4 is 28
* Number 5 is 17
*/
|
the_stack_data/6387487.c | #include <stdio.h>
int main(int argc, char *argv[])
{
int v1[] = {1, 2, 3, 4, 5};
int v2[] = {1, 2, 3, 4, 5};
int vSoma[5], vMult[5], vUniao[10], i, j;
for (i = 0; i < 5; i++)
{
vSoma[i] = v1[i] + v2[i];
vMult[i] = v1[i] * v2[i];
}
for (i = 0; i < 10; i++)
{
if (i < 5)
{
vUniao[i] = v1[i];
}
else if (i >= 5)
{
j = i - 5;
vUniao[i] = v2[j];
}
}
for (i = 0; i < 5; i++)
{
printf("Vetor soma posição %d %d \n", i, vSoma[i]);
printf("Vetor multiplição posição %d %d \n", i, vMult[i]);
}
for (i = 0; i < 10; i++)
{
printf("%d \n", vUniao[i]);
}
return 0;
}
|
the_stack_data/724111.c | //
// Sample Code:
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//#define DEBUG_CORRECTNESS
void pre_Initializing_Input_Tensors();
void post_Correctness();
//
//# abcdef-degb-gfac
//t3 [a,16,b,16,c,16,d,16,e,16,f,16] += sum(g,16) * t2 [d,e,g,b] * v2 [g,f,a,c];
//
int main(int argc, char** argv)
{
// for sd2
double *host_C, *host_C_chk;
double *host_A;
double *host_B;
int size_idx_a, size_idx_b, size_idx_c, size_idx_d, size_idx_e, size_idx_f, size_idx_g;
// Problem Size
size_idx_a = 16;
size_idx_b = 16;
size_idx_c = 16;
size_idx_d = 16;
size_idx_e = 16;
size_idx_f = 16;
size_idx_g = 16;
//
if (argc == 8)
{
size_idx_a = atoi(argv[1]);
size_idx_b = atoi(argv[2]);
size_idx_c = atoi(argv[3]);
size_idx_d = atoi(argv[4]);
size_idx_e = atoi(argv[5]);
size_idx_f = atoi(argv[6]);
size_idx_g = atoi(argv[7]);
}
int size_C;
int size_A;
int size_B;
int size_internal;
long long int tmp_num = (long long int)((long long int)(size_idx_a * size_idx_b * size_idx_c * size_idx_d * size_idx_e * size_idx_f * size_idx_g) * 2);
//# abcdef-degb-gfac
//t3 [a,16,b,16,c,16,d,16,e,16,f,16] += sum(g,16) * t2 [d,e,g,b] * v2 [g,f,a,c];
size_internal = size_idx_g;
size_C = size_idx_a * size_idx_b * size_idx_c * size_idx_d * size_idx_e * size_idx_f;
size_A = size_idx_d * size_idx_e * size_idx_g * size_idx_b;
size_B = size_idx_g * size_idx_f * size_idx_a * size_idx_c;
//
host_C = (double*)malloc(sizeof(double) * size_C);
host_C_chk = (double*)malloc(sizeof(double) * size_C);
host_A = (double*)malloc(sizeof(double) * size_A);
host_B = (double*)malloc(sizeof(double) * size_B);
printf ("==========================================================================================================\n");
printf (">>> Problem Size (a,b,c,d,e,f) and (g): (%2d,%2d,%2d,%2d,%2d,%2d) and (%2d)\n", size_idx_a, size_idx_b, size_idx_c, size_idx_d, size_idx_e, size_idx_f, size_idx_g);
printf (">>> # of Operations: %lld\n", tmp_num);
printf ("==========================================================================================================\n");
//
// Initialze "1" Output and "2 x 9" Inputs
pre_Initializing_Input_Tensors(host_C, host_C_chk, size_C, host_A, size_A, host_B, size_B);
// Run the Kernels
initmemmodule_();
tccg_32_cuda(size_idx_a, size_idx_b, size_idx_c, size_idx_d, size_idx_e, size_idx_f, size_idx_g, host_C, host_A, host_B);
#ifdef DEBUG_CORRECTNESS
// Correctness-Check
post_Correctness(host_C, host_C_chk, host_A, host_B, size_idx_a, size_idx_b, size_idx_c, size_idx_d, size_idx_e, size_idx_f, size_idx_g);
#endif
// Free
free(host_C); free(host_C_chk);
free(host_A);
free(host_B);
return 0;
}
// Initialize t3 (t3_temp), 9 t2 and 9 v2.
void pre_Initializing_Input_Tensors(double* h_C, double* h_C_chk, int size_C,
double* h_A, int size_A,
double* h_B, int size_B)
{
// t3
int i, j;
for (i = 0; i < size_C; i++)
{
h_C[i] = 0.0;
h_C_chk[i] = 0.0;
}
for (j = 0; j < size_A; j++)
{
h_A[j] = ((double)rand() / RAND_MAX);
}
for (j = 0; j < size_B; j++)
{
h_B[j] = ((double)rand() / RAND_MAX);
}
printf ("==========================================================================================================\n");
printf (" >>> %s <<<\n", __func__);
printf (" C: %'12d\n", size_C);
printf (" A: %'12d, B: %'12d\n", size_A, size_B);
printf ("==========================================================================================================\n");
}
//
void post_Correctness(double* h_C, double* h_C_chk,
double* h_A, double* h_B,
int size_idx_a, int size_idx_b, int size_idx_c, int size_idx_d, int size_idx_e, int size_idx_f, int size_idx_g)
{
//# abcdef-degb-gfac
//t3 [a,16,b,16,c,16,d,16,e,16,f,16] += sum(g,16) * t2 [d,e,g,b] * v2 [g,f,a,c];
int size_C = size_idx_a * size_idx_b * size_idx_c * size_idx_d * size_idx_e * size_idx_f;
long long int tmp_ops = 0;
int ops = 0;
int idx_a, idx_b, idx_c, idx_d, idx_e, idx_f, idx_g;
for (idx_a = 0; idx_a < size_idx_a; idx_a++)
for (idx_b = 0; idx_b < size_idx_b; idx_b++)
for (idx_c = 0; idx_c < size_idx_c; idx_c++)
for (idx_d = 0; idx_d < size_idx_d; idx_d++)
for (idx_e = 0; idx_e < size_idx_e; idx_e++)
for (idx_f = 0; idx_f < size_idx_f; idx_f++)
{
ops = 0;
for (idx_g = 0; idx_g < size_idx_g; idx_g++)
{
int tmp_r_idx = idx_a + (idx_b + (idx_c + (idx_d + (idx_e + (idx_f) * size_idx_e) * size_idx_d) * size_idx_c) * size_idx_b) * size_idx_a;
h_C_chk[tmp_r_idx] += h_A[idx_d + (idx_e + (idx_g + (idx_b) * size_idx_g) * size_idx_e) * size_idx_d] *
h_B[idx_g + (idx_f + (idx_a + (idx_c) * size_idx_a) * size_idx_f) * size_idx_g];
ops++;
}
tmp_ops = tmp_ops + ops;
}
printf ("======================================= Correctness Check ==========================================\n");
double epsilon = 0.00000001;
int diff = 0;
int same = 0;
int i;
for (i = 0; i < size_C; i++)
{
double check = h_C_chk[i] - h_C[i];
if (check < 0) check *= -1;
if (check > epsilon)
{
diff++;
if (diff < 8)
printf ("Index: %5d, (Host) %8.4f, (Dev.) %8.4f >> (Diff.) %8.4f\n", i, h_C_chk[i], h_C[i], check);
}
else
{
same++;
}
}
printf (" >>> PASSED: %'10d among %'10d in t3\n", same, size_C);
printf (" >>> ERROR : %'10d among %'10d in t3\n", diff, size_C);
printf (" >>> Total Operations: %'lld\n", tmp_ops * 2);
printf ("====================================================================================================\n");
}
|
the_stack_data/117326948.c | #include <stdio.h>
long arr[] = {
1, 2, 3,
4, 5, 6,
7, 8, 9,
10, 11, 12,
13, 14, 15,
16, 17, 18,
19, 20, 21,
22, 23, 24,
0
};
int main()
{
long total = 0;
for (size_t i = 0; i < 1000000; i++) {
for (size_t j = 0; j < (sizeof(arr)/sizeof(long)); j++) {
total += arr[j];
}
}
printf("total=%ld\n", total);
}
|
the_stack_data/1073105.c | typedef int myint;
void compound_assignment(const unsigned sz, int buffer[const]) {
int i = 0;
unsigned char c = 7;
c *= 567;
buffer[i++] = c;
c /= 567;
buffer[i++] = c;
c += 567;
buffer[i++] = c;
c -= 567;
buffer[i++] = c;
c %= 567;
buffer[i++] = c;
buffer[i++] = c *= 567;
buffer[i++] = c /= 567;
buffer[i++] = c += 567;
buffer[i++] = c -= 567;
buffer[i++] = c %= 567;
int x = 100;
x += 2000;
buffer[i++] = x;
volatile unsigned char vc = 7;
vc *= 567;
buffer[i++] = vc;
buffer[i++] = vc *= 567;
int y = 10;
y *= 500;
y /= 500;
myint z = 10;
z *= 500;
z /= 500;
}
|
the_stack_data/1054643.c | /**
* Syspro Project 3
* Written By Vissarion Moutafis sdi1800119
**/
#include <stdio.h>
/*
This algorithm (k=33) was first reported by dan bernstein many years
ago in comp.lang.c.
The magic of number 33 (why it works better than many other constants,
prime or not) has never been adequately explained.
*/
unsigned long djb2(unsigned char *str) {
unsigned long hash = 5381;
int c;
while ((c = *str++)) {
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
}
return hash;
}
/*
This algorithm was created for sdbm (a public-domain reimplementation of ndbm)
database library. it was found to do well in scrambling bits, causing better
distribution of the keys and fewer splits. it also happens to be a good
general hashing function with good distribution. The actual function
is hash(i) = hash(i - 1) * 65599 + str[i]; what is included below
is the faster version used in gawk. There is even a faster, duff-device
version. The magic constant 65599 was picked out of thin air while experimenting
with different constants, and turns out to be a prime. this is one of the
algorithms used in berkeley db (see sleepycat) and elsewhere.
*/
unsigned long sdbm(unsigned char *str) {
unsigned long hash = 0;
int c;
while ((c = *str++)) {
hash = c + (hash << 6) + (hash << 16) - hash;
}
return hash;
}
/*
Return the result of the Kth hash funcation. This function uses djb2 and sdbm.
None of the functions used here is strong for cryptography purposes but they
are good enough for the purpose of the class.
The approach in this function is based on the paper:
https://www.eecs.harvard.edu/~michaelm/postscripts/rsa2008.pdf
*/
unsigned long hash_i(unsigned char *str, unsigned int i) {
return djb2(str) + i * sdbm(str) + i * i;
}
/*
main to test
*/
// int main(int argc, char **argv) {
// char *s = "Hello World!";
// int i = 0;
// int K = 10;
// printf("djb2 (%s) : %lu \n", s, djb2(s));
// printf("sdbm2 (%s) : %lu \n", s, sdbm(s));
// for (i = 0; i < K; i++) {
// printf("hash_%d (%s) : %lu \n", i, s, hash_i(s, i));
// }
// }
|
the_stack_data/231392339.c | /******************************************************************************
* File: etm.c
*
* Copyright (c) 2017 Square, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Author: Ford Peprah <[email protected]>
*
* Created: March 22nd, 2017
* Modified: March 22nd, 2017
*****************************************************************************/
#define ETM_LAR (*((volatile unsigned *)0xE0041FB0))
#define ETM_CR (*((volatile unsigned *)0xE0041000))
#define ETF_FCR (*((volatile unsigned *)0xE0043000u))
#define MCM_ETBCC (*((volatile unsigned *)0xE0080014u))
#define SIM_SOPT2 (*((volatile unsigned *)0x40048004u))
#define SIM_SCGC5 (*((volatile unsigned *)0x40048004u))
#define ETM_LAR_UNLOCK 0xC5ACCE55
#define ETF_ETM_ENABLE 0x1u
#define ETMCR_POWER_DOWN_MASK 0x1u
#define MCM_ETBCC_ETDIS_MASK 0x10u
#define SIM_SOPT2_TRACECLKSEL_MASK 0x1000u
#define PORT_PCR_REG(base,index) (base[index])
#define PORTE_BASE_PTR ((volatile unsigned *)0x4004D000u)
#define PORTE_PCR0 PORT_PCR_REG(PORTE_BASE_PTR,0)
#define PORTE_PCR1 PORT_PCR_REG(PORTE_BASE_PTR,1)
#define PORTE_PCR2 PORT_PCR_REG(PORTE_BASE_PTR,2)
#define PORTE_PCR3 PORT_PCR_REG(PORTE_BASE_PTR,3)
#define PORTE_PCR4 PORT_PCR_REG(PORTE_BASE_PTR,4)
#define PORT_PCR_DSE_ENABLE (1<<6) /* Port Configuration Register, Drive Strength Enable (DSE) bit */
#define PORT_PCR_MUX_ALTERNATE_5 (5<<8) /* Port Configuration Register, Alternate 5 function (mux as trace pin) */
#define PORT_PCR_CONFIG_FOR_TRACE (PORT_PCR_DSE_ENABLE|PORT_PCR_MUX_ALTERNATE_5) /* for trace, mux it with function 5 and high drive strength */
#define PORTE_CLOCK_GATE (1<<13)
void etm_configure_gpio(void) {
/* check and enable clocking of PORTE */
SIM_SCGC5 |= PORTE_CLOCK_GATE;
SIM_SOPT2 |= SIM_SOPT2_TRACECLKSEL_MASK; /* Debug trace clock select = Core/system clock */
/* Trace data (PTE1-4) and clock pin (PTE0), high drive strength */
PORTE_PCR0 = PORT_PCR_CONFIG_FOR_TRACE; /* PTE0, PORTE_PCR0 at 0x4004D000, trace clock pin, high drive strength */
PORTE_PCR1 = PORT_PCR_CONFIG_FOR_TRACE; /* PTE1, PORTE_PCR1 at 0x4004D004, trace data pin, high drive strength */
PORTE_PCR2 = PORT_PCR_CONFIG_FOR_TRACE; /* PTE2, PORTE_PCR3 at 0x4004D008, trace data pin, high drive strength */
PORTE_PCR3 = PORT_PCR_CONFIG_FOR_TRACE; /* PTE3, PORTE_PCR3 at 0x4004D00C, trace data pin, high drive strength */
PORTE_PCR4 = PORT_PCR_CONFIG_FOR_TRACE; /* PTE4, PORTE_PCR4 at 0x4004D010, trace data pin, high drive strength */
}
void etm_configure_registers(void) {
// A privileged write of `0xC5ACCE55` enables write access to the ETM
// Control Register.
ETM_LAR = ETM_LAR_UNLOCK;
// The Power Down bit in the ETM control register must be cleared in order
// to enable ETM.
ETM_CR &= ~(ETMCR_POWER_DOWN_MASK);
/* Set up Embedded Trace FIFO to enable the ETM path. */
ETF_FCR |= ETF_ETM_ENABLE;
// Enable the signal path from ETM to TPIU
// MCM is Kinetis-specific, not ARM.
MCM_ETBCC &= (~MCM_ETBCC_ETDIS_MASK);
}
void etm_init(void) {
etm_configure_gpio();
etm_configure_registers();
}
|
the_stack_data/543405.c | /*
* @lc app=leetcode id=7 lang=c
*
* [7] Reverse Integer
*
* https://leetcode.com/problems/reverse-integer/description/
*
* algorithms
* Easy (25.63%)
* Total Accepted: 1M
* Total Submissions: 3.9M
* Testcase Example: '123'
*
* Given a 32-bit signed integer, reverse digits of an integer.
*
* Example 1:
*
*
* Input: 123
* Output: 321
*
*
* Example 2:
*
*
* Input: -123
* Output: -321
*
*
* Example 3:
*
*
* Input: 120
* Output: 21
*
*
* Note:
* Assume we are dealing with an environment which could only store integers
* within the 32-bit signed integer range: [−2^31, 2^31 − 1]. For the purpose
* of this problem, assume that your function returns 0 when the reversed
* integer overflows.
*
*/
int reverse(int x)
{
long result = 0;
while (x)
{
result = result * 10 + x % 10;
x = x / 10;
}
if (result > 0x7fffffff || result < (signed int)0x80000000)
{
return 0;
}
return result;
}
|
the_stack_data/105129.c | /*
* This source code is a product of Sun Microsystems, Inc. and is provided
* for unrestricted use. Users may copy or modify this source code without
* charge.
*
* SUN SOURCE CODE IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING
* THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
*
* Sun source code is provided with no support and without any obligation on
* the part of Sun Microsystems, Inc. to assist in its use, correction,
* modification or enhancement.
*
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY THIS SOFTWARE
* OR ANY PART THEREOF.
*
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
* or profits or other special, indirect and consequential damages, even if
* Sun has been advised of the possibility of such damages.
*
* Sun Microsystems, Inc.
* 2550 Garcia Avenue
* Mountain View, California 94043
*/
/*
* g711.c
*
* u-law, A-law and linear PCM conversions.
*/
/*
* December 30, 1994:
* Functions linear2alaw, linear2ulaw have been updated to correctly
* convert unquantized 16 bit values.
* Tables for direct u- to A-law and A- to u-law conversions have been
* corrected.
* Borge Lindberg, Center for PersonKommunikation, Aalborg University.
* [email protected]
*
*/
#define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
#define QUANT_MASK (0xf) /* Quantization field mask. */
#define NSEGS (8) /* Number of A-law segments. */
#define SEG_SHIFT (4) /* Left shift for segment number. */
#define SEG_MASK (0x70) /* Segment field mask. */
static short seg_aend[8] = {0x1F, 0x3F, 0x7F, 0xFF,
0x1FF, 0x3FF, 0x7FF, 0xFFF};
static short seg_uend[8] = {0x3F, 0x7F, 0xFF, 0x1FF,
0x3FF, 0x7FF, 0xFFF, 0x1FFF};
/* copy from CCITT G.711 specifications */
unsigned char _u2a[128] = { /* u- to A-law conversions */
1, 1, 2, 2, 3, 3, 4, 4,
5, 5, 6, 6, 7, 7, 8, 8,
9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24,
25, 27, 29, 31, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44,
46, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 58, 59, 60, 61, 62,
64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79,
/* corrected:
81, 82, 83, 84, 85, 86, 87, 88,
should be: */
80, 82, 83, 84, 85, 86, 87, 88,
89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 108, 109, 110, 111, 112,
113, 114, 115, 116, 117, 118, 119, 120,
121, 122, 123, 124, 125, 126, 127, 128};
unsigned char _a2u[128] = { /* A- to u-law conversions */
1, 3, 5, 7, 9, 11, 13, 15,
16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31,
32, 32, 33, 33, 34, 34, 35, 35,
36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 48, 49, 49,
50, 51, 52, 53, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 64,
65, 66, 67, 68, 69, 70, 71, 72,
/* corrected:
73, 74, 75, 76, 77, 78, 79, 79,
should be: */
73, 74, 75, 76, 77, 78, 79, 80,
80, 81, 82, 83, 84, 85, 86, 87,
88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119,
120, 121, 122, 123, 124, 125, 126, 127};
static short
search(
short val,
short *table,
short size)
{
short i;
for (i = 0; i < size; i++) {
if (val <= *table++)
return (i);
}
return (size);
}
/*
* linear2alaw() - Convert a 16-bit linear PCM value to 8-bit A-law
*
* linear2alaw() accepts an 16-bit integer and encodes it as A-law data.
*
* Linear Input Code Compressed Code
* ------------------------ ---------------
* 0000000wxyza 000wxyz
* 0000001wxyza 001wxyz
* 000001wxyzab 010wxyz
* 00001wxyzabc 011wxyz
* 0001wxyzabcd 100wxyz
* 001wxyzabcde 101wxyz
* 01wxyzabcdef 110wxyz
* 1wxyzabcdefg 111wxyz
*
* For further information see John C. Bellamy's Digital Telephony, 1982,
* John Wiley & Sons, pps 98-111 and 472-476.
*/
unsigned char
linear2alaw(
short pcm_val) /* 2's complement (16-bit range) */
{
short mask;
short seg;
unsigned char aval;
pcm_val = pcm_val >> 3;
if (pcm_val >= 0) {
mask = 0xD5; /* sign (7th) bit = 1 */
} else {
mask = 0x55; /* sign bit = 0 */
pcm_val = -pcm_val - 1;
}
/* Convert the scaled magnitude to segment number. */
seg = search(pcm_val, seg_aend, 8);
/* Combine the sign, segment, and quantization bits. */
if (seg >= 8) /* out of range, return maximum value. */
return (unsigned char) (0x7F ^ mask);
else {
aval = (unsigned char) seg << SEG_SHIFT;
if (seg < 2)
aval |= (pcm_val >> 1) & QUANT_MASK;
else
aval |= (pcm_val >> seg) & QUANT_MASK;
return (aval ^ mask);
}
}
/*
* alaw2linear() - Convert an A-law value to 16-bit linear PCM
*
*/
short
alaw2linear(
unsigned char a_val)
{
short t;
short seg;
a_val ^= 0x55;
t = (a_val & QUANT_MASK) << 4;
seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
switch (seg) {
case 0:
t += 8;
break;
case 1:
t += 0x108;
break;
default:
t += 0x108;
t <<= seg - 1;
}
return ((a_val & SIGN_BIT) ? t : -t);
}
#define BIAS (0x84) /* Bias for linear code. */
#define CLIP 8159
/*
* linear2ulaw() - Convert a linear PCM value to u-law
*
* In order to simplify the encoding process, the original linear magnitude
* is biased by adding 33 which shifts the encoding range from (0 - 8158) to
* (33 - 8191). The result can be seen in the following encoding table:
*
* Biased Linear Input Code Compressed Code
* ------------------------ ---------------
* 00000001wxyza 000wxyz
* 0000001wxyzab 001wxyz
* 000001wxyzabc 010wxyz
* 00001wxyzabcd 011wxyz
* 0001wxyzabcde 100wxyz
* 001wxyzabcdef 101wxyz
* 01wxyzabcdefg 110wxyz
* 1wxyzabcdefgh 111wxyz
*
* Each biased linear code has a leading 1 which identifies the segment
* number. The value of the segment number is equal to 7 minus the number
* of leading 0's. The quantization interval is directly available as the
* four bits wxyz. * The trailing bits (a - h) are ignored.
*
* Ordinarily the complement of the resulting code word is used for
* transmission, and so the code word is complemented before it is returned.
*
* For further information see John C. Bellamy's Digital Telephony, 1982,
* John Wiley & Sons, pps 98-111 and 472-476.
*/
unsigned char
linear2ulaw(
short pcm_val) /* 2's complement (16-bit range) */
{
short mask;
short seg;
unsigned char uval;
/* Get the sign and the magnitude of the value. */
pcm_val = pcm_val >> 2;
if (pcm_val < 0) {
pcm_val = -pcm_val;
mask = 0x7F;
} else {
mask = 0xFF;
}
if ( pcm_val > CLIP ) pcm_val = CLIP; /* clip the magnitude */
pcm_val += (BIAS >> 2);
/* Convert the scaled magnitude to segment number. */
seg = search(pcm_val, seg_uend, 8);
/*
* Combine the sign, segment, quantization bits;
* and complement the code word.
*/
if (seg >= 8) /* out of range, return maximum value. */
return (unsigned char) (0x7F ^ mask);
else {
uval = (unsigned char) (seg << 4) | ((pcm_val >> (seg + 1)) & 0xF);
return (uval ^ mask);
}
}
/*
* ulaw2linear() - Convert a u-law value to 16-bit linear PCM
*
* First, a biased linear code is derived from the code word. An unbiased
* output can then be obtained by subtracting 33 from the biased code.
*
* Note that this function expects to be passed the complement of the
* original code word. This is in keeping with ISDN conventions.
*/
short
ulaw2linear(
unsigned char u_val)
{
short t;
/* Complement to obtain normal u-law value. */
u_val = ~u_val;
/*
* Extract and bias the quantization bits. Then
* shift up by the segment number and subtract out the bias.
*/
t = ((u_val & QUANT_MASK) << 3) + BIAS;
t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
}
/* A-law to u-law conversion */
unsigned char
alaw2ulaw(
unsigned char aval)
{
aval &= 0xff;
return (unsigned char) ((aval & 0x80) ? (0xFF ^ _a2u[aval ^ 0xD5]) :
(0x7F ^ _a2u[aval ^ 0x55]));
}
/* u-law to A-law conversion */
unsigned char
ulaw2alaw(
unsigned char uval)
{
uval &= 0xff;
return (unsigned char) ((uval & 0x80) ? (0xD5 ^ (_u2a[0xFF ^ uval] - 1)) :
(unsigned char) (0x55 ^ (_u2a[0x7F ^ uval] - 1)));
}
|
the_stack_data/90765371.c | /**
* Computes the area of a rectangle
*/
#include <stdio.h>
#include <assert.h> // for the assert function
double area_of_rectangle(double length, double breadth);
void test(void);
int main(void)
{
double area, length, breadth;
test();
printf("length : ");
scanf("%lf", &length);
printf("breadth : ");
scanf("%lf", &breadth);
area = area_of_rectangle(length, breadth);
printf("area : %.1lf\n", area);
return 0;
}
// calculates the area
double area_of_rectangle(double length, double breadth)
{
return length * breadth;
}
// checks correctness of the area calculation
void test(void)
{
assert(area_of_rectangle(2, 3) == 6);
}
|
the_stack_data/48575072.c | // PARAM: --set solver td3 --enable ana.int.interval --set ana.base.arrays.domain partitioned --set ana.activated "['base','threadid','threadflag','escape','expRelation','mallocWrapper']" --set ana.base.privatization none --disable exp.fast_global_inits
// This checks that partitioned arrays and fast_global_inits are no longer incompatible
int global_array[50];
int global_array_multi[50][2][2];
int main(void) {
for(int i =0; i < 50; i++) {
assert(global_array[i] == 0);
assert(global_array_multi[i][1][1] == 0);
}
}
|
the_stack_data/84814.c | #include <stdio.h>
int main(){
float div=0,x=4,soma=0,y=1, op=1;
do{
if(op==1){
div = x/y;
if(div > 0.00001){
soma=soma + div;
op=0;
}
}else { //op =1
if(div > 0.00001){
div = x/y;
soma=soma - div;
op=1;
}
}
printf("%f\n",div);
y=y+2;
}while (div > 0.00001);
printf("%f\n",soma);
return 0;
}
|
the_stack_data/111077780.c | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int get_radix(int val, int radix)
{
while (radix--) val /= 10;
return val % 10;
}
void stable_sort(int a[], int size, int radix)
{
int k = 9;
int *b = calloc(k+1, sizeof(int));
int *c = malloc(sizeof(int)*size);
memcpy(c, a, sizeof(int)*size);
int i;
for (i=0; i<=k; ++i) {
b[i] = 0;
}
for (i=0; i<size; ++i) {
++b[get_radix(c[i], radix)];
}
for (i=1; i<=k; ++i) {
b[i] += b[i-1];
}
for (i=size-1; i>=0; --i) {
a[--b[get_radix(c[i], radix)]] = c[i];
}
free(c);
free(b);
}
int radix_sort(int a[], int size, int max_radix)
{
int radix = 0;
do {
stable_sort(a, size, radix);
} while (++radix <= max_radix);
}
int test1()
{
int a[] = {5211, 95368, 2567, 56429, 65782, 21530, 22862};
radix_sort(a, sizeof(a)/sizeof(int), 7);
int i;
for (i=0; i<sizeof(a)/sizeof(int); ++i) {
printf("%d\n", a[i]);
}
}
int test2()
{
int loop = 1000;
while (loop--) {
int size = rand() % 10 + 1;
int size_s = size;
int *a = malloc(sizeof(int)*size);
int i;
for (i=0; i<size; ++i) {
a[i] = rand() % 100000;
printf("a[%d]: %d\n", i, a[i]);
}
radix_sort(a, size, 7);
while (--size) {
if (a[size] < a[size-1]) {
printf("size:%d, failed\n", size);
break;
}
}
printf("size:%d, succeed\n", size_s);
free(a);
}
}
int main()
{
test2();
}
|
the_stack_data/41747.c | #include <stdio.h>
int main()
{
int num, sum = 0;
printf("请输入一个3位整数: ");
scanf("%d", &num);
//个位
sum += (num % 10) * (num % 10) * (num % 10);
//十位
sum += ((num / 10) % 10) * ((num / 10) % 10) * ((num / 10) % 10);
//百位
sum += (num / 100) * (num / 100) * (num / 100);
printf("结果为:%d\n", sum);
return 0;
}
|
the_stack_data/187644260.c |
/*
* -- SuperLU routine (version 2.0) --
* Univ. of California Berkeley, Xerox Palo Alto Research Center,
* and Lawrence Berkeley National Lab.
* November 15, 1997
*
*/
/*
* File name: smyblas2.c
* Purpose:
* Level 2 BLAS operations: solves and matvec, written in C.
* Note:
* This is only used when the system lacks an efficient BLAS library.
*/
/*
* Solves a dense UNIT lower triangular system. The unit lower
* triangular matrix is stored in a 2D array M(1:nrow,1:ncol).
* The solution will be returned in the rhs vector.
*/
void slsolve ( int ldm, int ncol, float *M, float *rhs )
{
int k;
float x0, x1, x2, x3, x4, x5, x6, x7;
float *M0;
register float *Mki0, *Mki1, *Mki2, *Mki3, *Mki4, *Mki5, *Mki6, *Mki7;
register int firstcol = 0;
M0 = &M[0];
while ( firstcol < ncol - 7 ) { /* Do 8 columns */
Mki0 = M0 + 1;
Mki1 = Mki0 + ldm + 1;
Mki2 = Mki1 + ldm + 1;
Mki3 = Mki2 + ldm + 1;
Mki4 = Mki3 + ldm + 1;
Mki5 = Mki4 + ldm + 1;
Mki6 = Mki5 + ldm + 1;
Mki7 = Mki6 + ldm + 1;
x0 = rhs[firstcol];
x1 = rhs[firstcol+1] - x0 * *Mki0++;
x2 = rhs[firstcol+2] - x0 * *Mki0++ - x1 * *Mki1++;
x3 = rhs[firstcol+3] - x0 * *Mki0++ - x1 * *Mki1++ - x2 * *Mki2++;
x4 = rhs[firstcol+4] - x0 * *Mki0++ - x1 * *Mki1++ - x2 * *Mki2++
- x3 * *Mki3++;
x5 = rhs[firstcol+5] - x0 * *Mki0++ - x1 * *Mki1++ - x2 * *Mki2++
- x3 * *Mki3++ - x4 * *Mki4++;
x6 = rhs[firstcol+6] - x0 * *Mki0++ - x1 * *Mki1++ - x2 * *Mki2++
- x3 * *Mki3++ - x4 * *Mki4++ - x5 * *Mki5++;
x7 = rhs[firstcol+7] - x0 * *Mki0++ - x1 * *Mki1++ - x2 * *Mki2++
- x3 * *Mki3++ - x4 * *Mki4++ - x5 * *Mki5++
- x6 * *Mki6++;
rhs[++firstcol] = x1;
rhs[++firstcol] = x2;
rhs[++firstcol] = x3;
rhs[++firstcol] = x4;
rhs[++firstcol] = x5;
rhs[++firstcol] = x6;
rhs[++firstcol] = x7;
++firstcol;
for (k = firstcol; k < ncol; k++)
rhs[k] = rhs[k] - x0 * *Mki0++ - x1 * *Mki1++
- x2 * *Mki2++ - x3 * *Mki3++
- x4 * *Mki4++ - x5 * *Mki5++
- x6 * *Mki6++ - x7 * *Mki7++;
M0 += 8 * ldm + 8;
}
while ( firstcol < ncol - 3 ) { /* Do 4 columns */
Mki0 = M0 + 1;
Mki1 = Mki0 + ldm + 1;
Mki2 = Mki1 + ldm + 1;
Mki3 = Mki2 + ldm + 1;
x0 = rhs[firstcol];
x1 = rhs[firstcol+1] - x0 * *Mki0++;
x2 = rhs[firstcol+2] - x0 * *Mki0++ - x1 * *Mki1++;
x3 = rhs[firstcol+3] - x0 * *Mki0++ - x1 * *Mki1++ - x2 * *Mki2++;
rhs[++firstcol] = x1;
rhs[++firstcol] = x2;
rhs[++firstcol] = x3;
++firstcol;
for (k = firstcol; k < ncol; k++)
rhs[k] = rhs[k] - x0 * *Mki0++ - x1 * *Mki1++
- x2 * *Mki2++ - x3 * *Mki3++;
M0 += 4 * ldm + 4;
}
if ( firstcol < ncol - 1 ) { /* Do 2 columns */
Mki0 = M0 + 1;
Mki1 = Mki0 + ldm + 1;
x0 = rhs[firstcol];
x1 = rhs[firstcol+1] - x0 * *Mki0++;
rhs[++firstcol] = x1;
++firstcol;
for (k = firstcol; k < ncol; k++)
rhs[k] = rhs[k] - x0 * *Mki0++ - x1 * *Mki1++;
}
}
/*
* Solves a dense upper triangular system. The upper triangular matrix is
* stored in a 2-dim array M(1:ldm,1:ncol). The solution will be returned
* in the rhs vector.
*/
void
susolve ( ldm, ncol, M, rhs )
int ldm; /* in */
int ncol; /* in */
float *M; /* in */
float *rhs; /* modified */
{
float xj;
int jcol, j, irow;
jcol = ncol - 1;
for (j = 0; j < ncol; j++) {
xj = rhs[jcol] / M[jcol + jcol*ldm]; /* M(jcol, jcol) */
rhs[jcol] = xj;
for (irow = 0; irow < jcol; irow++)
rhs[irow] -= xj * M[irow + jcol*ldm]; /* M(irow, jcol) */
jcol--;
}
}
/*
* Performs a dense matrix-vector multiply: Mxvec = Mxvec + M * vec.
* The input matrix is M(1:nrow,1:ncol); The product is returned in Mxvec[].
*/
void smatvec ( ldm, nrow, ncol, M, vec, Mxvec )
int ldm; /* in -- leading dimension of M */
int nrow; /* in */
int ncol; /* in */
float *M; /* in */
float *vec; /* in */
float *Mxvec; /* in/out */
{
float vi0, vi1, vi2, vi3, vi4, vi5, vi6, vi7;
float *M0;
register float *Mki0, *Mki1, *Mki2, *Mki3, *Mki4, *Mki5, *Mki6, *Mki7;
register int firstcol = 0;
int k;
M0 = &M[0];
while ( firstcol < ncol - 7 ) { /* Do 8 columns */
Mki0 = M0;
Mki1 = Mki0 + ldm;
Mki2 = Mki1 + ldm;
Mki3 = Mki2 + ldm;
Mki4 = Mki3 + ldm;
Mki5 = Mki4 + ldm;
Mki6 = Mki5 + ldm;
Mki7 = Mki6 + ldm;
vi0 = vec[firstcol++];
vi1 = vec[firstcol++];
vi2 = vec[firstcol++];
vi3 = vec[firstcol++];
vi4 = vec[firstcol++];
vi5 = vec[firstcol++];
vi6 = vec[firstcol++];
vi7 = vec[firstcol++];
for (k = 0; k < nrow; k++)
Mxvec[k] += vi0 * *Mki0++ + vi1 * *Mki1++
+ vi2 * *Mki2++ + vi3 * *Mki3++
+ vi4 * *Mki4++ + vi5 * *Mki5++
+ vi6 * *Mki6++ + vi7 * *Mki7++;
M0 += 8 * ldm;
}
while ( firstcol < ncol - 3 ) { /* Do 4 columns */
Mki0 = M0;
Mki1 = Mki0 + ldm;
Mki2 = Mki1 + ldm;
Mki3 = Mki2 + ldm;
vi0 = vec[firstcol++];
vi1 = vec[firstcol++];
vi2 = vec[firstcol++];
vi3 = vec[firstcol++];
for (k = 0; k < nrow; k++)
Mxvec[k] += vi0 * *Mki0++ + vi1 * *Mki1++
+ vi2 * *Mki2++ + vi3 * *Mki3++ ;
M0 += 4 * ldm;
}
while ( firstcol < ncol ) { /* Do 1 column */
Mki0 = M0;
vi0 = vec[firstcol++];
for (k = 0; k < nrow; k++)
Mxvec[k] += vi0 * *Mki0++;
M0 += ldm;
}
}
|
the_stack_data/66001.c | #include <stdio.h>
int main()
{
//Displays the string inside quotations
printf("C programming is a powerful general-purpose language.\n");
printf("It is an excellent language to learn to program.\n");
return 0;
}
|
the_stack_data/448923.c | #include <stdio.h>
/*
write a program to print all even numbers
given the highest even number entered by the user
*/
int main()
{
int even_max;
int even_number = 2;
printf("Please enter the higest even number\n");
scanf("%d", &even_max);
if(even_max % 2 != 0) {
printf("Wrong input... Please enter a even number\n");
return 0;
}
while (even_number <= even_max)
{
printf("%d\n",even_number);
even_number = even_number + 2;
}
return 0;
}
|
the_stack_data/168893101.c | /*
* POK header
*
* The following file is a part of the POK project. Any modification should
* be made according to the POK licence. You CANNOT use this file or a part
* of a file for your own project.
*
* For more information on the POK licence, please see our LICENCE FILE
*
* Please follow the coding guidelines described in doc/CODING_GUIDELINES
*
* Copyright (c) 2007-2022 POK team
*/
/* w_j1f.c -- float version of w_j1.c.
* Conversion to float by Ian Lance Taylor, Cygnus Support, [email protected].
*/
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
#ifdef POK_NEEDS_LIBMATH
/*
* wrapper of j1f,y1f
*/
#include "math_private.h"
#include <libm.h>
float j1f(float x) /* wrapper j1f */
{
#ifdef _IEEE_LIBM
return __ieee754_j1f(x);
#else
float z;
z = __ieee754_j1f(x);
if (_LIB_VERSION == _IEEE_ || isnanf(x))
return z;
if (fabsf(x) > (float)X_TLOSS) {
/* j1(|x|>X_TLOSS) */
return (float)__kernel_standard((double)x, (double)x, 136);
} else
return z;
#endif
}
float y1f(float x) /* wrapper y1f */
{
#ifdef _IEEE_LIBM
return __ieee754_y1f(x);
#else
float z;
z = __ieee754_y1f(x);
if (_LIB_VERSION == _IEEE_ || isnanf(x))
return z;
if (x <= (float)0.0) {
if (x == (float)0.0)
/* d= -one/(x-x); */
return (float)__kernel_standard((double)x, (double)x, 110);
else
/* d = zero/(x-x); */
return (float)__kernel_standard((double)x, (double)x, 111);
}
if (x > (float)X_TLOSS) {
/* y1(x>X_TLOSS) */
return (float)__kernel_standard((double)x, (double)x, 137);
} else
return z;
#endif
}
#endif
|
the_stack_data/67389.c | #include <stdlib.h>
#include <stdint.h>
#include <sys/types.h>
size_t utility_u32_len(uint32_t n)
{
static const uint32_t pow_10[] = {0, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
uint32_t t;
t = (32 - __builtin_clz(n | 1)) * 1233 >> 12;
return t - (n < pow_10[t]) + 1;
}
void utility_u32_sprint(uint32_t n, char *string)
{
static const char digits[] =
"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
"4041424344454647484950515253545556575859"
"6061626364656667686970717273747576777879"
"8081828384858687888990919293949596979899";
size_t i;
while (n >= 100)
{
i = (n % 100) << 1;
n /= 100;
*--string = digits[i + 1];
*--string = digits[i];
}
if (n < 10)
{
*--string = n + '0';
}
else
{
i = n << 1;
*--string = digits[i + 1];
*--string = digits[i];
}
}
void utility_u32_toa(uint32_t n, char *string)
{
size_t length;
length = utility_u32_len(n);
string += length;
*string = 0;
utility_u32_sprint(n, string);
}
uint64_t utility_tsc(void)
{
#if defined(__x86_64__) || defined(__amd64__)
uint32_t lo, hi;
__asm__ volatile("RDTSC"
: "=a"(lo), "=d"(hi));
return (((uint64_t) hi) << 32) | lo;
#else
return 0;
#endif
}
|
the_stack_data/86547.c | /***
* This code is a part of EvoApproxLib library (ehw.fit.vutbr.cz/approxlib) distributed under The MIT License.
* When used, please cite the following article(s): V. Mrazek, R. Hrbacek, Z. Vasicek and L. Sekanina, "EvoApprox8b: Library of approximate adders and multipliers for circuit design and benchmarking of approximation methods". Design, Automation & Test in Europe Conference & Exhibition (DATE), 2017, Lausanne, 2017, pp. 258-261. doi: 10.23919/DATE.2017.7926993
* This file contains a circuit from a sub-set of pareto optimal circuits with respect to the pwr and wce parameters
***/
// MAE% = 24.81 %
// MAE = 16256
// WCE% = 99.22 %
// WCE = 65025
// WCRE% = 100.00 %
// EP% = 99.22 %
// MRE% = 100.00 %
// MSE = 47164.981e4
// PDK45_PWR = 0.000 mW
// PDK45_AREA = 0.0 um2
// PDK45_DELAY = 0.00 ns
#include <stdint.h>
#include <stdlib.h>
uint64_t mul8u_E9R(const uint64_t B,const uint64_t A)
{
uint64_t O; int avg=0;
O = 0;
O |= (0&1) << 0;
O |= (0&1) << 1;
O |= (0&1) << 2;
O |= (0&1) << 3;
O |= (0&1) << 4;
O |= (0&1) << 5;
O |= (0&1) << 6;
O |= (0&1) << 7;
O |= (0&1) << 8;
O |= (0&1) << 9;
O |= (0&1) << 10;
O |= (0&1) << 11;
O |= (0&1) << 12;
O |= (0&1) << 13;
O |= (0&1) << 14;
O |= (0&1) << 15;
return O;
}
|
the_stack_data/168892289.c | /**
* default.c
* -*- mode: c -*-
* -*- coding: utf-8 -*-
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
char msg[0x100];
int main(int argc, char** argv, char** envp)
{
strncpy(msg, "Hello world!", sizeof(msg));
__asm__ volatile("int3;" : : : );
return EXIT_SUCCESS;
}
|
the_stack_data/98783.c | /*
Tempo sequencial:
real 0m31,842s
user 0m31,713s
sys 0m0,083s
real 0m30,929s
user 0m30,789s
sys 0m0,074s
real 0m31,569s
user 0m31,408s
sys 0m0,077s
real 0m30,880s
user 0m30,749s
sys 0m0,067s
real 0m31,120s
user 0m30,967s
sys 0m0,087s
Tempo Paralelo - Multicore:
real 0m9,663s
user 1m1,498s
sys 0m2,830s
real 0m9,897s
user 1m1,072s
sys 0m2,809s
real 0m9,767s
user 1m0,906s
sys 0m2,798s
real 0m9,857s
user 1m1,442s
sys 0m2,972s
real 0m9,709s
user 1m1,580s
sys 0m3,002s
Tempo paralelo - GPU
distribute
real 0m30,728s
user 0m30,683s
sys 0m0,184s
real 0m30,883s
user 0m30,952s
sys 0m0,122s
real 0m31,138s
user 0m31,304s
sys 0m0,087s
real 0m31,675s
user 0m31,759s
sys 0m0,050s
real 0m31,450s
user 0m31,600s
sys 0m0,043s
distribute parallel for
real 0m9,370s
user 0m54,341s
sys 0m0,196s
real 0m9,421s
user 0m55,248s
sys 0m0,227s
real 0m8,649s
user 0m59,349s
sys 0m0,220s
real 0m8,653s
user 0m59,911s
sys 0m0,234s
real 0m8,644s
user 0m59,108s
sys 0m0,195s
distribute parallel for simd
real 0m9,144s
user 0m56,485s
sys 0m0,878s
real 0m9,119s
user 0m58,920s
sys 0m0,247s
real 0m8,835s
user 0m57,115s
sys 0m0,208s
real 0m8,842s
user 0m57,008s
sys 0m0,170s
real 0m8,984s
user 0m56,533s
sys 0m0,232s
*/
#include <stdio.h>
#include <stdlib.h>
void mm(double *a, double *b, double *c, int width)
{
#pragma omp target map(to \
: a [0:(width * width)], b [0:(width * width)]) map(from \
: c [0:(width * width)])
#pragma omp teams distribute parallel for
for (int i = 0; i < width; i++)
{
for (int j = 0; j < width; j++)
{
double sum = 0;
for (int k = 0; k < width; k++)
{
double x = a[i * width + k];
double y = b[k * width + j];
sum += x * y;
}
c[i * width + j] = sum;
}
}
}
int main()
{
int width = 2000;
double *a = (double *)malloc(width * width * sizeof(double));
double *b = (double *)malloc(width * width * sizeof(double));
double *c = (double *)malloc(width * width * sizeof(double));
#pragma omp parallel for collapse(2)
for (int i = 0; i < width; i++)
{
for (int j = 0; j < width; j++)
{
a[i * width + j] = i;
b[i * width + j] = j;
c[i * width + j] = 0;
}
}
mm(a, b, c, width);
} |
the_stack_data/10887.c | #include <stdlib.h>
#include <stdio.h>
#ifdef DEBUG
#define abort() printf ("error, line %d\n", __LINE__)
#endif
int count;
void a1() { ++count; }
void
b (unsigned short data)
{
if (data & 0x8000) a1();
data <<= 1;
if (data & 0x8000) a1();
data <<= 1;
if (data & 0x8000) a1();
}
int main ()
{
count = 0;
b (0);
if (count != 0)
abort ();
count = 0;
b (0x8000);
if (count != 1)
abort ();
count = 0;
b (0x4000);
if (count != 1)
abort ();
count = 0;
b (0x2000);
if (count != 1)
abort ();
count = 0;
b (0xc000);
if (count != 2)
abort ();
count = 0;
b (0xa000);
if (count != 2)
abort ();
count = 0;
b (0x6000);
if (count != 2)
abort ();
count = 0;
b (0xe000);
if (count != 3)
abort ();
#ifdef DEBUG
printf ("Done.\n");
#endif
exit (0);
}
|
the_stack_data/154829211.c | #include <stdio.h>
#include <math.h>
int main () {
int n, counter = 0;
double multiply = 1, degree = 1, result = 0;
printf ("Enter N: ");
scanf ("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
multiply *= j + cos (j);
counter += 3;
}
degree *= 4;
result += (degree - i) / multiply;
multiply = 1;
counter += 4;
}
printf ("Result: %.7lf \n", result);
printf ("Number of operations: %d", counter);
return 0;
}
|
the_stack_data/72011658.c |
#include<stdint.h>
#include<stdio.h>
union Address
{
uint16_t shortAddr;
uint32_t longAddr;
};
int main(void)
{
union Address addr;
addr.shortAddr = 0xABCD;
addr.longAddr = 0xEEEECCCC;
printf("short addr = %#X\n",addr.shortAddr);
printf("long addr = %#X\n",addr.longAddr);
getchar();
return 0;
}
|
the_stack_data/658739.c | /* Test AAPCS layout (alignment) for callee. */
/* { dg-do run { target arm_eabi } } */
/* { dg-require-effective-target arm32 } */
/* { dg-options "-O2 -fno-inline" } */
extern void abort (void);
typedef __attribute__((aligned (8))) int alignedint;
alignedint a = 11;
alignedint b = 13;
alignedint c = 17;
alignedint d = 19;
alignedint e = 23;
alignedint f = 29;
void
foo (alignedint r0, alignedint r1, alignedint r2, alignedint r3,
alignedint stack, alignedint stack4)
{
if (r0 != a
|| r1 != b
|| r2 != c
|| r3 != d
|| stack != e
|| stack4 !=f)
abort ();
}
int
main (int argc, char **argv)
{
foo (a, b, c, d, e, f);
return 0;
}
|
the_stack_data/242331868.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ebeiline <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/05/11 19:22:49 by pstengl #+# #+# */
/* Updated: 2022/04/02 14:11:37 by ebeiline ### ########.fr */
/* */
/* ************************************************************************** */
#include <stddef.h>
size_t ft_strlen(const char *s)
{
size_t length;
length = 0;
if (!s)
return (length);
while (*s != '\0')
{
length++;
s++;
}
return (length);
}
|
the_stack_data/330526.c | // SKIP PARAM: --set ana.activated[+] apron --set ana.path_sens[+] threadflag --set ana.activated[-] threadJoins
#include <pthread.h>
#include <stdio.h>
int g;
int h;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *t_fun(void *arg) {
int t;
pthread_mutex_lock(&mutex);
g=t;
h=t;
pthread_mutex_unlock(&mutex);
return NULL;
}
int main(void) {
int top;
int mt = 0;
if(top) {
g = 8;
h = 7;
} else {
pthread_t id;
pthread_create(&id, NULL, t_fun, NULL);
pthread_mutex_lock(&mutex);
g=top;
h=top;
pthread_mutex_unlock(&mutex);
mt=1;
}
if(!mt) {
pthread_mutex_lock(&mutex);
assert(g==h); //MAYFAIL
pthread_mutex_unlock(&mutex);
}
return 0;
}
|
the_stack_data/7484.c | #include <stdio.h>
int main()
{
int x;
scanf("%d", &x);
printf("%d\n", x*x*x);
return 0;
}
|
the_stack_data/3263194.c | /*
* Generated with test/generate_buildtest.pl, to check that such a simple
* program builds.
*/
#include <openssl/opensslconf.h>
#ifndef OPENSSL_NO_STDIO
# include <stdio.h>
#endif
#ifndef OPENSSL_NO_EBCDIC
# include <openssl/ebcdic.h>
#endif
int main(void)
{
return 0;
}
|
the_stack_data/154828199.c | #include <stdio.h>
int main() {
int a = -5;
double b = 0.5;
float c = 2.6f;
printf("%d\n", a < a);
printf("%f\n", a < b);
printf("%f\n", a < c);
printf("%f\n", b < c);
printf("%d\n", a + a);
printf("%f\n", a + b);
printf("%f\n", (double)(a + c));
printf("%f\n", b + c);
printf("%d\n", a * a);
printf("%f\n", a * b);
printf("%f\n", (double)(a * c));
printf("%f\n", b * c);
return 0;
}
|
the_stack_data/211079593.c | //Funciones de Sumar y Restar
#include <stdio.h>
int sumar(int iNumeroX, int iNumeroY);
int restar(int iNumeroX, int iNumeroY);
int main(void){
int iNumeroX, iNumeroY;
printf("Este programa realiza la suma y la resta de dos n%cmeros",163);
printf("\nIngresa el primer n%cmero: ",163);
scanf("%d",&iNumeroX);
printf("\nIngresa el segundo n%cmero: ",163);
scanf("%d",&iNumeroY);
printf("\nEl resultado de sumar %d + %d = %d",iNumeroX,iNumeroY,sumar(iNumeroX,iNumeroY));
printf("\nEl resultado de restar %d - %d = %d",iNumeroX,iNumeroY,restar(iNumeroX,iNumeroY));
return 0;
}//fin int main
int sumar(int iNumeroX, int iNumeroY){
return iNumeroX + iNumeroY;
}//fin int sumar
int restar(int iNumeroX, int iNumeroY){
return iNumeroX - iNumeroY;
}//fin int restar
|
the_stack_data/8492.c | /* HAL raised several warnings, ignore them */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#ifdef STM32H7xx
#include "stm32h7xx_hal_rng_ex.c"
#elif STM32L4xx
#include "stm32l4xx_hal_rng_ex.c"
#elif STM32L5xx
#include "stm32l5xx_hal_rng_ex.c"
#endif
#pragma GCC diagnostic pop
|
the_stack_data/50595.c | #include <sys/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
/* Acknowledgement codes */
#define START_ACK 0xb
#define DATA_ACK 0x2
#define START_MAGIC 0xd7
#define BASEPORT 0x378
#define DATAPORT (BASEPORT+1)
#define TIMEOUT 1
#define TIMEOUT_TRIES 10000
#define OK 0
#define DELAY 1
static void write_data(unsigned char data, unsigned int clock)
{
data &= 0x0f;
outb (data | clock, BASEPORT);
}
static int read_noack(unsigned char clock, unsigned char *ret)
{
unsigned char c0, c1;
unsigned int cx = TIMEOUT_TRIES;
while (1) {
c0 = inb (DATAPORT) >> 3;
usleep(DELAY);
if ((c0 & 0x10) ^ clock) {
c1 = inb (DATAPORT) >> 3;
if (c0 == c1)
break;
}
if (--cx == 0)
return TIMEOUT;
}
fprintf(stderr, "read_status(clock=%x,data=%x)\n",clock,c0);
return (c0 & 0x0f);
}
static int read_status(unsigned char clock, unsigned char ack,
unsigned char *ret)
{
if (read_noack(clock, ret) == TIMEOUT)
return TIMEOUT;
write_data(ack, clock);
return OK;
}
static int read_octet(unsigned int ack, unsigned char *ret)
{
unsigned char low, high;
if (read_status(0x00, ack, &low) == TIMEOUT)
return TIMEOUT;
if (read_status(0x10, ack, &high) == TIMEOUT)
return TIMEOUT;
*ret = high << 4 | low;
return OK;
}
int read_word(unsigned short *ret)
{
unsigned char low, high;
if (read_octet(DATA_ACK, &low) == TIMEOUT)
return TIMEOUT;
if (read_octet(DATA_ACK, &high) == TIMEOUT)
return TIMEOUT;
*ret = high << 8 | low;
return OK;
}
int main(int argc, char *argv[])
{
unsigned char *p, start;
unsigned short checksum, size;
unsigned short sum = 0, i;
FILE * fout;
if (ioperm(BASEPORT, 8, 1)) { perror("ioperm"); exit(1); }
fout = stdout;
/* reset -- is this necessary? */
write_data(0x00, 0x10);
again:
while (read_octet(START_ACK, &start) != OK)
fprintf(stderr, "timed out reading start\n");
printf("read: (%x)\n", size);
if (read_word(&checksum) != OK) {
fprintf(stderr, "timed out reading checksum\n");
goto again;
}
fprintf(stderr, "checksum = (%04x)\n", checksum);
if (read_word(&size) != OK) {
fprintf(stderr, "timed out reading size\n");
goto again;
}
printf("size = (%05d)\n", size);
p = malloc(size);
fprintf(stderr, "Reading data\n");
for (i = 0; i < size; i++) {
fprintf(stderr, "%d\n", i);
if (read_octet(DATA_ACK, &p[i]) == TIMEOUT) {
/* print what data is available */
break;
}
sum += p[i];
}
fwrite(p, sizeof(char), i, fout);
fclose(fout);
return 0;
}
|
the_stack_data/170453270.c | void fence()
{
asm("sync");
}
void lwfence()
{
asm("lwsync");
}
void isync()
{
asm("isync");
}
int __unbuffered_cnt = 0;
int __unbuffered_p0_r1 = 0;
int __unbuffered_p0_r3 = 0;
int __unbuffered_p1_r1 = 0;
int __unbuffered_p1_r3 = 0;
int x = 0;
int y = 0;
void *P0(void *arg)
{
__unbuffered_p0_r1 = 1;
y = __unbuffered_p0_r1;
lwfence();
__unbuffered_p0_r3 = x;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
void *P1(void *arg)
{
__unbuffered_p1_r1 = 1;
x = __unbuffered_p1_r1;
lwfence();
__unbuffered_p1_r3 = y;
// Instrumentation for CPROVER
fence();
__unbuffered_cnt++;
}
int main()
{
__CPROVER_ASYNC_0:
P0(0);
__CPROVER_ASYNC_1:
P1(0);
__CPROVER_assume(__unbuffered_cnt == 2);
fence();
// EXPECT:exists
__CPROVER_assert(
!(__unbuffered_p0_r3 == 0 && __unbuffered_p1_r3 == 0),
"Program proven to be relaxed for PPC, model checker says YES.");
return 0;
}
|
the_stack_data/23575855.c | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ultimate_div_mod.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: anunes-d <[email protected]> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/10/27 18:03:34 by anunes-d #+# #+# */
/* Updated: 2020/10/27 19:27:43 by anunes-d ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ultimate_div_mod(int *a, int *b)
{
int div;
int mod;
div = *a / *b;
mod = *a % *b;
*a = div;
*b = mod;
}
|
the_stack_data/97795.c | /*
Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved.
This program is free software; you can redistribute it and/or modify it
under the terms of version 2.1 of the GNU Lesser General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it would be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Further, this software is distributed without any warranty that it is
free of the rightful claim of any third person regarding infringement
or the like. Any license provided herein, whether implied or
otherwise, applies only to this software file. Patent licenses, if
any, provided herein do not apply to combinations of this program with
other software, or any other product whatsoever.
You should have received a copy of the GNU Lesser General Public
License along with this program; if not, write the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
USA.
Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky,
Mountain View, CA 94043, or:
http://www.sgi.com
For further information regarding this notice, see:
http://oss.sgi.com/projects/GenInfo/NoticeExplan
*/
#pragma ident "@(#) libu/util/samefile.c 92.1 07/07/99 13:18:33"
/* samefile.c */
#include <sys/types.h>
#include <sys/stat.h>
SAMEFILE (file1, file2)
long *file1;
long *file2;
{
struct stat st1;
struct stat st2;
if (stat((char *)file1, &st1) < 0 || stat((char *)file2, &st2) < 0)
return(0);
if (st1.st_ino != st2.st_ino || st1.st_dev != st2.st_dev)
return(0);
return(1);
}
|
the_stack_data/597984.c | /*
* @Description: 直接插入排序（Insertion Sort）
* @version: 1.0
* @Author: Chandler Lu
* @Date: 2019-09-23 18:04:14
* @LastEditTime: 2019-09-23 18:07:29
*/
#include <stdio.h>
#include <stdlib.h>
void InsertSort(int *, int);
int main(int argc, char *argv[]) {
int raw[] = {-15, 2, 6, 3, 8, 25, 108, 35, 919, 503};
int length = sizeof(raw) / sizeof(int);
int *work = (int *)malloc(length + 1);
work[0] = 0;
for (int i = 1; i <= length; i++) {
work[i] = raw[i - 1];
}
InsertSort(work, length);
for (int i = 1; i <= length; i++) {
printf("%d", work[i]);
if (i != length) {
printf(" ");
}
}
free(work);
}
void InsertSort(int *work, int length) {
int i, j;
for (i = 2; i <= length; i++) {
if (work[i] < work[i - 1]) {
work[0] = work[i];
for (j = i - 1; work[0] < work[j]; j--) {
work[j + 1] = work[j];
}
work[j + 1] = work[0];
}
}
} |
the_stack_data/150142975.c | /*
* Copyright (C) 2015 University of Oregon
*
* You may distribute under the terms of either the GNU General Public
* License or the Apache License, as specified in the LICENSE file.
*
* For more information, see the LICENSE file.
*/
/* listparam - a tool for parsing parameter (sub-)sets in simpler format */
/*
1995-03-25 - r.kyburz, started
1997-01-10 - r.kyburz, fixed JCAMP-DX format, added unit in comment
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char rev[] = "listparam.c 3.2";
static char revdate[] = "2009-03-17_09:34";
/* define parameter header constants */
#define OK 0
#define ERROR 1
#define UNDEF 0
#define REAL 1
#define STRING 2
#define DELAY 3
#define FLAGPAR 4
#define FREQPAR 5
#define PULSE 6
#define INTEGER 7
#define NONE 0
#define SAMPLE 1
#define ACQPAR 2
#define PROCPAR 3
#define DISPLAY 4
#define SPSIM 5
#define JCAMP_SPEC 32765
#define JCAMP 32766
#define ALL 32767
#define OFF 0
#define ON 1
#define tprint (void) printf
/* define structures, global parameters */
struct parameter_header
{
char name[64];
int subtype, basictype;
double maxvalue, minvalue, stepsize;
int Ggroup, Dgroup, protection, active, intptr;
int numval;
};
struct parameter_header parhd;
FILE *parfile;
char *fname;
int dumpflag,
linepos = 0,
jcampflag = 0,
testval = ACQPAR;
/*----------------------------------+
| displayhelp() - display help info |
+----------------------------------*/
void displayhelp()
{
(void) fprintf(stderr, "Usage: listparam filename <parameter_group>\n");
(void) fprintf(stderr, "\n where parameter_group is one of\n");
(void) fprintf(stderr, " all: ");
(void) fprintf(stderr, "list all parameters\n");
(void) fprintf(stderr, " acquisition: ");
(void) fprintf(stderr, "list acquisition parameters\n");
(void) fprintf(stderr, " processing: ");
(void) fprintf(stderr, "list processing parameters\n");
(void) fprintf(stderr, " display: ");
(void) fprintf(stderr, "list display parameters\n");
(void) fprintf(stderr, " sample: ");
(void) fprintf(stderr, "list sample parameters\n");
(void) fprintf(stderr, " spsim: ");
(void) fprintf(stderr, "list spin simulation parameters\n");
(void) fprintf(stderr, " JCAMP: ");
(void) fprintf(stderr, "list acquisition parameters (JCAMP-DX, FID)\n");
(void) fprintf(stderr, " JS: ");
(void) fprintf(stderr, "list acq. & proc. parameters (JCAMP-DX, spectra)\n");
(void) fprintf(stderr, "\n\n");
}
/*------------------------------------------+
| readheader() - read parameter header line |
+------------------------------------------*/
int readheader()
{
char c;
int i = 0;
c = (char) fgetc(parfile);
while ((c == ' ') || (c == '\n'))
c = (char) fgetc(parfile);
while ((c != ' ') && (c != EOF) && (c != '\n'))
{
parhd.name[i++] = c;
c = (char) fgetc(parfile);
}
if (c == EOF) return(0);
parhd.name[i] = '\0';
i = fscanf(parfile, "%d %d %lg %lg %lg %d %d %d %d %d\n%d ",
&parhd.subtype, &parhd.basictype,
&parhd.maxvalue, &parhd.minvalue, &parhd.stepsize,
&parhd.Ggroup, &parhd.Dgroup, &parhd.protection,
&parhd.active, &parhd.intptr, &parhd.numval);
return(i);
}
/*--------------------------------------------------------------+
| dumptype() - print out information from parameter header line |
+--------------------------------------------------------------*/
void dumptype()
{
if (dumpflag)
{
if (testval == ALL)
{
switch (parhd.Ggroup)
{
case NONE: tprint("(none) "); break;
case SAMPLE: tprint("(sample) "); break;
case ACQPAR: tprint("(acq) "); break;
case PROCPAR: tprint("(proc) "); break;
case DISPLAY: tprint("(display) "); break;
case SPSIM: tprint("(spsim) "); break;
default: tprint("(Ggroup %d) ", parhd.Ggroup); break;
}
}
if (parhd.active == OFF)
tprint("NOT_USED ");
}
}
/*-------------------------------------------------+
| dumpnumber() - print out numeric parameter value |
+-------------------------------------------------*/
int dumpnumber()
{
char c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
while (c == ' ')
{
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
while ((c != ' ') && (c != '\n') && (c != EOF))
{
(void) putchar(c);
linepos++;
c = (char) fgetc(parfile);
}
if (!jcampflag)
{
switch (parhd.subtype)
{
case DELAY: tprint(" sec\n"); break;
case FREQPAR: tprint(" Hz\n"); break;
case PULSE: tprint(" usec\n"); break;
default: tprint("\n"); break;
}
}
return(OK);
}
/*--------------------------------------------+
| skipnumber() - skip numeric parameter value |
+--------------------------------------------*/
int skipnumber()
{
char c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
while ((c == ' ') || (c == '\n'))
{
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
while ((c != ' ') && (c != '\n'))
{
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
return(OK);
}
/*------------------------------------------------+
| dumpstring() - print out parameter string value |
+------------------------------------------------*/
int dumpstring()
{
char c, lastc;
lastc = c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
while ((c == ' ') || (c == '\n'))
{
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
if (c == '"')
{
if (jcampflag)
(void) putchar('<');
else
(void) putchar(c);
lastc = c;
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
while ((c != '"') || ((c == '"') && (lastc == '\\')))
{
(void) putchar(c);
lastc = c;
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
if (jcampflag)
(void) putchar('>');
else
{
(void) putchar('"');
(void) putchar('\n');
}
return(OK);
}
/*-------------------------------------------+
| skipstring() - skip parameter string value |
+-------------------------------------------*/
int skipstring()
{
char c, lastc;
lastc = c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
while ((c == ' ') || (c == '\n'))
{
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
if (c == '"')
{
lastc = c;
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
while ((c != '"') || ((c == '"') && (lastc == '\\')))
{
lastc = c;
c = (char) fgetc(parfile);
if (c == EOF) return(ERROR);
}
return(OK);
}
/*--------------------------------------------+
| dumpvalue() - print or skip parameter value |
+--------------------------------------------*/
int dumpvalue()
{
if (parhd.basictype == STRING)
{
if (dumpflag)
return(dumpstring());
else
return(skipstring());
}
else
{
if (dumpflag)
return(dumpnumber());
else
return(skipnumber());
}
}
/*----------------------------------------------------+
| skipenumerals() - skip enumerative parameter values |
+----------------------------------------------------*/
int skipenumerals()
{
int i, res, numenum;
res = fscanf(parfile, "%d", &numenum);
if (res == 0)
{
(void) fprintf(stderr, "listparam: problem reading number of enumerals\n");
(void) fclose(parfile);
return(ERROR);
}
for (i = 1; i <= numenum; i++)
{
if (parhd.basictype == STRING)
res = skipstring();
else
res = skipnumber();
if (res != OK)
{
(void) fprintf(stderr, "listparam: problem reading enumerals\n");
(void) fclose(parfile);
return(ERROR);
}
}
return(OK);
}
/*-------------------------------------+
| skipvalues() - skip parameter values |
+-------------------------------------*/
int skipvalues()
{
int i, res;
for (i = 1; i <= parhd.numval; i++)
{
if (parhd.basictype == STRING)
res = skipstring();
else
res = skipnumber();
if (res != OK)
{
(void) fprintf(stderr, "listparam: problem skipping values\n");
(void) fclose(parfile);
return(ERROR);
}
}
return(OK);
}
/*-----------------------------------------------------+
| dump_parameter() - print out (or skip) one parameter |
+-----------------------------------------------------*/
int dump_parameter()
{
dumptype();
if (dumpvalue() != OK)
{
(void) fprintf(stderr, "listparam: problem reading parameter value\n");
(void) fclose(parfile);
return(ERROR);
}
return(OK);
}
/*---------+
| main() |
+---------*/
int main (argc, argv)
int argc;
char *argv[];
{
int i, k, len;
char parname[64];
/* report version information with "-v" / "-version" argument */
if (argc >= 2)
{
if ((!strcasecmp(argv[1], "-v")) || (!strcasecmp(argv[1], "-version")))
{
(void) printf("%s (%s)\n", rev, revdate);
exit(0);
}
}
/* check arguments */
if ((argc < 2) || (argc > 3))
{
displayhelp();
return(ERROR);
}
fname = argv[1];
if (argc > 2)
{
if (! strncasecmp(argv[2], "al", 2)) testval = ALL;
else if (! strncasecmp(argv[2], "no", 2)) testval = NONE;
else if (! strncasecmp(argv[2], "un", 2)) testval = NONE;
else if (! strncasecmp(argv[2], "sa", 2)) testval = SAMPLE;
else if (! strncasecmp(argv[2], "ac", 2)) testval = ACQPAR;
else if (! strncasecmp(argv[2], "pr", 2)) testval = PROCPAR;
else if (! strncasecmp(argv[2], "di", 2)) testval = DISPLAY;
else if (! strncasecmp(argv[2], "sp", 2)) testval = SPSIM;
else if (! strncasecmp(argv[2], "jc", 2)) testval = JCAMP;
else if (! strncasecmp(argv[2], "js", 2)) testval = JCAMP_SPEC;
jcampflag = ((testval == JCAMP) || (testval == JCAMP_SPEC));
}
else
{
if ((argc == 2) && (! strcmp(argv[1], "help")))
{
displayhelp();
return(OK);
}
}
/* open parameter file */
parfile = fopen(fname, "r");
if (parfile == NULL)
{
(void) fprintf(stderr, "listparam: problem opening file %s\n", fname);
return(ERROR);
}
/* read & dump parameters */
while (readheader())
{
dumpflag = ((testval == ALL) ||
(parhd.Ggroup == testval) ||
(parhd.Ggroup == NONE) ||
((testval == JCAMP) && (parhd.active == ON) &&
((parhd.Ggroup == ACQPAR) || (parhd.Ggroup == SAMPLE))) ||
((testval == JCAMP_SPEC) && (parhd.active == ON) &&
((parhd.Ggroup == ACQPAR) || (parhd.Ggroup == PROCPAR) ||
(parhd.Ggroup == SAMPLE))));
if ((dumpflag) && (testval == JCAMP_SPEC))
{
if ((!strcmp(parhd.name,"lb1")) || (!strcmp(parhd.name,"sb1")) ||
(!strcmp(parhd.name,"sbs1")) || (!strcmp(parhd.name,"gf1")) ||
(!strcmp(parhd.name,"gfs1")) || (!strcmp(parhd.name,"awc1")) ||
(!strcmp(parhd.name,"lsfid1")) || (!strcmp(parhd.name,"phfid1")) ||
(!strcmp(parhd.name,"wtfile1")) || (!strcmp(parhd.name,"proc1")) ||
(!strcmp(parhd.name,"fn1")) || (!strcmp(parhd.name,"math")) ||
(!strcmp(parhd.name,"lsfrq1")))
{
dumpflag = 0;
}
}
if (parhd.numval == 0)
{
(void) fprintf(stderr, "listparam: problem reading number of values\n");
if ((dumpflag) && (!jcampflag))
{
tprint("%-15s ", parhd.name);
dumptype();
tprint("Parameter has got no value!\n");
}
(void) fclose(parfile);
return(ERROR);
}
else if (dumpflag)
{
if (parhd.numval == 1)
{
if (jcampflag)
{
linepos = 0;
(void) strcpy(parname, parhd.name);
(void) strcat(parname, "=");
tprint("##$%-13s ", parname);
}
else
tprint("%-15s ", parhd.name);
if (dump_parameter()) return(ERROR);
if (jcampflag)
{
if ((parhd.subtype == DELAY) ||
(parhd.subtype == FREQPAR) ||
(parhd.subtype == PULSE))
{
while (linepos < 18)
{
(void) putchar(' ');
linepos++;
}
}
switch (parhd.subtype)
{
case DELAY: tprint("$$ sec\n"); break;
case FREQPAR: tprint("$$ Hz\n"); break;
case PULSE: tprint("$$ usec\n"); break;
default: tprint("\n"); break;
}
}
}
else
{
if (jcampflag)
{
linepos = 0;
(void) strcpy(parname, parhd.name);
(void) strcat(parname, "=");
tprint("##$%-13s ", parname);
tprint("(0..%d) ", parhd.numval-1);
for (i = 1; i <= parhd.numval; i++)
{
if (dump_parameter()) return(ERROR);
if (i < parhd.numval)
tprint(" ");
else
{
switch (parhd.subtype)
{
case DELAY: tprint(" $$ sec\n"); break;
case FREQPAR: tprint(" $$ Hz\n"); break;
case PULSE: tprint(" $$ usec\n"); break;
default: tprint("\n"); break;
}
}
}
}
else
{
for (i = 1; i <= parhd.numval; i++)
{
len = strlen(parhd.name);
if (parhd.numval > 999)
{
tprint("%s[%04d] ", parhd.name, i);
len += 6;
}
else if (parhd.numval > 99)
{
tprint("%s[%03d] ", parhd.name, i);
len += 5;
}
else if (parhd.numval > 9)
{
tprint("%s[%02d] ", parhd.name, i);
len += 4;
}
else
{
tprint("%s[%d] ", parhd.name, i);
len += 3;
}
for (k = 0; k < 15 - len; k++)
(void) putchar(' ');
if (dump_parameter()) return(ERROR);
}
}
}
}
else
skipvalues();
if (skipenumerals() != OK)
{
(void) fprintf(stderr, "listparam: problem reading enumerals\n");
(void) fclose(parfile);
return(ERROR);
}
}
(void) fclose(parfile);
return(OK);
}
|
the_stack_data/212642972.c | /* JTSK-320111
a4_p6.c
Sheikh Usman Ali
[email protected] */
#include <stdio.h>
double sum25(double v[], int n)
{
double sum = v[2] + v[5];
return sum;
}
int main(void)
{
int n, count;
double v[20];
printf("Enter number of values: \n");
scanf("%d", &n);
printf("Enter vals of v /n");
getchar();
for ( count = 0; count < n; count++)
{
printf("%d /n",count + 1);
scanf("%lf", &v[count]);
}
if (n < 6)
{
printf("\n Array doesn't have any element in either p2 || p5 \n");
return (-111);
}
else
{
printf("Sum of elements at p2 & p5: %lf \n", (double) sum25(v, n));
}
}
|
the_stack_data/167330682.c |
#line 3 "lex.yy.c"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 0
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
#ifdef __cplusplus
/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST
#else /* ! __cplusplus */
/* C99 requires __STDC__ to be defined as 1. */
#if defined (__STDC__)
#define YY_USE_CONST
#endif /* defined (__STDC__) */
#endif /* ! __cplusplus */
#ifdef YY_USE_CONST
#define yyconst const
#else
#define yyconst
#endif
/* Returned upon end-of-file. */
#define YY_NULL 0
/* Promotes a possibly negative, possibly signed char to an unsigned
* integer for use as an array index. If the signed char is negative,
* we want to instead treat it as an 8-bit unsigned char, hence the
* double cast.
*/
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
/* Enter a start condition. This macro really ought to take a parameter,
* but we do it the disgusting crufty way forced on us by the ()-less
* definition of BEGIN.
*/
#define BEGIN (yy_start) = 1 + 2 *
/* Translate the current start state into a value that can be later handed
* to BEGIN to return to the state. The YYSTATE alias is for lex
* compatibility.
*/
#define YY_START (((yy_start) - 1) / 2)
#define YYSTATE YY_START
/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
/* Special action meaning "start processing a new file". */
#define YY_NEW_FILE yyrestart(yyin )
#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
* Ditto for the __ia64__ case accordingly.
*/
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif
/* The state buf must be large enough to hold one state per character in the main buffer.
*/
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif
extern yy_size_t yyleng;
extern FILE *yyin, *yyout;
#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2
#define YY_LESS_LINENO(n)
#define YY_LINENO_REWIND_TO(ptr)
/* Return all but the first "n" matched characters back to the input stream. */
#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
*yy_cp = (yy_hold_char); \
YY_RESTORE_YY_MORE_OFFSET \
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \
while ( 0 )
#define unput(c) yyunput( c, (yytext_ptr) )
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
{
FILE *yy_input_file;
char *yy_ch_buf; /* input buffer */
char *yy_buf_pos; /* current position in input buffer */
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
yy_size_t yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
* delete it.
*/
int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and
* if we're using stdio for input, then we want to use getc()
* instead of fread(), to make sure we stop fetching input after
* each newline.
*/
int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line.
* If so, '^' rules will be active on the next match, otherwise
* not.
*/
int yy_at_bol;
int yy_bs_lineno; /**< The line count. */
int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
int yy_fill_buffer;
int yy_buffer_status;
#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
/* When an EOF's been seen but there's still some text to process
* then we mark the buffer as YY_EOF_PENDING, to indicate that we
* shouldn't try reading from the input source any more. We might
* still have a bunch of tokens to match, though, because of
* possible backing-up.
*
* When we actually see the EOF, we change the status to "new"
* (via yyrestart()), so that the user can continue scanning by
* just pointing yyin at a new input file.
*/
#define YY_BUFFER_EOF_PENDING 2
};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
/* Stack of input buffers. */
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
/* We provide macros for accessing buffer states in case in the
* future we want to put the buffer states in a more general
* "scanner state".
*
* Returns the top of the stack, or NULL.
*/
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
? (yy_buffer_stack)[(yy_buffer_stack_top)] \
: NULL)
/* Same as previous macro, but useful when we know that the buffer stack is not
* NULL or when we need an lvalue. For internal use only.
*/
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
/* yy_hold_char holds the character lost when yytext is formed. */
static char yy_hold_char;
static int yy_n_chars; /* number of characters read into yy_ch_buf */
yy_size_t yyleng;
/* Points to current character in buffer. */
static char *yy_c_buf_p = (char *) 0;
static int yy_init = 0; /* whether we need to initialize */
static int yy_start = 0; /* start state number */
/* Flag which is used to allow yywrap()'s to do buffer switches
* instead of setting up a fresh yyin. A bit of a hack ...
*/
static int yy_did_buffer_switch_on_eof;
void yyrestart (FILE *input_file );
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
void yy_delete_buffer (YY_BUFFER_STATE b );
void yy_flush_buffer (YY_BUFFER_STATE b );
void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
void yypop_buffer_state (void );
static void yyensure_buffer_stack (void );
static void yy_load_buffer_state (void );
static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len );
void *yyalloc (yy_size_t );
void *yyrealloc (void *,yy_size_t );
void yyfree (void * );
#define yy_new_buffer yy_create_buffer
#define yy_set_interactive(is_interactive) \
{ \
if ( ! YY_CURRENT_BUFFER ){ \
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer(yyin,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
}
#define yy_set_bol(at_bol) \
{ \
if ( ! YY_CURRENT_BUFFER ){\
yyensure_buffer_stack (); \
YY_CURRENT_BUFFER_LVALUE = \
yy_create_buffer(yyin,YY_BUF_SIZE ); \
} \
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
}
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
/* Begin user sect3 */
typedef unsigned char YY_CHAR;
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
typedef int yy_state_type;
extern int yylineno;
int yylineno = 1;
extern char *yytext;
#ifdef yytext_ptr
#undef yytext_ptr
#endif
#define yytext_ptr yytext
static yy_state_type yy_get_previous_state (void );
static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
static int yy_get_next_buffer (void );
#if defined(__GNUC__) && __GNUC__ >= 3
__attribute__((__noreturn__))
#endif
static void yy_fatal_error (yyconst char msg[] );
/* Done after the current pattern has been matched and before the
* corresponding action - sets up yytext.
*/
#define YY_DO_BEFORE_ACTION \
(yytext_ptr) = yy_bp; \
yyleng = (size_t) (yy_cp - yy_bp); \
(yy_hold_char) = *yy_cp; \
*yy_cp = '\0'; \
(yy_c_buf_p) = yy_cp;
#define YY_NUM_RULES 3
#define YY_END_OF_BUFFER 4
/* This struct is not used in this scanner,
but its presence is necessary. */
struct yy_trans_info
{
flex_int32_t yy_verify;
flex_int32_t yy_nxt;
};
static yyconst flex_int16_t yy_accept[7] =
{ 0,
0, 0, 4, 1, 2, 0
} ;
static yyconst YY_CHAR yy_ec[256] =
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1
} ;
static yyconst YY_CHAR yy_meta[3] =
{ 0,
1, 1
} ;
static yyconst flex_uint16_t yy_base[7] =
{ 0,
0, 0, 3, 4, 4, 4
} ;
static yyconst flex_int16_t yy_def[7] =
{ 0,
6, 1, 6, 6, 6, 0
} ;
static yyconst flex_uint16_t yy_nxt[7] =
{ 0,
4, 5, 6, 3, 6, 6
} ;
static yyconst flex_int16_t yy_chk[7] =
{ 0,
1, 1, 3, 6, 6, 6
} ;
static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;
extern int yy_flex_debug;
int yy_flex_debug = 0;
/* The intent behind this definition is that it'll catch
* any uses of REJECT which flex missed.
*/
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
char *yytext;
#line 1 "3.lex"
#line 2 "3.lex"
#include<stdio.h>
#include<stdlib.h>
int charcount=0,linecount=0;
#line 469 "lex.yy.c"
#define INITIAL 0
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include <unistd.h>
#endif
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
static int yy_init_globals (void );
/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */
int yylex_destroy (void );
int yyget_debug (void );
void yyset_debug (int debug_flag );
YY_EXTRA_TYPE yyget_extra (void );
void yyset_extra (YY_EXTRA_TYPE user_defined );
FILE *yyget_in (void );
void yyset_in (FILE * _in_str );
FILE *yyget_out (void );
void yyset_out (FILE * _out_str );
yy_size_t yyget_leng (void );
char *yyget_text (void );
int yyget_lineno (void );
void yyset_lineno (int _line_number );
/* Macros after this point can all be overridden by user definitions in
* section 1.
*/
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap (void );
#else
extern int yywrap (void );
#endif
#endif
#ifndef YY_NO_UNPUT
static void yyunput (int c,char *buf_ptr );
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int );
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * );
#endif
#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput (void );
#else
static int input (void );
#endif
#endif
/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif
/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite().
*/
#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
#endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
* is returned in "result".
*/
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \
int c = '*'; \
size_t n; \
for ( n = 0; n < max_size && \
(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \
if ( c == '\n' ) \
buf[n++] = (char) c; \
if ( c == EOF && ferror( yyin ) ) \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
result = n; \
} \
else \
{ \
errno=0; \
while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
{ \
if( errno != EINTR) \
{ \
YY_FATAL_ERROR( "input in flex scanner failed" ); \
break; \
} \
errno=0; \
clearerr(yyin); \
} \
}\
\
#endif
/* No semi-colon after return; correct usage is to write "yyterminate();" -
* we don't want an extra ';' after the "return" because that will cause
* some compilers to complain about unreachable statements.
*/
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif
/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif
/* end tables serialization structures and prototypes */
/* Default declaration of generated scanner - a define so the user can
* easily add parameters.
*/
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
extern int yylex (void);
#define YY_DECL int yylex (void)
#endif /* !YY_DECL */
/* Code executed at the beginning of each rule, after yytext and yyleng
* have been set up.
*/
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif
/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK /*LINTED*/break;
#endif
#define YY_RULE_SETUP \
YY_USER_ACTION
/** The main scanner function which does all the work.
*/
YY_DECL
{
yy_state_type yy_current_state;
char *yy_cp, *yy_bp;
int yy_act;
if ( !(yy_init) )
{
(yy_init) = 1;
#ifdef YY_USER_INIT
YY_USER_INIT;
#endif
if ( ! (yy_start) )
(yy_start) = 1; /* first start state */
if ( ! yyin )
yyin = stdin;
if ( ! yyout )
yyout = stdout;
if ( ! YY_CURRENT_BUFFER ) {
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer(yyin,YY_BUF_SIZE );
}
yy_load_buffer_state( );
}
{
#line 7 "3.lex"
#line 689 "lex.yy.c"
while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
{
yy_cp = (yy_c_buf_p);
/* Support of yytext. */
*yy_cp = (yy_hold_char);
/* yy_bp points to the position in yy_ch_buf of the start of
* the current run.
*/
yy_bp = yy_cp;
yy_current_state = (yy_start);
yy_match:
do
{
YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 7 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
}
while ( yy_base[yy_current_state] != 4 );
yy_find_action:
yy_act = yy_accept[yy_current_state];
if ( yy_act == 0 )
{ /* have to back up */
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
yy_act = yy_accept[yy_current_state];
}
YY_DO_BEFORE_ACTION;
do_action: /* This label is used only to access EOF actions. */
switch ( yy_act )
{ /* beginning of action switch */
case 0: /* must back up */
/* undo the effects of YY_DO_BEFORE_ACTION */
*yy_cp = (yy_hold_char);
yy_cp = (yy_last_accepting_cpos);
yy_current_state = (yy_last_accepting_state);
goto yy_find_action;
case 1:
YY_RULE_SETUP
#line 8 "3.lex"
charcount++;
YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
#line 9 "3.lex"
{linecount++; charcount++;}
YY_BREAK
case 3:
YY_RULE_SETUP
#line 10 "3.lex"
ECHO;
YY_BREAK
#line 762 "lex.yy.c"
case YY_STATE_EOF(INITIAL):
yyterminate();
case YY_END_OF_BUFFER:
{
/* Amount of text matched not including the EOB char. */
int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
/* Undo the effects of YY_DO_BEFORE_ACTION. */
*yy_cp = (yy_hold_char);
YY_RESTORE_YY_MORE_OFFSET
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
{
/* We're scanning a new file or input source. It's
* possible that this happened because the user
* just pointed yyin at a new source and called
* yylex(). If so, then we have to assure
* consistency between YY_CURRENT_BUFFER and our
* globals. Here is the right place to do so, because
* this is the first action (other than possibly a
* back-up) that will match for the new input source.
*/
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
}
/* Note that here we test for yy_c_buf_p "<=" to the position
* of the first EOB in the buffer, since yy_c_buf_p will
* already have been incremented past the NUL character
* (since all states make transitions on EOB to the
* end-of-buffer state). Contrast this with the test
* in input().
*/
if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
{ /* This was really a NUL. */
yy_state_type yy_next_state;
(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
/* Okay, we're now positioned to make the NUL
* transition. We couldn't have
* yy_get_previous_state() go ahead and do it
* for us because it doesn't know how to deal
* with the possibility of jamming (and we don't
* want to build jamming into it because then it
* will run more slowly).
*/
yy_next_state = yy_try_NUL_trans( yy_current_state );
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
if ( yy_next_state )
{
/* Consume the NUL. */
yy_cp = ++(yy_c_buf_p);
yy_current_state = yy_next_state;
goto yy_match;
}
else
{
yy_cp = (yy_c_buf_p);
goto yy_find_action;
}
}
else switch ( yy_get_next_buffer( ) )
{
case EOB_ACT_END_OF_FILE:
{
(yy_did_buffer_switch_on_eof) = 0;
if ( yywrap( ) )
{
/* Note: because we've taken care in
* yy_get_next_buffer() to have set up
* yytext, we can now set up
* yy_c_buf_p so that if some total
* hoser (like flex itself) wants to
* call the scanner after we return the
* YY_NULL, it'll still work - another
* YY_NULL will get returned.
*/
(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
yy_act = YY_STATE_EOF(YY_START);
goto do_action;
}
else
{
if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;
}
break;
}
case EOB_ACT_CONTINUE_SCAN:
(yy_c_buf_p) =
(yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p);
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
goto yy_match;
case EOB_ACT_LAST_MATCH:
(yy_c_buf_p) =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p);
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
goto yy_find_action;
}
break;
}
default:
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found" );
} /* end of action switch */
} /* end of scanning one token */
} /* end of user's declarations */
} /* end of yylex */
/* yy_get_next_buffer - try to read in a new buffer
*
* Returns a code representing an action:
* EOB_ACT_LAST_MATCH -
* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
* EOB_ACT_END_OF_FILE - end of file
*/
static int yy_get_next_buffer (void)
{
char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
char *source = (yytext_ptr);
yy_size_t number_to_move, i;
int ret_val;
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" );
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
{ /* Don't try to fill the buffer, so this is an EOF. */
if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
{
/* We matched a single character, the EOB, so
* treat this as a final EOF.
*/
return EOB_ACT_END_OF_FILE;
}
else
{
/* We matched some text prior to the EOB, first
* process it.
*/
return EOB_ACT_LAST_MATCH;
}
}
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
/* don't do the read, it's not guaranteed to return an EOF,
* just force an EOF
*/
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
else
{
yy_size_t num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
int yy_c_buf_p_offset =
(int) ((yy_c_buf_p) - b->yy_ch_buf);
if ( b->yy_is_our_buffer )
{
yy_size_t new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
else
b->yy_buf_size *= 2;
b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */
yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
}
else
/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
"fatal error - scanner input buffer overflow" );
(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
number_to_move - 1;
}
if ( num_to_read > YY_READ_BUF_SIZE )
num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
(yy_n_chars), num_to_read );
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
if ( (yy_n_chars) == 0 )
{
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
yyrestart(yyin );
}
else
{
ret_val = EOB_ACT_LAST_MATCH;
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
YY_BUFFER_EOF_PENDING;
}
}
else
ret_val = EOB_ACT_CONTINUE_SCAN;
if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
/* Extend the array by 50%, plus the number we really need. */
int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
}
(yy_n_chars) += number_to_move;
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
return ret_val;
}
/* yy_get_previous_state - get the state just before the EOB char was reached */
static yy_state_type yy_get_previous_state (void)
{
yy_state_type yy_current_state;
char *yy_cp;
yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{
YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 7 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
}
return yy_current_state;
}
/* yy_try_NUL_trans - try to make a transition on the NUL character
*
* synopsis
* next_state = yy_try_NUL_trans( current_state );
*/
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
{
int yy_is_jam;
char *yy_cp = (yy_c_buf_p);
YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 7 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_is_jam = (yy_current_state == 6);
return yy_is_jam ? 0 : yy_current_state;
}
#ifndef YY_NO_UNPUT
static void yyunput (int c, char * yy_bp )
{
char *yy_cp;
yy_cp = (yy_c_buf_p);
/* undo effects of setting up yytext */
*yy_cp = (yy_hold_char);
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
yy_size_t number_to_move = (yy_n_chars) + 2;
char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
char *source =
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
*--dest = *--source;
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--yy_cp = (char) c;
(yytext_ptr) = yy_bp;
(yy_hold_char) = *yy_cp;
(yy_c_buf_p) = yy_cp;
}
#endif
#ifndef YY_NO_INPUT
#ifdef __cplusplus
static int yyinput (void)
#else
static int input (void)
#endif
{
int c;
*(yy_c_buf_p) = (yy_hold_char);
if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
{
/* yy_c_buf_p now points to the character we want to return.
* If this occurs *before* the EOB characters, then it's a
* valid NUL; if not, then we've hit the end of the buffer.
*/
if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
/* This was really a NUL. */
*(yy_c_buf_p) = '\0';
else
{ /* need more input */
yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
++(yy_c_buf_p);
switch ( yy_get_next_buffer( ) )
{
case EOB_ACT_LAST_MATCH:
/* This happens because yy_g_n_b()
* sees that we've accumulated a
* token and flags that we need to
* try matching the token before
* proceeding. But for input(),
* there's no matching to consider.
* So convert the EOB_ACT_LAST_MATCH
* to EOB_ACT_END_OF_FILE.
*/
/* Reset buffer status. */
yyrestart(yyin );
/*FALLTHROUGH*/
case EOB_ACT_END_OF_FILE:
{
if ( yywrap( ) )
return EOF;
if ( ! (yy_did_buffer_switch_on_eof) )
YY_NEW_FILE;
#ifdef __cplusplus
return yyinput();
#else
return input();
#endif
}
case EOB_ACT_CONTINUE_SCAN:
(yy_c_buf_p) = (yytext_ptr) + offset;
break;
}
}
}
c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
*(yy_c_buf_p) = '\0'; /* preserve yytext */
(yy_hold_char) = *++(yy_c_buf_p);
return c;
}
#endif /* ifndef YY_NO_INPUT */
/** Immediately switch to a different input stream.
* @param input_file A readable stream.
*
* @note This function does not reset the start condition to @c INITIAL .
*/
void yyrestart (FILE * input_file )
{
if ( ! YY_CURRENT_BUFFER ){
yyensure_buffer_stack ();
YY_CURRENT_BUFFER_LVALUE =
yy_create_buffer(yyin,YY_BUF_SIZE );
}
yy_init_buffer(YY_CURRENT_BUFFER,input_file );
yy_load_buffer_state( );
}
/** Switch to a different input buffer.
* @param new_buffer The new input buffer.
*
*/
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
{
/* TODO. We should be able to replace this entire function body
* with
* yypop_buffer_state();
* yypush_buffer_state(new_buffer);
*/
yyensure_buffer_stack ();
if ( YY_CURRENT_BUFFER == new_buffer )
return;
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
YY_CURRENT_BUFFER_LVALUE = new_buffer;
yy_load_buffer_state( );
/* We don't actually know whether we did this switch during
* EOF (yywrap()) processing, but the only time this flag
* is looked at is after yywrap() is called, so it's safe
* to go ahead and always set it.
*/
(yy_did_buffer_switch_on_eof) = 1;
}
static void yy_load_buffer_state (void)
{
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
(yy_hold_char) = *(yy_c_buf_p);
}
/** Allocate and initialize an input buffer state.
* @param file A readable stream.
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
*
* @return the allocated buffer state.
*/
YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = (yy_size_t)size;
/* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters.
*/
b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 );
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_is_our_buffer = 1;
yy_init_buffer(b,file );
return b;
}
/** Destroy the buffer.
* @param b a buffer created with yy_create_buffer()
*
*/
void yy_delete_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
yyfree((void *) b->yy_ch_buf );
yyfree((void *) b );
}
/* Initializes or reinitializes a buffer.
* This function is sometimes called more than once on the same buffer,
* such as during a yyrestart() or at EOF.
*/
static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
{
int oerrno = errno;
yy_flush_buffer(b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_
* called from yyrestart() or through yy_get_next_buffer.
* In that case, we don't want to reset the lineno or column.
*/
if (b != YY_CURRENT_BUFFER){
b->yy_bs_lineno = 1;
b->yy_bs_column = 0;
}
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
errno = oerrno;
}
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
*
*/
void yy_flush_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
yy_load_buffer_state( );
}
/** Pushes the new state onto the stack. The new state becomes
* the current state. This function will allocate the stack
* if necessary.
* @param new_buffer The new state.
*
*/
void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
/* This block is copied from yy_switch_to_buffer. */
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
/* Only push if top exists. Otherwise, replace top. */
if (YY_CURRENT_BUFFER)
(yy_buffer_stack_top)++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;
/* copied from yy_switch_to_buffer. */
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
/** Removes and deletes the top of the stack, if present.
* The next element becomes the new top.
*
*/
void yypop_buffer_state (void)
{
if (!YY_CURRENT_BUFFER)
return;
yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
if ((yy_buffer_stack_top) > 0)
--(yy_buffer_stack_top);
if (YY_CURRENT_BUFFER) {
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
}
}
/* Allocates the stack if it does not exist.
* Guarantees space for at least one push.
*/
static void yyensure_buffer_stack (void)
{
yy_size_t num_to_alloc;
if (!(yy_buffer_stack)) {
/* First allocation is just for 2 elements, since we don't know if this
* scanner will even need a stack. We use 2 instead of 1 to avoid an
* immediate realloc on the next call.
*/
num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
(num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc;
(yy_buffer_stack_top) = 0;
return;
}
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
/* Increase the buffer to prepare for a possible push. */
yy_size_t grow_size = 8 /* arbitrary grow size */;
num_to_alloc = (yy_buffer_stack_max) + grow_size;
(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
((yy_buffer_stack),
num_to_alloc * sizeof(struct yy_buffer_state*)
);
if ( ! (yy_buffer_stack) )
YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
/* zero only the new slots.*/
memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc;
}
}
/** Setup the input buffer state to scan directly from a user-specified character buffer.
* @param base the character buffer
* @param size the size in bytes of the character buffer
*
* @return the newly allocated buffer state object.
*/
YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
{
YY_BUFFER_STATE b;
if ( size < 2 ||
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */
return 0;
b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;
b->yy_is_our_buffer = 0;
b->yy_input_file = 0;
b->yy_n_chars = b->yy_buf_size;
b->yy_is_interactive = 0;
b->yy_at_bol = 1;
b->yy_fill_buffer = 0;
b->yy_buffer_status = YY_BUFFER_NEW;
yy_switch_to_buffer(b );
return b;
}
/** Setup the input buffer state to scan a string. The next call to yylex() will
* scan from a @e copy of @a str.
* @param yystr a NUL-terminated string to scan
*
* @return the newly allocated buffer state object.
* @note If you want to scan bytes that may contain NUL values, then use
* yy_scan_bytes() instead.
*/
YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
{
return yy_scan_bytes(yystr,strlen(yystr) );
}
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
* scan from a @e copy of @a bytes.
* @param yybytes the byte buffer to scan
* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
*
* @return the newly allocated buffer state object.
*/
YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len )
{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
yy_size_t i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = _yybytes_len + 2;
buf = (char *) yyalloc(n );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
for ( i = 0; i < _yybytes_len; ++i )
buf[i] = yybytes[i];
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
b = yy_scan_buffer(buf,n );
if ( ! b )
YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
/* It's okay to grow etc. this buffer, and we should throw it
* away when we're done.
*/
b->yy_is_our_buffer = 1;
return b;
}
#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif
static void yy_fatal_error (yyconst char* msg )
{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
/* Redefine yyless() so it works in section 3 code. */
#undef yyless
#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
int yyless_macro_arg = (n); \
YY_LESS_LINENO(yyless_macro_arg);\
yytext[yyleng] = (yy_hold_char); \
(yy_c_buf_p) = yytext + yyless_macro_arg; \
(yy_hold_char) = *(yy_c_buf_p); \
*(yy_c_buf_p) = '\0'; \
yyleng = yyless_macro_arg; \
} \
while ( 0 )
/* Accessor methods (get/set functions) to struct members. */
/** Get the current line number.
*
*/
int yyget_lineno (void)
{
return yylineno;
}
/** Get the input stream.
*
*/
FILE *yyget_in (void)
{
return yyin;
}
/** Get the output stream.
*
*/
FILE *yyget_out (void)
{
return yyout;
}
/** Get the length of the current token.
*
*/
yy_size_t yyget_leng (void)
{
return yyleng;
}
/** Get the current token.
*
*/
char *yyget_text (void)
{
return yytext;
}
/** Set the current line number.
* @param _line_number line number
*
*/
void yyset_lineno (int _line_number )
{
yylineno = _line_number;
}
/** Set the input stream. This does not discard the current
* input buffer.
* @param _in_str A readable stream.
*
* @see yy_switch_to_buffer
*/
void yyset_in (FILE * _in_str )
{
yyin = _in_str ;
}
void yyset_out (FILE * _out_str )
{
yyout = _out_str ;
}
int yyget_debug (void)
{
return yy_flex_debug;
}
void yyset_debug (int _bdebug )
{
yy_flex_debug = _bdebug ;
}
static int yy_init_globals (void)
{
/* Initialization is the same as for the non-reentrant scanner.
* This function is called from yylex_destroy(), so don't allocate here.
*/
(yy_buffer_stack) = 0;
(yy_buffer_stack_top) = 0;
(yy_buffer_stack_max) = 0;
(yy_c_buf_p) = (char *) 0;
(yy_init) = 0;
(yy_start) = 0;
/* Defined in main.c */
#ifdef YY_STDINIT
yyin = stdin;
yyout = stdout;
#else
yyin = (FILE *) 0;
yyout = (FILE *) 0;
#endif
/* For future reference: Set errno on error, since we are called by
* yylex_init()
*/
return 0;
}
/* yylex_destroy is for both reentrant and non-reentrant scanners. */
int yylex_destroy (void)
{
/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){
yy_delete_buffer(YY_CURRENT_BUFFER );
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state();
}
/* Destroy the stack itself. */
yyfree((yy_buffer_stack) );
(yy_buffer_stack) = NULL;
/* Reset the globals. This is important in a non-reentrant scanner so the next time
* yylex() is called, initialization will occur. */
yy_init_globals( );
return 0;
}
/*
* Internal utility routines.
*/
#ifndef yytext_ptr
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
{
int i;
for ( i = 0; i < n; ++i )
s1[i] = s2[i];
}
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * s )
{
int n;
for ( n = 0; s[n]; ++n )
;
return n;
}
#endif
void *yyalloc (yy_size_t size )
{
return (void *) malloc( size );
}
void *yyrealloc (void * ptr, yy_size_t size )
{
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latter
* because both ANSI C and C++ allow castless assignment from
* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.
*/
return (void *) realloc( (char *) ptr, size );
}
void yyfree (void * ptr )
{
free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
}
#define YYTABLES_NAME "yytables"
#line 10 "3.lex"
int yywrap() { return 1;}
int main(int n,char ** r)
{
FILE *file;
file = fopen(r[1], "r");
yyin=file;
yylex();
printf("There were %d characters in %d lines\n",charcount,linecount);
return 0;
}
|
the_stack_data/89551.c | #include <stdlib.h>
#include <stdio.h>
#include <time.h>
enum { sample_size = 3 };
typedef int subarray_algorithm(size_t n, int x[n]);
void generaterandomint(size_t n, int** p, int max_num) {
*p = calloc(n, sizeof **p);
srand(time(0));
for (size_t i = 0; i < n; ++i) {
(*p)[i] = rand() % (2 * max_num) - max_num;
}
}
double elapsed_time(clock_t c1[static 1], clock_t c0[static 1]) {
return (double)(c1[0] - c0[0]) / CLOCKS_PER_SEC;
}
int max(int a, int b) {
return (a > b) ? a : b;
}
int algo1(size_t n, int x[n]) {
int maxsofar = 0;
for (size_t i = 0; i < n; ++i) {
for (size_t j = i; j < n; ++j) {
int sum = 0;
for (size_t k = i; k <= j; ++k) {
sum += x[k];
}
maxsofar = max(maxsofar, sum);
}
}
return maxsofar;
}
int algo2(size_t n, int x[n]) {
int maxsofar = 0;
for (size_t i = 0; i < n; ++i) {
int sum = 0;
for (size_t j = i; j < n; ++j) {
sum += x[j];
maxsofar = max(maxsofar, sum);
}
}
return maxsofar;
}
int algo3_inner(size_t n, int x[n], size_t l, size_t u) {
if (l > u) return 0;
if (l == u) return max(0, x[l]);
int lmax, rmax, sum;
size_t m = (l + u) / 2;
lmax = sum = 0;
for (size_t i = m; l <= i && i <= n; --i) {
sum += x[i];
lmax = max(lmax, sum);
}
rmax = sum = 0;
for (size_t i = m+1; i<= u; ++i) {
sum += x[i];
rmax = max(rmax, sum);
}
return max(lmax+rmax, max(algo3_inner(n, x, l, m), algo3_inner(n, x, m+1, u)));
}
int algo3(size_t n, int x[n]) {
return algo3_inner(n, x, 0, n-1);
}
int algo4(size_t n, int x[n]) {
int maxsofar = 0;
int maxendinghere = 0;
for (size_t i = 0; i < n; ++i) {
maxendinghere = max(maxendinghere + x[i], 0);
maxsofar = max(maxsofar, maxendinghere);
}
return maxsofar;
}
int run_algorithm(size_t n, int x[n], subarray_algorithm* f, char* comment) {
int max_num;
clock_t begin, end;
begin = clock();
max_num = f(n, x);
end = clock();
printf("%s, n = %lu, elapsed = %g, result = %d\n",
comment, n, elapsed_time(&end, &begin), max_num);
return max_num;
}
int main(int argc, char* argv[argc+1]) {
size_t n[sample_size] = {100, 1000, 10000};
int abs_max_num = 500;
for (size_t i = 0; i < sample_size; ++i) {
int* x = 0;
generaterandomint(n[i], &x, abs_max_num);
run_algorithm(n[i], x, algo1, "algorithm 1");
run_algorithm(n[i], x, algo2, "algorithm 2");
run_algorithm(n[i], x, algo3, "algorithm 3");
run_algorithm(n[i], x, algo4, "algorithm 4");
free(x);
}
return EXIT_SUCCESS;
}
|
the_stack_data/61074517.c | //
//jmi_p17.c on 20-08-18
//
//programe to find smallest number
#include<stdio.h>
int main()
{
int num1, num2, num3, result;
printf("Enter an number :\t");
scanf("%d", &num1);
printf("Enter an number :\t");
scanf("%d", &num2);
printf("Enter an number :\t");
scanf("%d", &num3);
result = num1 < num2 ? num1 < num3 ? num1 : num3 : num2 < num3 ? num2 : num3;
printf("\n%d is smallest.", result);
return 0;
} |
the_stack_data/147168.c | // Sample 1-1
#include <stdio.h>
main(){
printf("hello world!\n");
}
|
the_stack_data/175143612.c | /*
J. L. Bentley and M. D. McIlroy. Engineering a sort function.
Software---Practice and Experience, 23(11):1249-1265.
*/
#define SWAPINIT(a, es) swaptype = \
(a - (char*) 0) % sizeof(long) || es % sizeof(long) ? 2 : \
es == sizeof(long) ? 0 : 1;
#define swapcode(TYPE, parmi, parmj, n) { \
long i = (n) / sizeof(TYPE); \
register TYPE *pi = (TYPE *) (parmi); \
register TYPE *pj = (TYPE *) (parmj); \
do { \
register TYPE t = *pi; \
*pi++ = *pj; \
*pj++ = t; \
} while (--i > 0); \
}
void swapfunc(char *a, char *b, int n, int swaptype)
{
if (swaptype <= 1) {
swapcode(long, a, b, n)
} else
swapcode(char, a, b, n)
}
#define swap(a, b) \
if (swaptype == 0) { \
long t = * (long *) (a); \
* (long *) (a) = * (long *) (b); \
* (long *) (b) = t; \
} else \
swapfunc(a, b, es, swaptype)
#define vecswap(a, b, n) if (n > 0) swapfunc(a, b, n, swaptype)
#define min(x, y) ((x)<=(y) ? (x) : (y))
char *med3(char *a, char *b, char *c,
int (*cmp) (const void *, const void *))
{
return cmp(a, b) < 0 ? (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a))
: (cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c));
}
void qsort(void *base, unsigned n, int es,
int (*cmp) (const void *, const void *))
{
char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
int d, r, swaptype;
char *a = (char *) base;
SWAPINIT(a, es);
if (n < 7) { /* Insertion sort on small arrays */
for (pm = a + es; pm < a + n * es; pm += es)
for (pl = pm; pl > a && cmp(pl - es, pl) > 0; pl -= es)
swap(pl, pl - es);
return;
}
pm = a + (n / 2) * es;
if (n > 7) {
pl = a;
pn = a + (n - 1) * es;
if (n > 40) { /* On big arrays, pseudomedian of 9 */
d = (n / 8) * es;
pl = med3(pl, pl + d, pl + 2 * d, cmp);
pm = med3(pm - d, pm, pm + d, cmp);
pn = med3(pn - 2 * d, pn - d, pn, cmp);
}
pm = med3(pl, pm, pn, cmp); /* On mid arrays, med of 3 */
}
swap(a, pm); /* On tiny arrays, partition around middle */
pa = pb = a + es;
pc = pd = a + (n - 1) * es;
for (;;) {
while (pb <= pc && (r = cmp(pb, a)) <= 0) {
if (r == 0) {
swap(pa, pb);
pa += es;
}
pb += es;
}
while (pb <= pc && (r = cmp(pc, a)) >= 0) {
if (r == 0) {
swap(pc, pd);
pd -= es;
}
pc -= es;
}
if (pb > pc)
break;
swap(pb, pc);
pb += es;
pc -= es;
}
pn = a + n * es;
r = min(pa - a, pb - pa);
vecswap(a, pb - r, r);
r = min(pd - pc, pn - pd - es);
vecswap(pb, pn - r, r);
if ((r = pb - pa) > es)
qsort(a, r / es, es, cmp);
if ((r = pd - pc) > es)
qsort(pn - r, r / es, es, cmp);
}
|
the_stack_data/237643615.c | ////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2005
// Packet Engineering, Inc. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification is not permitted unless authorized in writing by a duly
// appointed officer of Packet Engineering, Inc. or its derivatives
//
// File Name: mysudo.c
// Description:
//
//
// Modification History:
//
////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char ** argv)
{
char arg[4096];
int i,j;
int p=0;
char status = -1;
arg[0]=0;
for(i=1;i<argc; i++)
{
for(j=0;j<strlen(argv[i]);j++)
{
if(argv[i][j]=='\x1F')
argv[i][j]='\'';
}
strncpy(&arg[p],argv[i],1020-p);
p=strlen(arg);
arg[p]=' ';
arg[p+1]=0;
p++;
}
setuid(0);
seteuid(0);
i = system(arg);
/*
if(i && 0==i%256)
{
i=255;
}
*/
if (WIFSIGNALED(i) &&
(WTERMSIG(i) == SIGINT || WTERMSIG(i) == SIGQUIT))
status = -1;
else if( WIFEXITED(i) )
status = WEXITSTATUS(i);
return status;
}
|
the_stack_data/69017.c |
/* length.c */
/* Get the length of an array */
/* This code is released to the public domain */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
int main()
{
int myarray[] = {32, 67, 25, 48, 5, 17, 23};
int length = sizeof(myarray) / sizeof(*myarray);
printf("length of myarray is %d \n", length);
return 0;
}
|
the_stack_data/111078796.c | /**
* @brief 问题模型：模拟
*
* 思路：
* 初步思路时将移到数组尾部的元素记录到队列，比较完数组后，比较队列
* 进一步发现队列中元素其实时递增的，且一定小于最后一个cur，因此比遍历完数组无须再模拟下去，队列也没有必要了
*/
// #define SIZE 100001
int getWinner(int* arr, int arrSize, int k){
if (k == 1 || arrSize == 2) {
return fmax(arr[0], arr[1]);
}
int cnt = 0;
// empty: front == rear
// full: (rear + 1) % SIZE == front
// push: q[rear] = v; rear = (rear + 1) % SIZE
// pop : ans = q[front]; front = (front + 1) % SIZE
// qsize: (rear - front + SIZE) % SIZE
// int queue[SIZE] = { 0 };
// int front = 0;
// int rear = 0;
int cur = arr[0];
for (int i = 1; i < arrSize; i++) {
if (cur > arr[i]) { // cur 更大，cnt加1，arr[i]加入队列
cnt++;
// queue[rear] = arr[i];
// rear = (rear + 1) % SIZE;
} else { // cur 小，cnt归为1，cur加入队列
cnt = 1;
// queue[rear] = cur;
cur = arr[i];
// rear = (rear + 1) % SIZE;
}
if (cnt == k) return cur;
}
return cur;
} |
the_stack_data/67326504.c | // RUN: clang %loadLLOV %s -o /dev/null 2>&1 | FileCheck %s
#include <omp.h>
#define N 20
int main() {
double A[N], B[N], sum0 = 0.0, sum1 = 0.0;
#pragma omp parallel
{
#pragma omp for // nowait
for (int i = 0; i < N; i++) {
A[i] = i;
B[i] = i * i;
}
#pragma omp for reduction(+ : sum0)
for (int i = 0; i < N; i++) {
sum0 += A[i] * B[i];
}
}
for (int i = 0; i < N; i++) {
sum1 += i * i * i;
}
return (sum1 - sum0);
}
// Printing in reverse. Need to fix it.
// CHECK: Region is Data Race Free.
// CHECK: Region is Data Race Free.
// END
|
the_stack_data/503917.c | // From https://en.wikipedia.org/wiki/Inline_assembler
extern int errno;
int funcname(int arg1, int *arg2, int arg3)
{
int res;
__asm__ volatile (
"int $0x80" /* make the request to the OS */
: "=a" (res), /* return result in eax ("a") */
"+b" (arg1), /* pass arg1 in ebx ("b") */
"+c" (arg2), /* pass arg2 in ecx ("c") */
"+d" (arg3) /* pass arg3 in edx ("d") */
: "a" (128) /* pass system call number in eax ("a") */
: "memory", "cc"); /* announce to the compiler that the memory and condition codes have been modified */
/* The operating system will return a negative value on error;
* wrappers return -1 on error and set the errno global variable */
if (-125 <= res && res < 0) {
errno = -res;
res = -1;
}
return res;
}
|
the_stack_data/24040.c | #include <stdio.h>
int mdc(int num1, int num2) {
int resto;
do {
resto = num1 % num2;
num1 = num2;
num2 = resto;
} while (resto != 0);
return num1;
}
int main()
{
int x, a, b;
scanf("%d", &x);
for(int c = 0; c < x; c++)
{
scanf("%d %d", &a, &b);
printf("%d\n", mdc(a, b));
}
return 0;
} |
the_stack_data/67324857.c | #include <stdio.h>
#include <string.h>
int main()
{
char egn[12];
int egn_i[10];
int god, mes, data;
int i, temp;
scanf("%s",egn);
if (strlen(egn)==10)
{
for(i = 0; i < 10; i++)
{
egn_i[i] = egn[i] - '0';
}
god=egn_i[0]*10+egn_i[1];
if(god>=0 && god<=99)
{
mes=egn_i[2]*10+egn_i[3];
if((mes>=1 && mes<=12) || (mes>=21 && mes<=32) || (mes>=41 && mes<=52))
{
data=egn_i[4]*10+egn_i[5];
if (data<=31)
{
temp = egn_i[0]*2 + egn_i[1]*4 + egn_i[2]*8 + egn_i[3]*5 + egn_i[4]*10 + egn_i[5]*9 + egn_i[6]*7 + egn_i[7]*3 + egn_i[8]*6;
temp%=11;
if(temp==10)
{
temp=0;
}
if (temp==egn_i[9])
{
printf("1");
return 0;
}
else
{
printf("0");
return 0;
}
}
else
{
printf("0");
return 0;
}
}
else
{
printf("0");
return 0;
}
}
else
{
printf("0");
return 0;
}
}
else
{
printf("0");
return 0;
}
return 0;
} |
the_stack_data/45451616.c | #include <math.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <complex.h>
#ifdef complex
#undef complex
#endif
#ifdef I
#undef I
#endif
#if defined(_WIN64)
typedef long long BLASLONG;
typedef unsigned long long BLASULONG;
#else
typedef long BLASLONG;
typedef unsigned long BLASULONG;
#endif
#ifdef LAPACK_ILP64
typedef BLASLONG blasint;
#if defined(_WIN64)
#define blasabs(x) llabs(x)
#else
#define blasabs(x) labs(x)
#endif
#else
typedef int blasint;
#define blasabs(x) abs(x)
#endif
typedef blasint integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef struct { real r, i; } complex;
typedef struct { doublereal r, i; } doublecomplex;
#ifdef _MSC_VER
static inline _Fcomplex Cf(complex *z) {_Fcomplex zz={z->r , z->i}; return zz;}
static inline _Dcomplex Cd(doublecomplex *z) {_Dcomplex zz={z->r , z->i};return zz;}
static inline _Fcomplex * _pCf(complex *z) {return (_Fcomplex*)z;}
static inline _Dcomplex * _pCd(doublecomplex *z) {return (_Dcomplex*)z;}
#else
static inline _Complex float Cf(complex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex double Cd(doublecomplex *z) {return z->r + z->i*_Complex_I;}
static inline _Complex float * _pCf(complex *z) {return (_Complex float*)z;}
static inline _Complex double * _pCd(doublecomplex *z) {return (_Complex double*)z;}
#endif
#define pCf(z) (*_pCf(z))
#define pCd(z) (*_pCd(z))
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
/* Extern is for use with -E */
#ifndef Extern
#define Extern extern
#endif
/* I/O stuff */
typedef int flag;
typedef int ftnlen;
typedef int ftnint;
/*external read, write*/
typedef struct
{ flag cierr;
ftnint ciunit;
flag ciend;
char *cifmt;
ftnint cirec;
} cilist;
/*internal read, write*/
typedef struct
{ flag icierr;
char *iciunit;
flag iciend;
char *icifmt;
ftnint icirlen;
ftnint icirnum;
} icilist;
/*open*/
typedef struct
{ flag oerr;
ftnint ounit;
char *ofnm;
ftnlen ofnmlen;
char *osta;
char *oacc;
char *ofm;
ftnint orl;
char *oblnk;
} olist;
/*close*/
typedef struct
{ flag cerr;
ftnint cunit;
char *csta;
} cllist;
/*rewind, backspace, endfile*/
typedef struct
{ flag aerr;
ftnint aunit;
} alist;
/* inquire */
typedef struct
{ flag inerr;
ftnint inunit;
char *infile;
ftnlen infilen;
ftnint *inex; /*parameters in standard's order*/
ftnint *inopen;
ftnint *innum;
ftnint *innamed;
char *inname;
ftnlen innamlen;
char *inacc;
ftnlen inacclen;
char *inseq;
ftnlen inseqlen;
char *indir;
ftnlen indirlen;
char *infmt;
ftnlen infmtlen;
char *inform;
ftnint informlen;
char *inunf;
ftnlen inunflen;
ftnint *inrecl;
ftnint *innrec;
char *inblank;
ftnlen inblanklen;
} inlist;
#define VOID void
union Multitype { /* for multiple entry points */
integer1 g;
shortint h;
integer i;
/* longint j; */
real r;
doublereal d;
complex c;
doublecomplex z;
};
typedef union Multitype Multitype;
struct Vardesc { /* for Namelist */
char *name;
char *addr;
ftnlen *dims;
int type;
};
typedef struct Vardesc Vardesc;
struct Namelist {
char *name;
Vardesc **vars;
int nvars;
};
typedef struct Namelist Namelist;
#define abs(x) ((x) >= 0 ? (x) : -(x))
#define dabs(x) (fabs(x))
#define f2cmin(a,b) ((a) <= (b) ? (a) : (b))
#define f2cmax(a,b) ((a) >= (b) ? (a) : (b))
#define dmin(a,b) (f2cmin(a,b))
#define dmax(a,b) (f2cmax(a,b))
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
#define abort_() { sig_die("Fortran abort routine called", 1); }
#define c_abs(z) (cabsf(Cf(z)))
#define c_cos(R,Z) { pCf(R)=ccos(Cf(Z)); }
#ifdef _MSC_VER
#define c_div(c, a, b) {Cf(c)._Val[0] = (Cf(a)._Val[0]/Cf(b)._Val[0]); Cf(c)._Val[1]=(Cf(a)._Val[1]/Cf(b)._Val[1]);}
#define z_div(c, a, b) {Cd(c)._Val[0] = (Cd(a)._Val[0]/Cd(b)._Val[0]); Cd(c)._Val[1]=(Cd(a)._Val[1]/df(b)._Val[1]);}
#else
#define c_div(c, a, b) {pCf(c) = Cf(a)/Cf(b);}
#define z_div(c, a, b) {pCd(c) = Cd(a)/Cd(b);}
#endif
#define c_exp(R, Z) {pCf(R) = cexpf(Cf(Z));}
#define c_log(R, Z) {pCf(R) = clogf(Cf(Z));}
#define c_sin(R, Z) {pCf(R) = csinf(Cf(Z));}
//#define c_sqrt(R, Z) {*(R) = csqrtf(Cf(Z));}
#define c_sqrt(R, Z) {pCf(R) = csqrtf(Cf(Z));}
#define d_abs(x) (fabs(*(x)))
#define d_acos(x) (acos(*(x)))
#define d_asin(x) (asin(*(x)))
#define d_atan(x) (atan(*(x)))
#define d_atn2(x, y) (atan2(*(x),*(y)))
#define d_cnjg(R, Z) { pCd(R) = conj(Cd(Z)); }
#define r_cnjg(R, Z) { pCf(R) = conjf(Cf(Z)); }
#define d_cos(x) (cos(*(x)))
#define d_cosh(x) (cosh(*(x)))
#define d_dim(__a, __b) ( *(__a) > *(__b) ? *(__a) - *(__b) : 0.0 )
#define d_exp(x) (exp(*(x)))
#define d_imag(z) (cimag(Cd(z)))
#define r_imag(z) (cimagf(Cf(z)))
#define d_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define r_int(__x) (*(__x)>0 ? floor(*(__x)) : -floor(- *(__x)))
#define d_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define r_lg10(x) ( 0.43429448190325182765 * log(*(x)) )
#define d_log(x) (log(*(x)))
#define d_mod(x, y) (fmod(*(x), *(y)))
#define u_nint(__x) ((__x)>=0 ? floor((__x) + .5) : -floor(.5 - (__x)))
#define d_nint(x) u_nint(*(x))
#define u_sign(__a,__b) ((__b) >= 0 ? ((__a) >= 0 ? (__a) : -(__a)) : -((__a) >= 0 ? (__a) : -(__a)))
#define d_sign(a,b) u_sign(*(a),*(b))
#define r_sign(a,b) u_sign(*(a),*(b))
#define d_sin(x) (sin(*(x)))
#define d_sinh(x) (sinh(*(x)))
#define d_sqrt(x) (sqrt(*(x)))
#define d_tan(x) (tan(*(x)))
#define d_tanh(x) (tanh(*(x)))
#define i_abs(x) abs(*(x))
#define i_dnnt(x) ((integer)u_nint(*(x)))
#define i_len(s, n) (n)
#define i_nint(x) ((integer)u_nint(*(x)))
#define i_sign(a,b) ((integer)u_sign((integer)*(a),(integer)*(b)))
#define pow_dd(ap, bp) ( pow(*(ap), *(bp)))
#define pow_si(B,E) spow_ui(*(B),*(E))
#define pow_ri(B,E) spow_ui(*(B),*(E))
#define pow_di(B,E) dpow_ui(*(B),*(E))
#define pow_zi(p, a, b) {pCd(p) = zpow_ui(Cd(a), *(b));}
#define pow_ci(p, a, b) {pCf(p) = cpow_ui(Cf(a), *(b));}
#define pow_zz(R,A,B) {pCd(R) = cpow(Cd(A),*(B));}
#define s_cat(lpp, rpp, rnp, np, llp) { ftnlen i, nc, ll; char *f__rp, *lp; ll = (llp); lp = (lpp); for(i=0; i < (int)*(np); ++i) { nc = ll; if((rnp)[i] < nc) nc = (rnp)[i]; ll -= nc; f__rp = (rpp)[i]; while(--nc >= 0) *lp++ = *(f__rp)++; } while(--ll >= 0) *lp++ = ' '; }
#define s_cmp(a,b,c,d) ((integer)strncmp((a),(b),f2cmin((c),(d))))
#define s_copy(A,B,C,D) { int __i,__m; for (__i=0, __m=f2cmin((C),(D)); __i<__m && (B)[__i] != 0; ++__i) (A)[__i] = (B)[__i]; }
#define sig_die(s, kill) { exit(1); }
#define s_stop(s, n) {exit(0);}
static char junk[] = "\n@(#)LIBF77 VERSION 19990503\n";
#define z_abs(z) (cabs(Cd(z)))
#define z_exp(R, Z) {pCd(R) = cexp(Cd(Z));}
#define z_sqrt(R, Z) {pCd(R) = csqrt(Cd(Z));}
#define myexit_() break;
#define mycycle() continue;
#define myceiling(w) {ceil(w)}
#define myhuge(w) {HUGE_VAL}
//#define mymaxloc_(w,s,e,n) {if (sizeof(*(w)) == sizeof(double)) dmaxloc_((w),*(s),*(e),n); else dmaxloc_((w),*(s),*(e),n);}
#define mymaxloc(w,s,e,n) {dmaxloc_(w,*(s),*(e),n)}
/* procedure parameter types for -A and -C++ */
#define F2C_proc_par_types 1
#ifdef __cplusplus
typedef logical (*L_fp)(...);
#else
typedef logical (*L_fp)();
#endif
static float spow_ui(float x, integer n) {
float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static double dpow_ui(double x, integer n) {
double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#ifdef _MSC_VER
static _Fcomplex cpow_ui(complex x, integer n) {
complex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x.r = 1/x.r, x.i=1/x.i;
for(u = n; ; ) {
if(u & 01) pow.r *= x.r, pow.i *= x.i;
if(u >>= 1) x.r *= x.r, x.i *= x.i;
else break;
}
}
_Fcomplex p={pow.r, pow.i};
return p;
}
#else
static _Complex float cpow_ui(_Complex float x, integer n) {
_Complex float pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
#ifdef _MSC_VER
static _Dcomplex zpow_ui(_Dcomplex x, integer n) {
_Dcomplex pow={1.0,0.0}; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x._Val[0] = 1/x._Val[0], x._Val[1] =1/x._Val[1];
for(u = n; ; ) {
if(u & 01) pow._Val[0] *= x._Val[0], pow._Val[1] *= x._Val[1];
if(u >>= 1) x._Val[0] *= x._Val[0], x._Val[1] *= x._Val[1];
else break;
}
}
_Dcomplex p = {pow._Val[0], pow._Val[1]};
return p;
}
#else
static _Complex double zpow_ui(_Complex double x, integer n) {
_Complex double pow=1.0; unsigned long int u;
if(n != 0) {
if(n < 0) n = -n, x = 1/x;
for(u = n; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
#endif
static integer pow_ii(integer x, integer n) {
integer pow; unsigned long int u;
if (n <= 0) {
if (n == 0 || x == 1) pow = 1;
else if (x != -1) pow = x == 0 ? 1/x : 0;
else n = -n;
}
if ((n > 0) || !(n == 0 || x == 1 || x != -1)) {
u = n;
for(pow = 1; ; ) {
if(u & 01) pow *= x;
if(u >>= 1) x *= x;
else break;
}
}
return pow;
}
static integer dmaxloc_(double *w, integer s, integer e, integer *n)
{
double m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static integer smaxloc_(float *w, integer s, integer e, integer *n)
{
float m; integer i, mi;
for(m=w[s-1], mi=s, i=s+1; i<=e; i++)
if (w[i-1]>m) mi=i ,m=w[i-1];
return mi-s+1;
}
static inline void cdotc_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i]))._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i]))._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conjf(Cf(&x[i*incx]))._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += conjf(Cf(&x[i*incx]))._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i])) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conjf(Cf(&x[i*incx])) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotc_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i]))._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i]))._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += conj(Cd(&x[i*incx]))._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += conj(Cd(&x[i*incx]))._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i])) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += conj(Cd(&x[i*incx])) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
static inline void cdotu_(complex *z, integer *n_, complex *x, integer *incx_, complex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Fcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i])._Val[0] * Cf(&y[i])._Val[0];
zdotc._Val[1] += Cf(&x[i])._Val[1] * Cf(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cf(&x[i*incx])._Val[0] * Cf(&y[i*incy])._Val[0];
zdotc._Val[1] += Cf(&x[i*incx])._Val[1] * Cf(&y[i*incy])._Val[1];
}
}
pCf(z) = zdotc;
}
#else
_Complex float zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i]) * Cf(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cf(&x[i*incx]) * Cf(&y[i*incy]);
}
}
pCf(z) = zdotc;
}
#endif
static inline void zdotu_(doublecomplex *z, integer *n_, doublecomplex *x, integer *incx_, doublecomplex *y, integer *incy_) {
integer n = *n_, incx = *incx_, incy = *incy_, i;
#ifdef _MSC_VER
_Dcomplex zdotc = {0.0, 0.0};
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i])._Val[0] * Cd(&y[i])._Val[0];
zdotc._Val[1] += Cd(&x[i])._Val[1] * Cd(&y[i])._Val[1];
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc._Val[0] += Cd(&x[i*incx])._Val[0] * Cd(&y[i*incy])._Val[0];
zdotc._Val[1] += Cd(&x[i*incx])._Val[1] * Cd(&y[i*incy])._Val[1];
}
}
pCd(z) = zdotc;
}
#else
_Complex double zdotc = 0.0;
if (incx == 1 && incy == 1) {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i]) * Cd(&y[i]);
}
} else {
for (i=0;i<n;i++) { /* zdotc = zdotc + dconjg(x(i))* y(i) */
zdotc += Cd(&x[i*incx]) * Cd(&y[i*incy]);
}
}
pCd(z) = zdotc;
}
#endif
/* -- translated by f2c (version 20000121).
You must link the resulting object file with the libraries:
-lf2c -lm (in that order)
*/
/* Table of constant values */
static real c_b9 = 0.f;
static real c_b10 = 1.f;
static integer c__3 = 3;
static integer c__1 = 1;
/* > \brief \b SLAROR */
/* =========== DOCUMENTATION =========== */
/* Online html documentation available at */
/* http://www.netlib.org/lapack/explore-html/ */
/* Definition: */
/* =========== */
/* SUBROUTINE SLAROR( SIDE, INIT, M, N, A, LDA, ISEED, X, INFO ) */
/* CHARACTER INIT, SIDE */
/* INTEGER INFO, LDA, M, N */
/* INTEGER ISEED( 4 ) */
/* REAL A( LDA, * ), X( * ) */
/* > \par Purpose: */
/* ============= */
/* > */
/* > \verbatim */
/* > */
/* > SLAROR pre- or post-multiplies an M by N matrix A by a random */
/* > orthogonal matrix U, overwriting A. A may optionally be initialized */
/* > to the identity matrix before multiplying by U. U is generated using */
/* > the method of G.W. Stewart (SIAM J. Numer. Anal. 17, 1980, 403-409). */
/* > \endverbatim */
/* Arguments: */
/* ========== */
/* > \param[in] SIDE */
/* > \verbatim */
/* > SIDE is CHARACTER*1 */
/* > Specifies whether A is multiplied on the left or right by U. */
/* > = 'L': Multiply A on the left (premultiply) by U */
/* > = 'R': Multiply A on the right (postmultiply) by U' */
/* > = 'C' or 'T': Multiply A on the left by U and the right */
/* > by U' (Here, U' means U-transpose.) */
/* > \endverbatim */
/* > */
/* > \param[in] INIT */
/* > \verbatim */
/* > INIT is CHARACTER*1 */
/* > Specifies whether or not A should be initialized to the */
/* > identity matrix. */
/* > = 'I': Initialize A to (a section of) the identity matrix */
/* > before applying U. */
/* > = 'N': No initialization. Apply U to the input matrix A. */
/* > */
/* > INIT = 'I' may be used to generate square or rectangular */
/* > orthogonal matrices: */
/* > */
/* > For M = N and SIDE = 'L' or 'R', the rows will be orthogonal */
/* > to each other, as will the columns. */
/* > */
/* > If M < N, SIDE = 'R' produces a dense matrix whose rows are */
/* > orthogonal and whose columns are not, while SIDE = 'L' */
/* > produces a matrix whose rows are orthogonal, and whose first */
/* > M columns are orthogonal, and whose remaining columns are */
/* > zero. */
/* > */
/* > If M > N, SIDE = 'L' produces a dense matrix whose columns */
/* > are orthogonal and whose rows are not, while SIDE = 'R' */
/* > produces a matrix whose columns are orthogonal, and whose */
/* > first M rows are orthogonal, and whose remaining rows are */
/* > zero. */
/* > \endverbatim */
/* > */
/* > \param[in] M */
/* > \verbatim */
/* > M is INTEGER */
/* > The number of rows of A. */
/* > \endverbatim */
/* > */
/* > \param[in] N */
/* > \verbatim */
/* > N is INTEGER */
/* > The number of columns of A. */
/* > \endverbatim */
/* > */
/* > \param[in,out] A */
/* > \verbatim */
/* > A is REAL array, dimension (LDA, N) */
/* > On entry, the array A. */
/* > On exit, overwritten by U A ( if SIDE = 'L' ), */
/* > or by A U ( if SIDE = 'R' ), */
/* > or by U A U' ( if SIDE = 'C' or 'T'). */
/* > \endverbatim */
/* > */
/* > \param[in] LDA */
/* > \verbatim */
/* > LDA is INTEGER */
/* > The leading dimension of the array A. LDA >= f2cmax(1,M). */
/* > \endverbatim */
/* > */
/* > \param[in,out] ISEED */
/* > \verbatim */
/* > ISEED is INTEGER array, dimension (4) */
/* > On entry ISEED specifies the seed of the random number */
/* > generator. The array elements should be between 0 and 4095; */
/* > if not they will be reduced mod 4096. Also, ISEED(4) must */
/* > be odd. The random number generator uses a linear */
/* > congruential sequence limited to small integers, and so */
/* > should produce machine independent random numbers. The */
/* > values of ISEED are changed on exit, and can be used in the */
/* > next call to SLAROR to continue the same random number */
/* > sequence. */
/* > \endverbatim */
/* > */
/* > \param[out] X */
/* > \verbatim */
/* > X is REAL array, dimension (3*MAX( M, N )) */
/* > Workspace of length */
/* > 2*M + N if SIDE = 'L', */
/* > 2*N + M if SIDE = 'R', */
/* > 3*N if SIDE = 'C' or 'T'. */
/* > \endverbatim */
/* > */
/* > \param[out] INFO */
/* > \verbatim */
/* > INFO is INTEGER */
/* > An error flag. It is set to: */
/* > = 0: normal return */
/* > < 0: if INFO = -k, the k-th argument had an illegal value */
/* > = 1: if the random numbers generated by SLARND are bad. */
/* > \endverbatim */
/* Authors: */
/* ======== */
/* > \author Univ. of Tennessee */
/* > \author Univ. of California Berkeley */
/* > \author Univ. of Colorado Denver */
/* > \author NAG Ltd. */
/* > \date December 2016 */
/* > \ingroup real_matgen */
/* ===================================================================== */
/* Subroutine */ int slaror_(char *side, char *init, integer *m, integer *n,
real *a, integer *lda, integer *iseed, real *x, integer *info)
{
/* System generated locals */
integer a_dim1, a_offset, i__1, i__2;
real r__1;
/* Local variables */
integer kbeg, jcol;
extern /* Subroutine */ int sger_(integer *, integer *, real *, real *,
integer *, real *, integer *, real *, integer *);
integer irow;
extern real snrm2_(integer *, real *, integer *);
integer j;
extern logical lsame_(char *, char *);
extern /* Subroutine */ int sscal_(integer *, real *, real *, integer *),
sgemv_(char *, integer *, integer *, real *, real *, integer *,
real *, integer *, real *, real *, integer *);
integer ixfrm, itype, nxfrm;
real xnorm;
extern /* Subroutine */ int xerbla_(char *, integer *);
real factor;
extern real slarnd_(integer *, integer *);
extern /* Subroutine */ int slaset_(char *, integer *, integer *, real *,
real *, real *, integer *);
real xnorms;
/* -- LAPACK auxiliary routine (version 3.7.0) -- */
/* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
/* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
/* December 2016 */
/* ===================================================================== */
/* Parameter adjustments */
a_dim1 = *lda;
a_offset = 1 + a_dim1 * 1;
a -= a_offset;
--iseed;
--x;
/* Function Body */
*info = 0;
if (*n == 0 || *m == 0) {
return 0;
}
itype = 0;
if (lsame_(side, "L")) {
itype = 1;
} else if (lsame_(side, "R")) {
itype = 2;
} else if (lsame_(side, "C") || lsame_(side, "T")) {
itype = 3;
}
/* Check for argument errors. */
if (itype == 0) {
*info = -1;
} else if (*m < 0) {
*info = -3;
} else if (*n < 0 || itype == 3 && *n != *m) {
*info = -4;
} else if (*lda < *m) {
*info = -6;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("SLAROR", &i__1);
return 0;
}
if (itype == 1) {
nxfrm = *m;
} else {
nxfrm = *n;
}
/* Initialize A to the identity matrix if desired */
if (lsame_(init, "I")) {
slaset_("Full", m, n, &c_b9, &c_b10, &a[a_offset], lda);
}
/* If no rotation possible, multiply by random +/-1 */
/* Compute rotation by computing Householder transformations */
/* H(2), H(3), ..., H(nhouse) */
i__1 = nxfrm;
for (j = 1; j <= i__1; ++j) {
x[j] = 0.f;
/* L10: */
}
i__1 = nxfrm;
for (ixfrm = 2; ixfrm <= i__1; ++ixfrm) {
kbeg = nxfrm - ixfrm + 1;
/* Generate independent normal( 0, 1 ) random numbers */
i__2 = nxfrm;
for (j = kbeg; j <= i__2; ++j) {
x[j] = slarnd_(&c__3, &iseed[1]);
/* L20: */
}
/* Generate a Householder transformation from the random vector X */
xnorm = snrm2_(&ixfrm, &x[kbeg], &c__1);
xnorms = r_sign(&xnorm, &x[kbeg]);
r__1 = -x[kbeg];
x[kbeg + nxfrm] = r_sign(&c_b10, &r__1);
factor = xnorms * (xnorms + x[kbeg]);
if (abs(factor) < 1e-20f) {
*info = 1;
xerbla_("SLAROR", info);
return 0;
} else {
factor = 1.f / factor;
}
x[kbeg] += xnorms;
/* Apply Householder transformation to A */
if (itype == 1 || itype == 3) {
/* Apply H(k) from the left. */
sgemv_("T", &ixfrm, n, &c_b10, &a[kbeg + a_dim1], lda, &x[kbeg], &
c__1, &c_b9, &x[(nxfrm << 1) + 1], &c__1);
r__1 = -factor;
sger_(&ixfrm, n, &r__1, &x[kbeg], &c__1, &x[(nxfrm << 1) + 1], &
c__1, &a[kbeg + a_dim1], lda);
}
if (itype == 2 || itype == 3) {
/* Apply H(k) from the right. */
sgemv_("N", m, &ixfrm, &c_b10, &a[kbeg * a_dim1 + 1], lda, &x[
kbeg], &c__1, &c_b9, &x[(nxfrm << 1) + 1], &c__1);
r__1 = -factor;
sger_(m, &ixfrm, &r__1, &x[(nxfrm << 1) + 1], &c__1, &x[kbeg], &
c__1, &a[kbeg * a_dim1 + 1], lda);
}
/* L30: */
}
r__1 = slarnd_(&c__3, &iseed[1]);
x[nxfrm * 2] = r_sign(&c_b10, &r__1);
/* Scale the matrix A by D. */
if (itype == 1 || itype == 3) {
i__1 = *m;
for (irow = 1; irow <= i__1; ++irow) {
sscal_(n, &x[nxfrm + irow], &a[irow + a_dim1], lda);
/* L40: */
}
}
if (itype == 2 || itype == 3) {
i__1 = *n;
for (jcol = 1; jcol <= i__1; ++jcol) {
sscal_(m, &x[nxfrm + jcol], &a[jcol * a_dim1 + 1], &c__1);
/* L50: */
}
}
return 0;
/* End of SLAROR */
} /* slaror_ */
|
the_stack_data/916196.c | /*
* @Author: gongluck
* @Date: 2020-11-26 08:36:17
* @Last Modified by: gongluck
* @Last Modified time: 2020-11-26 08:44:12
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/poll.h>
#include <errno.h>
#include <fcntl.h>
#define BUFFER_LENGTH 1024
#define POLL_SIZE 1024
int main(int argc, char *argv[])
{
int port = 9096;
int listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd < 0)
{
perror("socket");
return -1;
}
struct sockaddr_in addr = {0};
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = INADDR_ANY;
if (bind(listenfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0)
{
perror("bind");
return -2;
}
if (listen(listenfd, 5) < 0)
{
perror("listen");
return -3;
}
struct pollfd fds[POLL_SIZE] = {0};
fds[0].fd = listenfd;
fds[0].events = POLLIN;
int max_fd = 0, i = 0;
for (i = 1; i < POLL_SIZE; i++)
{
fds[i].fd = -1;
}
while (1)
{
int nready = poll(fds, max_fd + 1, 5);
if (nready <= 0)
continue;
if ((fds[0].revents & POLLIN) == POLLIN) // 判断listenfd是否有数据可读(新连接)
{
struct sockaddr_in client_addr = {0};
socklen_t client_len = sizeof(client_addr);
int clientfd = accept(listenfd, (struct sockaddr *)&client_addr, &client_len);
if (clientfd <= 0)
continue;
char str[INET_ADDRSTRLEN] = {0};
printf("recvived from %s at port %d, sockfd:%d, clientfd:%d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
ntohs(client_addr.sin_port), listenfd, clientfd);
fds[clientfd].fd = clientfd;
fds[clientfd].events = POLLIN;
if (clientfd > max_fd)
max_fd = clientfd;
if (--nready == 0)
continue;
}
for (i = listenfd + 1; i <= max_fd; i++)
{
if (fds[i].revents & (POLLIN | POLLERR))
{
char buffer[BUFFER_LENGTH] = {0};
int ret = recv(i, buffer, BUFFER_LENGTH, 0);
if (ret < 0)
{
if (errno == EAGAIN || errno == EWOULDBLOCK)
{
printf("read all data");
}
close(i);
fds[i].fd = -1;
}
else if (ret == 0)
{
printf(" disconnect %d\n", i);
close(i);
fds[i].fd = -1;
break;
}
else
{
printf("Recv: %s, %d Bytes\n", buffer, ret);
}
if (--nready == 0)
break;
}
}
}
return 0;
}
|
the_stack_data/1152620.c | /* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
*/
/* YYWRAP -- Called by lex when end of file is seen.
*/
int
yywrap()
{
return (1);
}
|
the_stack_data/178265265.c | #include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#include<fcntl.h>
#define int long long int
struct node{
char command[1000];
struct node * next;
struct node * prev;
};
struct node *head, *end;
int n,k,th;
void pushfront(char *command)
{
struct node *temp=(struct node *)malloc(sizeof(struct node));
strcpy(temp->command, command);
temp->next=head;
temp->prev=NULL;
if(head==NULL)
{
head=temp;
end=temp;
// printf("First Value pushed to queue is: %lld\n", head->a );
}
else
{
head->prev=temp;
head=temp;
// printf("Value pushed to queue is: %lld\n",head->a );
}
n++;
}
void pushend(char *command)
{
struct node *temp=(struct node *)malloc(sizeof(struct node));
strcpy(temp->command, command);
temp->next=NULL;
if(head==NULL)
{
temp->prev=NULL;
head=temp;
end=temp;
// printf("First Value pushed to queue is: %lld\n", head->a );
}
else
{
end->next=temp;
temp->prev=end;
end=temp;
// printf("Value pushed to queue is: %lld\n",head->a );
}
n++;
}
void popend()
{
// printf("DELETED.\n");
struct node *temp=end;
//Only one element in queue
if(end->prev==NULL)
{
// printf("ONLY ONE ELEMENT\n");
end=head=NULL;
}
else
{
(end->prev)->next=NULL;
end=end->prev;
// printf("REMOVE: %lld from end\n", temp->a );
}
free(temp);
n--;
}
void popfront()
{
struct node *temp=head;
if(head->next==NULL)
{
// printf("NULL ERROR\n");
head->prev=NULL;
end->next=end->prev=NULL;
end=head=NULL;
return;
}
head=head->next;
// printf("head->next->a %lld\n", temp->next->a);
head->prev=NULL;
// printf("REMOVE 2.0: %lld from front\n", temp->a );
free(temp);
// printf("DELETE.\n");
if(head==NULL)
end=NULL;
n--;
}
void update_history()
{
FILE *history = fopen("./history", "w");
if(history == NULL)
{
perror("Shell:");
return;
}
struct node *temp = head;
while(temp)
{
char *withoutnewline = strtok(temp->command, "\n");
fprintf(history, "%s\n", withoutnewline);
temp = temp->next;
}
fclose(history);
}
void initialize_history()
{
// printf("1.");
head = end = NULL;
FILE *history = fopen("./history", "r");
// printf("2.");
if(history == NULL)
{
perror("Shell:");
return;
}
int c = 0;
n = 0;
char command[1000];
while(fgets(command, 1000, history) != NULL)
{
c++;
pushend(command);
}
// printf("3.");
n = c;
update_history();
fclose(history);
}
void add_history(char *command)
{
if(n == 20)
popend();
pushfront(command);
update_history();
}
void history(char **tokenized_input, int count)
{
if(count == 1)
{
struct node *temp = head;
int i=0;
while(temp && i<10)
{
printf("\n%s", temp->command);
temp = temp->next;
i++;
}
}
else
{
count = atoi(tokenized_input[1]);
if(count == 0)
{
printf("\nUsage: history <number of commands to be displayed>");
return;
}
struct node *temp = head;
int i=0;
while(temp && i<count)
{
printf("\n%s", temp->command);
temp = temp->next;
i++;
}
}
} |
the_stack_data/132953384.c | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
char *w = getenv("EXTRA");
if (!w)
w = getenv("FOOD");
if (!w)
w = argv[argc-1];
char *c = getenv("EXTRA");
if (!c)
c = argv[argc-1];
printf("%s with %s\n", c, w);
return 0;
}
|
the_stack_data/6388491.c | // Author: [email protected]
// Date: 2015-09-09
//
// We assume sizeof(int)=4 and sizeof(long)>4.
#include <stdio.h>
//#include "discover.h"
int main() {
// The operand 1LL has type long long. Due to the usual arithmetic conversions,
// 2147483647 is converted to long long before the addition, hence there is
// no overflow.
int y = 2147483647;
int x = /*@{Safe:IntegerOverflow*/ /*@{Safe:IntegerOverflow*/(y + 1LL)/*@:Safe}*/ - 23;/*@:Safe}*/
printf("%d\n", x);
return 0;
}
|
the_stack_data/1044719.c | /*
<TAGS>signal_processing transform</TAGS>
DESCRIPTION:
- reduce data to averaged bins of a fixed size
- non-finite values are impossible for short-integer input
- allows for different numbers of elements to go into different bins to evenly spread the results (fractional bin-widths)
- allows definition of a "zero" sample which is guaranteed to be the first sample in the bin corresponding with the new "zero"
- guarantees no bins will be under-sampled - edge bins will contain between 1x and just-under-2x bindwidth samples
- exception - a single partial-bin just before zero can be included, as data around zero is usually too important to exclude
USES:
Downsampling data
DEPENDENCY TREE:
No dependencies
ARGUMENTS:
short *data : pointer to input array, which will be overwritten
long *setn : number of elements in data (overwritten - pass as address)
long *setz : element to treat as "zero" (overwritten - pass as address)
double setbinsize : desired bin-width (samples - can be a fraction)
char *message : array to hold error message
RETURN VALUE:
- status (0=success, -1=fail)
- setz and setn are also updated
- can be used to reconstruct timestamps
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int xf_bin1b_s(short *data, long *setn, long *setz, double setbinsize, char *message) {
char *thisfunc="xf_bin1b_s\0";
long ii,jj,n1,n2=0,zero,sum=0,nsums=0,start;
double aa,bb,cc,prebins,limit;
n1=*setn;
zero=*setz;
//TEST: fprintf(stderr,"n1=%ld\tzero=%ld\tsetbinsize=%.9f\n",n1,zero,setbinsize);
/* CHECK PARAMETERS */
if(n1<1) {
sprintf(message,"%s [ERROR]: number of samples (%ld) must be >0",thisfunc,n1);
return(-1);
}
if(setbinsize==1.0) {
return(n1);
}
if(setbinsize<=0) {
sprintf(message,"%s [ERROR]: bin size (%g) must be >0",thisfunc,setbinsize);
return(-1);
}
if(zero>=n1) {
sprintf(message,"%s [ERROR]: specified zero-sample (%ld) must be less than data array length (%ld)",thisfunc,zero,n1);
return(-1);
}
//TEST: for(ii=0;ii<n1;ii++) printf("%g\n",data[ii]); exit(1);
/* IF "ZERO" IS SET, CALCULATE THE NUMBER OF BINS BEFORE "ZERO" (PREBINS) */
/* note that if prebins is not an integer, a portion will be combined with another bin */
if(zero>0) prebins=(double)(zero)/setbinsize;
else prebins=0.0;
/* PRE-BIN AND SET START FOR MAIN BINNING SECTION */
/* if prebins is zero or an integer, we can start from sample-zero with no special measures */
if(fmod(prebins,1)==0.0) {
start= 0;
limit= setbinsize - 1.0;
}
/* otherwise, build a fractional bin and proceed from the first full-bin */
else {
// define limits for first bin which will include the partial bin + 1 full bin
limit= (double)(zero-1) - ((long)(prebins-1.0)*setbinsize);
if(limit>=zero) limit= zero-1;
// build the bin
for(ii=0;ii<=limit;ii++) { sum+= data[ii]; nsums++;}
if(nsums>0) data[n2]= (short)(sum/nsums);
else data[n2]=0;
n2++;
// set parameters for main loop
start= (long)limit+1;
limit+= setbinsize;
}
//TEST: fprintf(stderr,"start: %ld zero: %ld setbinsize:%.4f prebins=%g limit:%.16f\n",start,zero,setbinsize,prebins,limit);
/* START BINNING: LEFTOVER DATA AT THE END IS ADDED TO THE PRECEDING BIN */
sum= 0;
nsums= 0;
for(ii=start;ii<n1;ii++) {
/* build runing sum and total data-points */
sum+= data[ii]; nsums++;
// if the current sample-number is >= the limit defining the right edge of the curent window...
if(ii>=limit) {
//TEST: printf("\tii=%ld bin=%ld nsums=%ld limits: %f to %f: next=%f\n",ii,n2,nsums,(limit-setbinsize),(limit),(limit+setbinsize));
data[n2]= (short)(sum/nsums);
n2++;
sum=0; // reset the running sum
nsums=0; // reset the count within the window
limit+= setbinsize; // readjust limit
}
}
//TEST: fprintf(stderr,"ii: %ld limit:%g nsums:%ld sum:%g \n",ii,limit,nsums,sum);
/* MAKE ONE MORE BIN IF THERE IS LEFTOVER DATA (IE. IF LAST SAMPLE DIDN'T TIP THE LIMIT) */
if( ((ii-1)+setbinsize) != limit ) {
jj= n1-(long)setbinsize;
if(jj<zero) jj=zero; // cannot integrate data from before zero!
sum=0; nsums=0;
for(ii=jj;ii<n1;ii++) {
sum+= data[ii];
nsums++;
}
if(nsums>=0) data[n2]= (short)(sum/nsums);
else data[n2]=0;
n2++;
}
/* REASSIGN SETZ AND N */
(*setz)= prebins;
(*setn)= n2;
return(0);
}
|
the_stack_data/150140426.c | /*
* xlibc/stdio/fread.c
*/
#include <stdio.h>
size_t fread(void * buf, size_t size, size_t count, FILE * f)
{
unsigned char * p = buf;
size_t i;
for(i = 0; i < count; i++)
{
if(__stdio_read(f, p, size) != size)
break;
p += size;
}
return i;
}
|
the_stack_data/198579385.c | #include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <locale.h>
#include <monetary.h>
#include <string.h>
void strConcat(char *dest, size_t destLength, const char *src1, const char *src2) {
memset(dest, 0, destLength);
strcat(dest, src1);
strcat(dest, src2);
}
int main(int argc, char const *argv[]) {
const size_t bufferSize = 256;
uint8_t testAmountsCount = 11 * 2;
double testAmounts[testAmountsCount];
testAmounts[0] = 0;
testAmounts[1] = 123456789;
for (uint8_t i = 2; i < testAmountsCount; i++) {
double x = -testAmounts[i-1];
if (i%2 == 0) {
x /= 10;
}
testAmounts[i] = x;
}
char* utf8Suffix = ".UTF-8";
for (int localeIndex = 1; localeIndex < argc; localeIndex++) {
size_t libcLocaleLength = strlen(argv[localeIndex]) + strlen(utf8Suffix) + 1;
char libcLocale[libcLocaleLength];
strConcat(libcLocale, libcLocaleLength, argv[localeIndex], utf8Suffix);
char *selectedLibcLocale = setlocale(LC_MONETARY, libcLocale);
if (selectedLibcLocale == NULL) {
printf("%s\30", argv[localeIndex]);
continue;
}
for (uint8_t testAmountIndex = 0; testAmountIndex < testAmountsCount; testAmountIndex++) {
double testAmount = testAmounts[testAmountIndex];
char libcFormatted[bufferSize];
strfmon(libcFormatted, bufferSize, "%n", testAmount);
printf("%s\31%f\31%s\30", argv[localeIndex], testAmount, libcFormatted);
}
}
return 0;
}
|
the_stack_data/132735.c | #include <stdio.h>
#include <inttypes.h>
#include <stdlib.h>
#include <limits.h>
int reverse_number(int n);
int main() {
printf("non-reversed: %d\n", 153423646);
printf("reversed: %d\n", reverse_number(153423646));
return 0;
}
int reverse_number(int x) {
int64_t out = 0;
int64_t last_digit = 0;
if(x == 0)
{
return 1;
exit(1);
}
while (x > 0 || x < 0) {
last_digit = x % 10;
if ((out*10) >= INT_MAX || (out*10) <= INT_MIN) {
return 0;
}
out = (out * 10) + last_digit;
x /= 10;
}
return out;
}
|
the_stack_data/87636569.c | /*
* author: SciZeal
* email: [email protected]
* time: 2020-05-11
*
* MIT LICENCE
*/
#define _AUTHOR_IS_SCIZEAL
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#define maxn 6000
bool soldier[maxn];
// knockout specified soldier
void knockout(int num)
{
int index = 0; // index of soldier
int count = 0; // from 0 to factor
int in_queue = num; // number of in-queue soldiers
int factor = 2; // switch between 2 and 3
while (in_queue > 3)
{
if (soldier[index])
{
count++;
if (count == factor)
{
soldier[index] = false;
in_queue--;
count = 0;
}
}
index++;
if (index >= num)
{
index = count = 0;
factor = 6 / factor;
}
}
}
int main()
{
memset(soldier, true, sizeof(soldier));
int num;
scanf("%d", &num);
knockout(num);
int printed = 0;
for (int i = 0; i < num; i++)
{
if (soldier[i])
{
printf("%d", i + 1);
printed++;
if (printed == 3)
{
printf("\n");
break;
}
printf(" ");
}
}
return 0;
}
|
the_stack_data/115073.c | int main()
{
int i, space, rows, k=0, count = 0, count1 = 0;
printf("Enter number of rows: ");
scanf("%d",&rows);
for(i=1; i<=rows; ++i)
{
for(space=1; space <= rows-i; ++space)
{
printf(" ");
++count;
}
while(k != 2*i-1)
{
if (count <= rows-1)
{
printf("%d ", i+k);
++count;
}
else
{
++count1;
printf("%d ", (i+k-2*count1));
}
++k;
}
count1 = count = k = 0;
printf("\n");
}
return 0;
}
|
the_stack_data/1206953.c | #include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <fcntl.h>
#include <sys/msg.h>
struct msgbuf{
long msgtype;
char msg[256];
};
int main()
{
struct msgbuf message;
key_t key;
int msgid, ff;
/* ff = open("file", O_RDWR | O_TRUNC | O_CREAT, 0644);
if(ff<0)
{
perror("file");
return 1;
}
*/
key = ftok("msg.c", 'z');
if(key<0)
{
perror("key");
return 2;
}
// close(ff);
msgid = msgget(key, IPC_CREAT | 0666);
if(msgid<0)
{
perror("msgget");
return 3;
}
for(;;)
{
msgrcv(msgid, &message, 256, 2, 0);
if(strcmp(message.msg, "q") == 0)
break;
else
printf("Process received: %s", message.msg);
}
return 0;
}
|
the_stack_data/212642839.c | /*
compilation:
clang -pedantic -Wall -o omp-ser-cl omp-ser.c -fopenmp=libomp -fopenmp-targets=nvptx64-nvidia-cuda -L/usr/local/cuda/lib64 --cuda-path=/usr/local/cuda
minimal compilation command:
clang -o omp-ser-cl omp-ser.c -fopenmp=libomp -fopenmp-targets=nvptx64-nvidia-cuda
source: based on "OpenMP Application Programming Interface Examples - Version 5.0.0 - November 2019"
Section 4.7.1 'Simple target data Construct'
*/
#include <stdlib.h>
#include <omp.h>
int main (){
const int N = 1000000;
unsigned int i;
unsigned int j;
float *a;
float *b;
float *c;
a = (float *)malloc(N * sizeof(float));
b = (float *)malloc(N * sizeof(float));
c = (float *)malloc(N * sizeof(float));
//srand((unsigned int)time(NULL));
for (i = 0; i < N; i++) {
a[i] = 0;
b[i] = ((float)rand() / (float)(RAND_MAX)) * 4.0;
c[i] = ((float)rand() / (float)(RAND_MAX)) * 4.0;
}
#pragma omp target data map (to: c[0:N], b[0:N]) map(from: a[0:N])
{
#pragma omp target
#pragma omp parallel for
for (j=0; j<N; j++)
{
a[j] = b[j]+3.73*c[j];
}
}
return 0;
}
|
the_stack_data/51756.c | #include <stdio.h>
int main(void){
for(int i=123;i<350;i++){
int j=i*2;
int k=i*3;
int mul=1,sum=0;
for(int a=i;a>0;a/=10) {
sum+=(a%10);
mul*=(a%10);
}
for(int a=j;a>0;a/=10) {
sum+=(a%10);
mul*=(a%10);
}
for(int a=k;a>0;a/=10) {
sum+=(a%10);
mul*=(a%10);
}
if(sum==45 && mul==362880) printf("%d %d %d\n",i,j,k);
}
return 0;
}
|
the_stack_data/179832155.c | // Tests for 3C.
//
// Tests properties about type re-writing and replacement, and simple function
// return value stuff.
//
// RUN: 3c -alltypes %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_ALL","CHECK","CHECK_NEXT" %s
// RUN: 3c %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_NOALL","CHECK","CHECK-NEXT" %s
// RUN: 3c %s -- | %clang_cc1 -verify -fcheckedc-extension -x c -
// expected-no-diagnostics
//
typedef unsigned short wchar_t;
void typd_driver(void) {
wchar_t buf[10];
wchar_t *a = &buf[0];
wchar_t *b = &buf[0];
*a = 0;
*(b+4) = 0;
}
//CHECK: void typd_driver(void) {
//CHECK_NOALL: wchar_t buf[10];
//CHECK_NOALL: wchar_t *a = &buf[0];
//CHECK_NOALL: wchar_t *b = &buf[0];
//CHECK_ALL: wchar_t buf _Checked[10];
//CHECK_ALL: _Ptr<wchar_t> a = &buf[0];
//CHECK_ALL: _Array_ptr<wchar_t> b : count(10) = &buf[0];
typedef struct _A {
int a;
int b;
} A, *PA;
void mut_pa(PA p) {
p->a = 0;
p->b = 1;
}
//CHECK: void mut_pa(_Ptr<struct _A> p) {
void pa_driver(void) {
A a = {0};
PA b = &a;
mut_pa(b);
}
//CHECK: void pa_driver(void) {
//CHECK-NEXT: A a = {0};
//CHECK-NEXT: _Ptr<struct _A> b = &a;
int *id(int *a) {
return a;
}
//CHECK: _Ptr<int> id(_Ptr<int> a) {
extern int *fry(void);
//CHECK: extern int *fry(void);
void fret_driver(void) {
int a = 0;
int *b = &a;
int *c = id(b);
int *d = fry();
}
//CHECK: void fret_driver(void) {
//CHECK-NEXT: int a = 0;
//CHECK-NEXT: _Ptr<int> b = &a;
//CHECK-NEXT: _Ptr<int> c = id(b);
//CHECK-NEXT: int *d = fry();
typedef int *(*fooptr)(int*, int);
//CHECK: typedef _Ptr<_Ptr<int> (_Ptr<int> , int )> fooptr;
int *good_mut(int *a, int b) {
*a = b;
return a;
}
//CHECK: _Ptr<int> good_mut(_Ptr<int> a, int b) {
void fooptr_driver(void) {
fooptr f = &good_mut;
int a = 0;
int *b = &a;
int *c = f(b, 1);
}
//CHECK: void fooptr_driver(void) {
//CHECK-NEXT: fooptr f = &good_mut;
//CHECK-NEXT: int a = 0;
//CHECK-NEXT: _Ptr<int> b = &a;
//CHECK-NEXT: _Ptr<int> c = f(b, 1);
#define launder(x) (char*) x
void launder_driver(void) {
int a = 0;
int *b = &a;
int *e = &a;
char *d = launder(e);
*b = 0;
*d = 0;
}
//CHECK: void launder_driver(void) {
//CHECK-NEXT: int a = 0;
//CHECK-NEXT: _Ptr<int> b = &a;
//CHECK-NEXT: int *e = &a;
//CHECK-NEXT: char *d = launder(e);
typedef struct _D {
char *a;
} D;
//CHECK: typedef struct _D {
//CHECK-NEXT: char *a;
typedef struct _E {
char *b;
int a;
} E;
#define launder1(x) ((E*) x->a)
void launder_driver2(void) {
D d;
D *pd = &d;
E *pe = launder1(pd);
}
//CHECK: void launder_driver2(void) {
//CHECK-NEXT: D d;
//CHECK-NEXT: _Ptr<D> pd = &d;
//CHECK-NEXT: E *pe = launder1(pd);
void easy_cast_driver(void) {
int a = 0;
int *b = &a;
char *c = (char *)b;
*b = 0;
*c = 1;
}
//CHECK: void easy_cast_driver(void) {
//CHECK-NEXT: int a = 0;
//CHECK-NEXT: int *b = &a;
//CHECK-NEXT: char *c = (char *)b;
|
the_stack_data/76010.c | /*
* Copyright 2001-2021 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#include <openssl/ocsp.h>
#include <openssl/http.h>
#ifndef OPENSSL_NO_OCSP
OSSL_HTTP_REQ_CTX *OCSP_sendreq_new(BIO *io, const char *path,
const OCSP_REQUEST *req, int buf_size)
{
OSSL_HTTP_REQ_CTX *rctx = OSSL_HTTP_REQ_CTX_new(io, io, buf_size);
if (rctx == NULL)
return NULL;
/*-
* by default:
* no bio_update_fn (and consequently no arg)
* no ssl
* no proxy
* no timeout (blocking indefinitely)
* no expected content type
* max_resp_len = 100 KiB
*/
if (!OSSL_HTTP_REQ_CTX_set_request_line(rctx, 1 /* POST */,
NULL, NULL, path))
goto err;
/* by default, no extra headers */
if (!OSSL_HTTP_REQ_CTX_set_expected(rctx,
NULL /* content_type */, 1 /* asn1 */,
0 /* timeout */, 0 /* keep_alive */))
goto err;
if (req != NULL
&& !OSSL_HTTP_REQ_CTX_set1_req(rctx, "application/ocsp-request",
ASN1_ITEM_rptr(OCSP_REQUEST),
(const ASN1_VALUE *)req))
goto err;
return rctx;
err:
OSSL_HTTP_REQ_CTX_free(rctx);
return NULL;
}
OCSP_RESPONSE *OCSP_sendreq_bio(BIO *b, const char *path, OCSP_REQUEST *req)
{
OCSP_RESPONSE *resp = NULL;
OSSL_HTTP_REQ_CTX *ctx;
BIO *mem;
ctx = OCSP_sendreq_new(b, path, req, 0 /* default buf_size */);
if (ctx == NULL)
return NULL;
mem = OSSL_HTTP_REQ_CTX_exchange(ctx);
/* ASN1_item_d2i_bio handles NULL bio gracefully */
resp = (OCSP_RESPONSE *)ASN1_item_d2i_bio(ASN1_ITEM_rptr(OCSP_RESPONSE),
mem, NULL);
OSSL_HTTP_REQ_CTX_free(ctx);
return resp;
}
#endif /* !defined(OPENSSL_NO_OCSP) */
|
the_stack_data/9651.c |
extern void x86g_calculate_eflags_c ( int cc_op );
void x86g_calculate_eflags_c ( int cc_op )
{
}
|
the_stack_data/167331441.c | #include <stdio.h>
int main()
{
printf("Here we go\n");
while(1)
{
printf("Forever world\n");
}
return 0;
}
|
the_stack_data/211348.c | #include <stdio.h>
int main()
{
char c = 'a', e;
printf("Digite um caractere: ");
scanf("%c", &e);
if (e != c){
printf("Esse caractere e diferente.");
}
if (e == c){
printf("Esse caractere e igual.");
}
return 0;
}
|
the_stack_data/96556.c | // 编写程序对表达式求值：
// Enter an expression: 1+2.5*3
// Value of expression: 10.5
// 表达式中的操作数是浮点数，运算符是+、-、*和/。
// 表达式从左向右求值（所有运算符的优先级都一样）。
#include <stdio.h>
int main() {
// TODO
return 0;
}
|
the_stack_data/77398.c | #include <stdio.h>
#define ARRAY_SIZE (100000000)
#define ARRAY_SIZE_SQRT (10000)
char array[ARRAY_SIZE];
int main( void )
{
int n, i;
/* 配列を初期化する */
for( i = 0; i < ARRAY_SIZE; i++ )
array[i] = 1;
/* 配列をふるいにかける */
for( n = 2; n <= ARRAY_SIZE_SQRT; n++ ) {
if( array[n] == 1 ) {
for( i = n * n; i < ARRAY_SIZE; i += n )
array[i] = 0;
}
}
/* ふるいで残った数は素数である */
for( n = 2; n < ARRAY_SIZE; n++ ) {
if( array[n] == 1 )
printf( "%d\n", n );
}
return( 0 );
}
|
the_stack_data/963680.c | // General tests that ld invocations on Linux targets sane. Note that we use
// sysroot to make these tests independent of the host system.
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LD-32 %s
// CHECK-LD-32-NOT: warning:
// CHECK-LD-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-32: "{{.*}}/usr/lib/gcc/i386-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0"
// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/lib"
// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../.."
// CHECK-LD-32: "-L[[SYSROOT]]/lib"
// CHECK-LD-32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LD-64 %s
// CHECK-LD-64-NOT: warning:
// CHECK-LD-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-64: "--eh-frame-hdr"
// CHECK-LD-64: "-m" "elf_x86_64"
// CHECK-LD-64: "-dynamic-linker"
// CHECK-LD-64: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-LD-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-LD-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-LD-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-LD-64: "-L[[SYSROOT]]/lib"
// CHECK-LD-64: "-L[[SYSROOT]]/usr/lib"
// CHECK-LD-64: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// CHECK-LD-64: "-lc"
// CHECK-LD-64: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnux32 -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LD-X32 %s
// CHECK-LD-X32-NOT: warning:
// CHECK-LD-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-X32: "--eh-frame-hdr"
// CHECK-LD-X32: "-m" "elf32_x86_64"
// CHECK-LD-X32: "-dynamic-linker"
// CHECK-LD-X32: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// CHECK-LD-X32: "-lc"
// CHECK-LD-X32: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: --rtlib=compiler-rt \
// RUN: | FileCheck --check-prefix=CHECK-LD-RT %s
// CHECK-LD-RT-NOT: warning:
// CHECK-LD-RT: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-RT: "--eh-frame-hdr"
// CHECK-LD-RT: "-m" "elf_x86_64"
// CHECK-LD-RT: "-dynamic-linker"
// CHECK-LD-RT: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-LD-RT: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-LD-RT: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-LD-RT: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-LD-RT: "-L[[SYSROOT]]/lib"
// CHECK-LD-RT: "-L[[SYSROOT]]/usr/lib"
// CHECK-LD-RT: libclang_rt.builtins-x86_64.a"
// CHECK-LD-RT: "-lc"
// CHECK-LD-RT: libclang_rt.builtins-x86_64.a"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: --rtlib=compiler-rt \
// RUN: | FileCheck --check-prefix=CHECK-LD-RT-ANDROID %s
// CHECK-LD-RT-ANDROID-NOT: warning:
// CHECK-LD-RT-ANDROID: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-RT-ANDROID: "--eh-frame-hdr"
// CHECK-LD-RT-ANDROID: "-m" "armelf_linux_eabi"
// CHECK-LD-RT-ANDROID: "-dynamic-linker"
// CHECK-LD-RT-ANDROID: libclang_rt.builtins-arm-android.a"
// CHECK-LD-RT-ANDROID: "-lc"
// CHECK-LD-RT-ANDROID: libclang_rt.builtins-arm-android.a"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: --rtlib=libgcc \
// RUN: | FileCheck --check-prefix=CHECK-LD-GCC %s
// CHECK-LD-GCC-NOT: warning:
// CHECK-LD-GCC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-GCC: "--eh-frame-hdr"
// CHECK-LD-GCC: "-m" "elf_x86_64"
// CHECK-LD-GCC: "-dynamic-linker"
// CHECK-LD-GCC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-LD-GCC: "-L[[SYSROOT]]/lib"
// CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib"
// CHECK-LD-GCC: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// CHECK-LD-GCC: "-lc"
// CHECK-LD-GCC: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -rtlib=platform \
// RUN: -static-libgcc \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LD-64-STATIC-LIBGCC %s
// CHECK-LD-64-STATIC-LIBGCC-NOT: warning:
// CHECK-LD-64-STATIC-LIBGCC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-64-STATIC-LIBGCC: "--eh-frame-hdr"
// CHECK-LD-64-STATIC-LIBGCC: "-m" "elf_x86_64"
// CHECK-LD-64-STATIC-LIBGCC: "-dynamic-linker"
// CHECK-LD-64-STATIC-LIBGCC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-LD-64-STATIC-LIBGCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-LD-64-STATIC-LIBGCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-LD-64-STATIC-LIBGCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-LD-64-STATIC-LIBGCC: "-L[[SYSROOT]]/lib"
// CHECK-LD-64-STATIC-LIBGCC: "-L[[SYSROOT]]/usr/lib"
// CHECK-LD-64-STATIC-LIBGCC: "-lgcc" "-lgcc_eh"
// CHECK-LD-64-STATIC-LIBGCC: "-lc"
// CHECK-LD-64-STATIC-LIBGCC: "-lgcc" "-lgcc_eh"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -rtlib=platform \
// RUN: -static \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LD-64-STATIC %s
// CHECK-LD-64-STATIC-NOT: warning:
// CHECK-LD-64-STATIC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-64-STATIC-NOT: "--eh-frame-hdr"
// CHECK-LD-64-STATIC: "-m" "elf_x86_64"
// CHECK-LD-64-STATIC-NOT: "-dynamic-linker"
// CHECK-LD-64-STATIC: "-static"
// CHECK-LD-64-STATIC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbeginT.o"
// CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-LD-64-STATIC: "-L[[SYSROOT]]/lib"
// CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib"
// CHECK-LD-64-STATIC: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
//
// Check that flags can be combined. The -static dominates.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -rtlib=platform \
// RUN: -static-libgcc -static \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-LD-64-STATIC %s
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_32bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-32-TO-32 %s
// CHECK-32-TO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-32-TO-32: "{{.*}}/usr/lib/gcc/i386-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/lib/../lib32"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../lib32"
// CHECK-32-TO-32: "-L[[SYSROOT]]/lib/../lib32"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib/../lib32"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/lib"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../.."
// CHECK-32-TO-32: "-L[[SYSROOT]]/lib"
// CHECK-32-TO-32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m64 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_32bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-32-TO-64 %s
// CHECK-32-TO-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-32-TO-64: "{{.*}}/usr/lib/gcc/i386-unknown-linux/4.6.0/64{{/|\\\\}}crtbegin.o"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/64"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/lib/../lib64"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../lib64"
// CHECK-32-TO-64: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/../lib64"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../../../i386-unknown-linux/lib"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/i386-unknown-linux/4.6.0/../../.."
// CHECK-32-TO-64: "-L[[SYSROOT]]/lib"
// CHECK-32-TO-64: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -m64 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-64-TO-64 %s
// CHECK-64-TO-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-64-TO-64: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../lib64"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../lib64"
// CHECK-64-TO-64: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib/../lib64"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-64-TO-64: "-L[[SYSROOT]]/lib"
// CHECK-64-TO-64: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -m32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-64-TO-32 %s
// CHECK-64-TO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-64-TO-32: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32{{/|\\\\}}crtbegin.o"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../lib32"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../lib32"
// CHECK-64-TO-32: "-L[[SYSROOT]]/lib/../lib32"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/../lib32"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-64-TO-32: "-L[[SYSROOT]]/lib"
// CHECK-64-TO-32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnux32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-X32 %s
// CHECK-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-X32: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/x32{{/|\\\\}}crtbegin.o"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/x32"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../libx32"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../libx32"
// CHECK-X32: "-L[[SYSROOT]]/lib/../libx32"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/../libx32"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-X32: "-L[[SYSROOT]]/lib"
// CHECK-X32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -mx32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-64-TO-X32 %s
// CHECK-64-TO-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-64-TO-X32: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/x32{{/|\\\\}}crtbegin.o"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/x32"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../libx32"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../libx32"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/lib/../libx32"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/../libx32"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-64-TO-X32: "-L[[SYSROOT]]/lib"
// CHECK-64-TO-X32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -mx32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-32-TO-X32 %s
// CHECK-32-TO-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-32-TO-X32: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/x32{{/|\\\\}}crtbegin.o"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/x32"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../libx32"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../libx32"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/lib/../libx32"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/../libx32"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-32-TO-X32: "-L[[SYSROOT]]/lib"
// CHECK-32-TO-X32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnux32 -m64 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-X32-TO-64 %s
// CHECK-X32-TO-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-X32-TO-64: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../lib64"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../lib64"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/../lib64"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-X32-TO-64: "-L[[SYSROOT]]/lib"
// CHECK-X32-TO-64: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnux32 -m32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/multilib_64bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-X32-TO-32 %s
// CHECK-X32-TO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-X32-TO-32: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32{{/|\\\\}}crtbegin.o"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib/../lib32"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../lib32"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/lib/../lib32"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/../lib32"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
// CHECK-X32-TO-32: "-L[[SYSROOT]]/lib"
// CHECK-X32-TO-32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -m32 \
// RUN: --gcc-toolchain=%S/Inputs/multilib_64bit_linux_tree/usr \
// RUN: --sysroot=%S/Inputs/multilib_32bit_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-64-TO-32-SYSROOT %s
// CHECK-64-TO-32-SYSROOT: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-64-TO-32-SYSROOT: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32{{/|\\\\}}crtbegin.o"
// CHECK-64-TO-32-SYSROOT: "-L{{[^"]*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0/32"
// CHECK-64-TO-32-SYSROOT: "-L[[SYSROOT]]/lib/../lib32"
// CHECK-64-TO-32-SYSROOT: "-L[[SYSROOT]]/usr/lib/../lib32"
// CHECK-64-TO-32-SYSROOT: "-L{{[^"]*}}/Inputs/multilib_64bit_linux_tree/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
// CHECK-64-TO-32-SYSROOT: "-L[[SYSROOT]]/lib"
// CHECK-64-TO-32-SYSROOT: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: -ccc-install-dir %S/Inputs/fake_install_tree/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-INSTALL-DIR-32 %s
// CHECK-INSTALL-DIR-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-INSTALL-DIR-32: "{{.*}}/Inputs/fake_install_tree/bin/../lib/gcc/i386-unknown-linux/4.7.0{{/|\\\\}}crtbegin.o"
// CHECK-INSTALL-DIR-32: "-L{{.*}}/Inputs/fake_install_tree/bin/../lib/gcc/i386-unknown-linux/4.7.0"
//
// Check that with 64-bit builds, we don't actually use the install directory
// as its version of GCC is lower than our sysrooted version.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux -m64 \
// RUN: -ccc-install-dir %S/Inputs/fake_install_tree/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-INSTALL-DIR-64 %s
// CHECK-INSTALL-DIR-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-INSTALL-DIR-64: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"
// CHECK-INSTALL-DIR-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
//
// Check that we support unusual patch version formats, including missing that
// component.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing1/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION1 %s
// CHECK-GCC-VERSION1: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-GCC-VERSION1: "{{.*}}/Inputs/gcc_version_parsing1/bin/../lib/gcc/i386-unknown-linux/4.7{{/|\\\\}}crtbegin.o"
// CHECK-GCC-VERSION1: "-L{{.*}}/Inputs/gcc_version_parsing1/bin/../lib/gcc/i386-unknown-linux/4.7"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing2/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION2 %s
// CHECK-GCC-VERSION2: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-GCC-VERSION2: "{{.*}}/Inputs/gcc_version_parsing2/bin/../lib/gcc/i386-unknown-linux/4.7.x{{/|\\\\}}crtbegin.o"
// CHECK-GCC-VERSION2: "-L{{.*}}/Inputs/gcc_version_parsing2/bin/../lib/gcc/i386-unknown-linux/4.7.x"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing3/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION3 %s
// CHECK-GCC-VERSION3: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-GCC-VERSION3: "{{.*}}/Inputs/gcc_version_parsing3/bin/../lib/gcc/i386-unknown-linux/4.7.99-rc5{{/|\\\\}}crtbegin.o"
// CHECK-GCC-VERSION3: "-L{{.*}}/Inputs/gcc_version_parsing3/bin/../lib/gcc/i386-unknown-linux/4.7.99-rc5"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing4/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION4 %s
// CHECK-GCC-VERSION4: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-GCC-VERSION4: "{{.*}}/Inputs/gcc_version_parsing4/bin/../lib/gcc/i386-unknown-linux/4.7.99{{/|\\\\}}crtbegin.o"
// CHECK-GCC-VERSION4: "-L{{.*}}/Inputs/gcc_version_parsing4/bin/../lib/gcc/i386-unknown-linux/4.7.99"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux -m32 \
// RUN: -ccc-install-dir %S/Inputs/gcc_version_parsing5/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-GCC-VERSION5 %s
// CHECK-GCC-VERSION5: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-GCC-VERSION5: "{{.*}}/Inputs/gcc_version_parsing5/bin/../lib/gcc/i386-unknown-linux/5{{/|\\\\}}crtbegin.o"
// CHECK-GCC-VERSION5: "-L{{.*}}/Inputs/gcc_version_parsing5/bin/../lib/gcc/i386-unknown-linux/5"
//
// Test a simulated installation of libc++ on Linux, both through sysroot and
// the installation path of Clang.
// RUN: %clangxx -no-canonical-prefixes -x c++ %s -### -o %t.o 2>&1 \
// RUN: -target x86_64-unknown-linux-gnu \
// RUN: -stdlib=libc++ \
// RUN: -ccc-install-dir %S/Inputs/basic_linux_tree/usr/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \
// RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-SYSROOT %s
// CHECK-BASIC-LIBCXX-SYSROOT: "{{[^"]*}}clang{{[^"]*}}" "-cc1"
// CHECK-BASIC-LIBCXX-SYSROOT: "-isysroot" "[[SYSROOT:[^"]+]]"
// CHECK-BASIC-LIBCXX-SYSROOT: "-internal-isystem" "[[SYSROOT]]/usr/include/c++/v1"
// CHECK-BASIC-LIBCXX-SYSROOT: "-internal-isystem" "[[SYSROOT]]/usr/local/include"
// CHECK-BASIC-LIBCXX-SYSROOT: "--sysroot=[[SYSROOT]]"
// RUN: %clang -no-canonical-prefixes -x c++ %s -### -o %t.o 2>&1 \
// RUN: -target x86_64-unknown-linux-gnu \
// RUN: -stdlib=libc++ \
// RUN: -ccc-install-dir %S/Inputs/basic_linux_libcxx_tree/usr/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \
// RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-INSTALL %s
// CHECK-BASIC-LIBCXX-INSTALL: "{{[^"]*}}clang{{[^"]*}}" "-cc1"
// CHECK-BASIC-LIBCXX-INSTALL: "-isysroot" "[[SYSROOT:[^"]+]]"
// CHECK-BASIC-LIBCXX-INSTALL: "-internal-isystem" "[[SYSROOT]]/usr/bin/../include/c++/v1"
// CHECK-BASIC-LIBCXX-INSTALL: "-internal-isystem" "[[SYSROOT]]/usr/local/include"
// CHECK-BASIC-LIBCXX-INSTALL: "--sysroot=[[SYSROOT]]"
// CHECK-BASIC-LIBCXX-INSTALL: "-L[[SYSROOT]]/usr/bin/../lib"
//
// Test that we can use -stdlib=libc++ in a build system even when it
// occasionally links C code instead of C++ code.
// RUN: %clang -no-canonical-prefixes -x c %s -### -o %t.o 2>&1 \
// RUN: -target x86_64-unknown-linux-gnu \
// RUN: -stdlib=libc++ \
// RUN: -ccc-install-dir %S/Inputs/basic_linux_libcxx_tree/usr/bin \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_libcxx_tree \
// RUN: | FileCheck --check-prefix=CHECK-BASIC-LIBCXX-C-LINK %s
// CHECK-BASIC-LIBCXX-C-LINK-NOT: warning:
// CHECK-BASIC-LIBCXX-C-LINK: "{{[^"]*}}clang{{[^"]*}}" "-cc1"
// CHECK-BASIC-LIBCXX-C-LINK: "-isysroot" "[[SYSROOT:[^"]+]]"
// CHECK-BASIC-LIBCXX-C-LINK-NOT: "-internal-isystem" "[[SYSROOT]]/usr/bin/../include/c++/v1"
// CHECK-BASIC-LIBCXX-C-LINK: "-internal-isystem" "[[SYSROOT]]/usr/local/include"
// CHECK-BASIC-LIBCXX-C-LINK: "--sysroot=[[SYSROOT]]"
// CHECK-BASIC-LIBCXX-C-LINK: "-L[[SYSROOT]]/usr/bin/../lib"
//
// Test a very broken version of multiarch that shipped in Ubuntu 11.04.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i386-unknown-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/ubuntu_11.04_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBUNTU-11-04 %s
// CHECK-UBUNTU-11-04: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-UBUNTU-11-04: "{{.*}}/usr/lib/i386-linux-gnu/gcc/i686-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-UBUNTU-11-04: "-L[[SYSROOT]]/usr/lib/i386-linux-gnu/gcc/i686-linux-gnu/4.5"
// CHECK-UBUNTU-11-04: "-L[[SYSROOT]]/usr/lib/i386-linux-gnu/gcc/i686-linux-gnu/4.5/../../../../i386-linux-gnu"
// CHECK-UBUNTU-11-04: "-L[[SYSROOT]]/usr/lib/i386-linux-gnu"
// CHECK-UBUNTU-11-04: "-L[[SYSROOT]]/usr/lib/i386-linux-gnu/gcc/i686-linux-gnu/4.5/../../../.."
// CHECK-UBUNTU-11-04: "-L[[SYSROOT]]/lib"
// CHECK-UBUNTU-11-04: "-L[[SYSROOT]]/usr/lib"
//
// Check multi arch support on Ubuntu 12.04 LTS.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-unknown-linux-gnueabihf \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/ubuntu_12.04_LTS_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBUNTU-12-04-ARM-HF %s
// CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/../../../arm-linux-gnueabihf{{/|\\\\}}crt1.o"
// CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/../../../arm-linux-gnueabihf{{/|\\\\}}crti.o"
// CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}/usr/lib/gcc/arm-linux-gnueabihf/4.6.3{{/|\\\\}}crtbegin.o"
// CHECK-UBUNTU-12-04-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc/arm-linux-gnueabihf/4.6.3"
// CHECK-UBUNTU-12-04-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/../../../arm-linux-gnueabihf"
// CHECK-UBUNTU-12-04-ARM-HF: "-L[[SYSROOT]]/lib/arm-linux-gnueabihf"
// CHECK-UBUNTU-12-04-ARM-HF: "-L[[SYSROOT]]/usr/lib/arm-linux-gnueabihf"
// CHECK-UBUNTU-12-04-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/../../.."
// CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}/usr/lib/gcc/arm-linux-gnueabihf/4.6.3{{/|\\\\}}crtend.o"
// CHECK-UBUNTU-12-04-ARM-HF: "{{.*}}/usr/lib/gcc/arm-linux-gnueabihf/4.6.3/../../../arm-linux-gnueabihf{{/|\\\\}}crtn.o"
//
// Check Ubuntu 13.10 on x86-64 targeting arm-linux-gnueabihf.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-gnueabihf \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/x86-64_ubuntu_13.10 \
// RUN: | FileCheck --check-prefix=CHECK-X86-64-UBUNTU-13-10-ARM-HF %s
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "-dynamic-linker" "{{(/usr/arm--linux-gnueabihf)?}}/lib/ld-linux-armhf.so.3"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8/../../../../arm-linux-gnueabihf/lib/../lib{{/|\\\\}}crt1.o"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8/../../../../arm-linux-gnueabihf/lib/../lib{{/|\\\\}}crti.o"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8{{/|\\\\}}crtbegin.o"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8/../../../../arm-linux-gnueabihf/lib/../lib"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "-L[[SYSROOT]]/lib/../lib"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "-L[[SYSROOT]]/usr/lib/../lib"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8/../../../../arm-linux-gnueabihf/lib"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8{{/|\\\\}}crtend.o"
// CHECK-X86-64-UBUNTU-13-10-ARM-HF: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabihf/4.8/../../../../arm-linux-gnueabihf/lib/../lib{{/|\\\\}}crtn.o"
//
// Check Ubuntu 13.10 on x86-64 targeting arm-linux-gnueabi.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-gnueabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/x86-64_ubuntu_13.10 \
// RUN: | FileCheck --check-prefix=CHECK-X86-64-UBUNTU-13-10-ARM %s
// CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-X86-64-UBUNTU-13-10-ARM: "-dynamic-linker" "{{(/usr/arm--linux-gnueabi)?}}/lib/ld-linux.so.3"
// CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/../../../../arm-linux-gnueabi/lib/../lib{{/|\\\\}}crt1.o"
// CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/../../../../arm-linux-gnueabi/lib/../lib{{/|\\\\}}crti.o"
// CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabi/4.7{{/|\\\\}}crtbegin.o"
// CHECK-X86-64-UBUNTU-13-10-ARM: "-L[[SYSROOT]]/usr/lib/gcc-cross/arm-linux-gnueabi/4.7"
// CHECK-X86-64-UBUNTU-13-10-ARM: "-L[[SYSROOT]]/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/../../../../arm-linux-gnueabi/lib/../lib"
// CHECK-X86-64-UBUNTU-13-10-ARM: "-L[[SYSROOT]]/lib/../lib"
// CHECK-X86-64-UBUNTU-13-10-ARM: "-L[[SYSROOT]]/usr/lib/../lib"
// CHECK-X86-64-UBUNTU-13-10-ARM: "-L[[SYSROOT]]/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/../../../../arm-linux-gnueabi/lib"
// CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabi/4.7{{/|\\\\}}crtend.o"
// CHECK-X86-64-UBUNTU-13-10-ARM: "{{.*}}/usr/lib/gcc-cross/arm-linux-gnueabi/4.7/../../../../arm-linux-gnueabi/lib/../lib{{/|\\\\}}crtn.o"
//
// Check Ubuntu 14.04 on powerpc64le.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64le-unknown-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-PPC64LE %s
// CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.8/../../../powerpc64le-linux-gnu{{/|\\\\}}crt1.o"
// CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.8/../../../powerpc64le-linux-gnu{{/|\\\\}}crti.o"
// CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.8{{/|\\\\}}crtbegin.o"
// CHECK-UBUNTU-14-04-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.8"
// CHECK-UBUNTU-14-04-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.8/../../../powerpc64le-linux-gnu"
// CHECK-UBUNTU-14-04-PPC64LE: "-L[[SYSROOT]]/lib/powerpc64le-linux-gnu"
// CHECK-UBUNTU-14-04-PPC64LE: "-L[[SYSROOT]]/usr/lib/powerpc64le-linux-gnu"
// CHECK-UBUNTU-14-04-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.8/../../.."
// CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.8{{/|\\\\}}crtend.o"
// CHECK-UBUNTU-14-04-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.8/../../../powerpc64le-linux-gnu{{/|\\\\}}crtn.o"
//
// Check Ubuntu 14.04 on x32.
// "/usr/lib/gcc/x86_64-linux-gnu/4.8/x32/crtend.o" "/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../libx32/crtn.o"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnux32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/ubuntu_14.04_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBUNTU-14-04-X32 %s
// CHECK-UBUNTU-14-04-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-UBUNTU-14-04-X32: "{{.*}}/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../libx32{{/|\\\\}}crt1.o"
// CHECK-UBUNTU-14-04-X32: "{{.*}}/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../libx32{{/|\\\\}}crti.o"
// CHECK-UBUNTU-14-04-X32: "{{.*}}/usr/lib/gcc/x86_64-linux-gnu/4.8/x32{{/|\\\\}}crtbegin.o"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.8/x32"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../libx32"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/lib/../libx32"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/usr/lib/../libx32"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/usr/lib/x86_64-linux-gnu/../../libx32"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.8"
// CHECK-UBUNTU-14-04-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.8/../../.."
// CHECK-UBUNTU-14-04-X32: "{{.*}}/usr/lib/gcc/x86_64-linux-gnu/4.8/x32{{/|\\\\}}crtend.o"
// CHECK-UBUNTU-14-04-X32: "{{.*}}/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../libx32{{/|\\\\}}crtn.o"
//
// Check fedora 18 on arm.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armv7-unknown-linux-gnueabihf \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/fedora_18_tree \
// RUN: | FileCheck --check-prefix=CHECK-FEDORA-18-ARM-HF %s
// CHECK-FEDORA-18-ARM-HF: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-FEDORA-18-ARM-HF: "{{.*}}/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2/../../../../lib{{/|\\\\}}crt1.o"
// CHECK-FEDORA-18-ARM-HF: "{{.*}}/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2/../../../../lib{{/|\\\\}}crti.o"
// CHECK-FEDORA-18-ARM-HF: "{{.*}}/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2{{/|\\\\}}crtbegin.o"
// CHECK-FEDORA-18-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2"
// CHECK-FEDORA-18-ARM-HF: "-L[[SYSROOT]]/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2/../../../../lib"
// CHECK-FEDORA-18-ARM-HF: "{{.*}}/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2{{/|\\\\}}crtend.o"
// CHECK-FEDORA-18-ARM-HF: "{{.*}}/usr/lib/gcc/armv7hl-redhat-linux-gnueabi/4.7.2/../../../../lib{{/|\\\\}}crtn.o"
//
// Check Fedora 21 on AArch64.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-unknown-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/fedora_21_tree \
// RUN: | FileCheck --check-prefix=CHECK-FEDORA-21-AARCH64 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-unknown-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/fedora_21_tree \
// RUN: | FileCheck --check-prefix=CHECK-FEDORA-21-AARCH64 %s
// CHECK-FEDORA-21-AARCH64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-FEDORA-21-AARCH64: "{{.*}}/usr/lib/gcc/aarch64-redhat-linux/4.9.0/../../../../lib64{{/|\\\\}}crt1.o"
// CHECK-FEDORA-21-AARCH64: "{{.*}}/usr/lib/gcc/aarch64-redhat-linux/4.9.0/../../../../lib64{{/|\\\\}}crti.o"
// CHECK-FEDORA-21-AARCH64: "{{.*}}/usr/lib/gcc/aarch64-redhat-linux/4.9.0{{/|\\\\}}crtbegin.o"
// CHECK-FEDORA-21-AARCH64: "-L[[SYSROOT]]/usr/lib/gcc/aarch64-redhat-linux/4.9.0"
// CHECK-FEDORA-21-AARCH64: "-L[[SYSROOT]]/usr/lib/gcc/aarch64-redhat-linux/4.9.0/../../../../lib64"
// CHECK-FEDORA-21-AARCH64: "{{.*}}/usr/lib/gcc/aarch64-redhat-linux/4.9.0{{/|\\\\}}crtend.o"
// CHECK-FEDORA-21-AARCH64: "{{.*}}/usr/lib/gcc/aarch64-redhat-linux/4.9.0/../../../../lib64{{/|\\\\}}crtn.o"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-unknown-linux-gnueabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/ubuntu_12.04_LTS_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-UBUNTU-12-04-ARM %s
// CHECK-UBUNTU-12-04-ARM: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-UBUNTU-12-04-ARM: "{{.*}}/usr/lib/gcc/arm-linux-gnueabi/4.6.1/../../../arm-linux-gnueabi{{/|\\\\}}crt1.o"
// CHECK-UBUNTU-12-04-ARM: "{{.*}}/usr/lib/gcc/arm-linux-gnueabi/4.6.1/../../../arm-linux-gnueabi{{/|\\\\}}crti.o"
// CHECK-UBUNTU-12-04-ARM: "{{.*}}/usr/lib/gcc/arm-linux-gnueabi/4.6.1{{/|\\\\}}crtbegin.o"
// CHECK-UBUNTU-12-04-ARM: "-L[[SYSROOT]]/usr/lib/gcc/arm-linux-gnueabi/4.6.1"
// CHECK-UBUNTU-12-04-ARM: "-L[[SYSROOT]]/usr/lib/gcc/arm-linux-gnueabi/4.6.1/../../../arm-linux-gnueabi"
// CHECK-UBUNTU-12-04-ARM: "-L[[SYSROOT]]/lib/arm-linux-gnueabi"
// CHECK-UBUNTU-12-04-ARM: "-L[[SYSROOT]]/usr/lib/arm-linux-gnueabi"
// CHECK-UBUNTU-12-04-ARM: "-L[[SYSROOT]]/usr/lib/gcc/arm-linux-gnueabi/4.6.1/../../.."
// CHECK-UBUNTU-12-04-ARM: "{{.*}}/usr/lib/gcc/arm-linux-gnueabi/4.6.1{{/|\\\\}}crtend.o"
// CHECK-UBUNTU-12-04-ARM: "{{.*}}/usr/lib/gcc/arm-linux-gnueabi/4.6.1/../../../arm-linux-gnueabi{{/|\\\\}}crtn.o"
//
// Test the setup that shipped in SUSE 10.3 on ppc64.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-suse-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/suse_10.3_ppc64_tree \
// RUN: | FileCheck --check-prefix=CHECK-SUSE-10-3-PPC64 %s
// CHECK-SUSE-10-3-PPC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-SUSE-10-3-PPC64: "{{.*}}/usr/lib/gcc/powerpc64-suse-linux/4.1.2/64{{/|\\\\}}crtbegin.o"
// CHECK-SUSE-10-3-PPC64: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64-suse-linux/4.1.2/64"
// CHECK-SUSE-10-3-PPC64: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64-suse-linux/4.1.2/../../../../lib64"
// CHECK-SUSE-10-3-PPC64: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-SUSE-10-3-PPC64: "-L[[SYSROOT]]/usr/lib/../lib64"
//
// Check openSuse Leap 42.2 on AArch64
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-unknown-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/opensuse_42.2_aarch64_tree \
// RUN: | FileCheck --check-prefix=CHECK-OPENSUSE-42-2-AARCH64 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-unknown-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/opensuse_42.2_aarch64_tree \
// RUN: | FileCheck --check-prefix=CHECK-OPENSUSE-42-2-AARCH64 %s
// CHECK-OPENSUSE-42-2-AARCH64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-OPENSUSE-42-2-AARCH64: "{{.*}}/usr/lib64/gcc/aarch64-suse-linux/4.8/../../../../lib64{{/|\\\\}}crt1.o"
// CHECK-OPENSUSE-42-2-AARCH64: "{{.*}}/usr/lib64/gcc/aarch64-suse-linux/4.8/../../../../lib64{{/|\\\\}}crti.o"
// CHECK-OPENSUSE-42-2-AARCH64: "{{.*}}/usr/lib64/gcc/aarch64-suse-linux/4.8{{/|\\\\}}crtbegin.o"
// CHECK-OPENSUSE-42-2-AARCH64: "-L[[SYSROOT]]/usr/lib64/gcc/aarch64-suse-linux/4.8"
// CHECK-OPENSUSE-42-2-AARCH64: "-L[[SYSROOT]]/usr/lib64/gcc/aarch64-suse-linux/4.8/../../../../lib64"
// CHECK-OPENSUSE-42-2-AARCH64: "{{.*}}/usr/lib64/gcc/aarch64-suse-linux/4.8{{/|\\\\}}crtend.o"
// CHECK-OPENSUSE-42-2-AARCH64: "{{.*}}/usr/lib64/gcc/aarch64-suse-linux/4.8/../../../../lib64{{/|\\\\}}crtn.o"
//
// Check openSUSE Tumbleweed on armv6hl
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armv6hl-suse-linux-gnueabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/opensuse_tumbleweed_armv6hl_tree \
// RUN: | FileCheck --check-prefix=CHECK-OPENSUSE-TW-ARMV6HL %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armv6hl-suse-linux-gnueabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/opensuse_tumbleweed_armv6hl_tree \
// RUN: | FileCheck --check-prefix=CHECK-OPENSUSE-TW-ARMV6HL %s
// CHECK-OPENSUSE-TW-ARMV6HL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-OPENSUSE-TW-ARMV6HL: "{{.*}}/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5/../../../../lib{{/|\\\\}}crt1.o"
// CHECK-OPENSUSE-TW-ARMV6HL: "{{.*}}/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5/../../../../lib{{/|\\\\}}crti.o"
// CHECK-OPENSUSE-TW-ARMV6HL: "{{.*}}/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5{{/|\\\\}}crtbegin.o"
// CHECK-OPENSUSE-TW-ARMV6HL: "-L[[SYSROOT]]/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5"
// CHECK-OPENSUSE-TW-ARMV6HL: "-L[[SYSROOT]]/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5/../../../../lib"
// CHECK-OPENSUSE-TW-ARMV6HL: "{{.*}}/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5{{/|\\\\}}crtend.o"
// CHECK-OPENSUSE-TW-ARMV6HL: "{{.*}}/usr/lib/gcc/armv6hl-suse-linux-gnueabi/5/../../../../lib{{/|\\\\}}crtn.o"
//
// Check openSUSE Tumbleweed on armv7hl
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armv7hl-suse-linux-gnueabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/opensuse_tumbleweed_armv7hl_tree \
// RUN: | FileCheck --check-prefix=CHECK-OPENSUSE-TW-ARMV7HL %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armv7hl-suse-linux-gnueabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/opensuse_tumbleweed_armv7hl_tree \
// RUN: | FileCheck --check-prefix=CHECK-OPENSUSE-TW-ARMV7HL %s
// CHECK-OPENSUSE-TW-ARMV7HL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-OPENSUSE-TW-ARMV7HL: "{{.*}}/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5/../../../../lib{{/|\\\\}}crt1.o"
// CHECK-OPENSUSE-TW-ARMV7HL: "{{.*}}/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5/../../../../lib{{/|\\\\}}crti.o"
// CHECK-OPENSUSE-TW-ARMV7HL: "{{.*}}/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5{{/|\\\\}}crtbegin.o"
// CHECK-OPENSUSE-TW-ARMV7HL: "-L[[SYSROOT]]/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5"
// CHECK-OPENSUSE-TW-ARMV7HL: "-L[[SYSROOT]]/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5/../../../../lib"
// CHECK-OPENSUSE-TW-ARMV7HL: "{{.*}}/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5{{/|\\\\}}crtend.o"
// CHECK-OPENSUSE-TW-ARMV7HL: "{{.*}}/usr/lib/gcc/armv7hl-suse-linux-gnueabi/5/../../../../lib{{/|\\\\}}crtn.o"
//
// Check dynamic-linker for different archs
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-gnueabi \
// RUN: | FileCheck --check-prefix=CHECK-ARM %s
// CHECK-ARM: "{{.*}}ld{{(.exe)?}}"
// CHECK-ARM: "-m" "armelf_linux_eabi"
// CHECK-ARM: "-dynamic-linker" "{{.*}}/lib/ld-linux.so.3"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-gnueabi -mfloat-abi=hard \
// RUN: | FileCheck --check-prefix=CHECK-ARM-ABIHF %s
// CHECK-ARM-ABIHF: "{{.*}}ld{{(.exe)?}}"
// CHECK-ARM-ABIHF: "-m" "armelf_linux_eabi"
// CHECK-ARM-ABIHF: "-dynamic-linker" "{{.*}}/lib/ld-linux-armhf.so.3"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-gnueabihf \
// RUN: | FileCheck --check-prefix=CHECK-ARM-HF %s
// CHECK-ARM-HF: "{{.*}}ld{{(.exe)?}}"
// CHECK-ARM-HF: "-m" "armelf_linux_eabi"
// CHECK-ARM-HF: "-dynamic-linker" "{{.*}}/lib/ld-linux-armhf.so.3"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-PPC64 %s
// CHECK-PPC64: "{{.*}}ld{{(.exe)?}}"
// CHECK-PPC64: "-m" "elf64ppc"
// CHECK-PPC64: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld64.so.1"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-linux-gnu -mabi=elfv1 \
// RUN: | FileCheck --check-prefix=CHECK-PPC64-ELFv1 %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-linux-gnu -mabi=elfv1-qpx \
// RUN: | FileCheck --check-prefix=CHECK-PPC64-ELFv1 %s
// CHECK-PPC64-ELFv1: "{{.*}}ld{{(.exe)?}}"
// CHECK-PPC64-ELFv1: "-m" "elf64ppc"
// CHECK-PPC64-ELFv1: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld64.so.1"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-linux-gnu -mabi=elfv2 \
// RUN: | FileCheck --check-prefix=CHECK-PPC64-ELFv2 %s
// CHECK-PPC64-ELFv2: "{{.*}}ld{{(.exe)?}}"
// CHECK-PPC64-ELFv2: "-m" "elf64ppc"
// CHECK-PPC64-ELFv2: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld64.so.2"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64le-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-PPC64LE %s
// CHECK-PPC64LE: "{{.*}}ld{{(.exe)?}}"
// CHECK-PPC64LE: "-m" "elf64lppc"
// CHECK-PPC64LE: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld64.so.2"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64le-linux-gnu -mabi=elfv1 \
// RUN: | FileCheck --check-prefix=CHECK-PPC64LE-ELFv1 %s
// CHECK-PPC64LE-ELFv1: "{{.*}}ld{{(.exe)?}}"
// CHECK-PPC64LE-ELFv1: "-m" "elf64lppc"
// CHECK-PPC64LE-ELFv1: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld64.so.1"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64le-linux-gnu -mabi=elfv2 \
// RUN: | FileCheck --check-prefix=CHECK-PPC64LE-ELFv2 %s
// CHECK-PPC64LE-ELFv2: "{{.*}}ld{{(.exe)?}}"
// CHECK-PPC64LE-ELFv2: "-m" "elf64lppc"
// CHECK-PPC64LE-ELFv2: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld64.so.2"
//
// Check that we do not pass --hash-style=gnu or --hash-style=both to
// hexagon linux linker
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=hexagon-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-HEXAGON %s
// CHECK-HEXAGON: "{{.*}}hexagon-link{{(.exe)?}}"
// CHECK-HEXAGON-NOT: "--hash-style={{gnu|both}}"
//
// Check that we do not pass --hash-style=gnu and --hash-style=both to linker
// and provide correct path to the dynamic linker and emulation mode when build
// for MIPS platforms.
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-MIPS %s
// CHECK-MIPS: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS: "-m" "elf32btsmip"
// CHECK-MIPS: "-dynamic-linker" "{{.*}}/lib/ld.so.1"
// CHECK-MIPS-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-MIPSEL %s
// CHECK-MIPSEL: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPSEL: "-m" "elf32ltsmip"
// CHECK-MIPSEL: "-dynamic-linker" "{{.*}}/lib/ld.so.1"
// CHECK-MIPSEL-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 --target=mipsel-linux-gnu -mnan=2008 \
// RUN: | FileCheck --check-prefix=CHECK-MIPSEL-NAN2008 %s
// CHECK-MIPSEL-NAN2008: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPSEL-NAN2008: "-m" "elf32ltsmip"
// CHECK-MIPSEL-NAN2008: "-dynamic-linker" "{{.*}}/lib/ld-linux-mipsn8.so.1"
// CHECK-MIPSEL-NAN2008-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 --target=mipsel-linux-gnu -mcpu=mips32r6 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS32R6EL %s
// CHECK-MIPS32R6EL: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS32R6EL: "-m" "elf32ltsmip"
// CHECK-MIPS32R6EL: "-dynamic-linker" "{{.*}}/lib/ld-linux-mipsn8.so.1"
// CHECK-MIPS32R6EL-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips64-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64 %s
// CHECK-MIPS64: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64: "-m" "elf64btsmip"
// CHECK-MIPS64: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld.so.1"
// CHECK-MIPS64-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64EL %s
// CHECK-MIPS64EL: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64EL: "-m" "elf64ltsmip"
// CHECK-MIPS64EL: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld.so.1"
// CHECK-MIPS64EL-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 --target=mips64el-linux-gnu -mnan=2008 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64EL-NAN2008 %s
// CHECK-MIPS64EL-NAN2008: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64EL-NAN2008: "-m" "elf64ltsmip"
// CHECK-MIPS64EL-NAN2008: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld-linux-mipsn8.so.1"
// CHECK-MIPS64EL-NAN2008-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 --target=mips64el-linux-gnu -mcpu=mips64r6 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64R6EL %s
// CHECK-MIPS64R6EL: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64R6EL: "-m" "elf64ltsmip"
// CHECK-MIPS64R6EL: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld-linux-mipsn8.so.1"
// CHECK-MIPS64R6EL-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips64-linux-gnu -mabi=n32 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64-N32 %s
// CHECK-MIPS64-N32: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64-N32: "-m" "elf32btsmipn32"
// CHECK-MIPS64-N32: "-dynamic-linker" "{{.*}}/lib{{(32)?}}/ld.so.1"
// CHECK-MIPS64-N32-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnu -mabi=n32 \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64EL-N32 %s
// CHECK-MIPS64EL-N32: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64EL-N32: "-m" "elf32ltsmipn32"
// CHECK-MIPS64EL-N32: "-dynamic-linker" "{{.*}}/lib{{(32)?}}/ld.so.1"
// CHECK-MIPS64EL-N32-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 --target=mips64el-linux-gnu -mabi=n32 \
// RUN: -mnan=2008 | FileCheck --check-prefix=CHECK-MIPS64EL-N32-NAN2008 %s
// CHECK-MIPS64EL-N32-NAN2008: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64EL-N32-NAN2008: "-m" "elf32ltsmipn32"
// CHECK-MIPS64EL-N32-NAN2008: "-dynamic-linker" "{{.*}}/lib{{(32)?}}/ld-linux-mipsn8.so.1"
// CHECK-MIPS64EL-N32-NAN2008-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 --target=mips64el-redhat-linux \
// RUN: | FileCheck --check-prefix=CHECK-MIPS64EL-REDHAT %s
// CHECK-MIPS64EL-REDHAT: "{{.*}}ld{{(.exe)?}}"
// CHECK-MIPS64EL-REDHAT: "-m" "elf64ltsmip"
// CHECK-MIPS64EL-REDHAT: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld.so.1"
// CHECK-MIPS64EL-REDHAT-NOT: "-dynamic-linker" "{{.*}}/lib{{(64)?}}/ld-musl-mipsel.so.1"
// CHECK-MIPS64EL-REDHAT-NOT: "--hash-style={{gnu|both}}"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=sparc-unknown-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-SPARCV8 %s
// CHECK-SPARCV8: "{{.*}}ld{{(.exe)?}}"
// CHECK-SPARCV8: "-m" "elf32_sparc"
// CHECK-SPARCV8: "-dynamic-linker" "{{(/usr/sparc-unknown-linux-gnu)?}}/lib/ld-linux.so.2"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=sparcel-unknown-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-SPARCV8EL %s
// CHECK-SPARCV8EL: "{{.*}}ld{{(.exe)?}}"
// CHECK-SPARCV8EL: "-m" "elf32_sparc"
// CHECK-SPARCV8EL: "-dynamic-linker" "{{(/usr/sparcel-unknown-linux-gnu)?}}/lib/ld-linux.so.2"
//
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=sparcv9-unknown-linux-gnu \
// RUN: | FileCheck --check-prefix=CHECK-SPARCV9 %s
// CHECK-SPARCV9: "{{.*}}ld{{(.exe)?}}"
// CHECK-SPARCV9: "-m" "elf64_sparc"
// CHECK-SPARCV9: "-dynamic-linker" "{{(/usr/sparcv9-unknown-linux-gnu)?}}/lib{{(64)?}}/ld-linux.so.2"
//
// Thoroughly exercise the Debian multiarch environment.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-X86 %s
// CHECK-DEBIAN-X86: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-X86: "{{.*}}/usr/lib/gcc/i686-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-X86: "-L[[SYSROOT]]/usr/lib/gcc/i686-linux-gnu/4.5"
// CHECK-DEBIAN-X86: "-L[[SYSROOT]]/usr/lib/gcc/i686-linux-gnu/4.5/../../../i386-linux-gnu"
// CHECK-DEBIAN-X86: "-L[[SYSROOT]]/usr/lib/i386-linux-gnu"
// CHECK-DEBIAN-X86: "-L[[SYSROOT]]/usr/lib/gcc/i686-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-X86: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-X86: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-X86-64 %s
// CHECK-DEBIAN-X86-64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-X86-64: "{{.*}}/usr/lib/gcc/x86_64-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.5"
// CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.5/../../../x86_64-linux-gnu"
// CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/usr/lib/x86_64-linux-gnu"
// CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-X86-64: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC %s
// CHECK-DEBIAN-PPC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-PPC: "{{.*}}/usr/lib/gcc/powerpc-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib/gcc/powerpc-linux-gnu/4.5"
// CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib/gcc/powerpc-linux-gnu/4.5/../../../powerpc-linux-gnu"
// CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib/powerpc-linux-gnu"
// CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib/gcc/powerpc-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-PPC: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64le-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC64LE %s
// CHECK-DEBIAN-PPC64LE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-PPC64LE: "{{.*}}/usr/lib/gcc/powerpc64le-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.5"
// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.5/../../../powerpc64le-linux-gnu"
// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/powerpc64le-linux-gnu"
// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64le-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-PPC64LE: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-PPC64 %s
// CHECK-DEBIAN-PPC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-PPC64: "{{.*}}/usr/lib/gcc/powerpc64-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64-linux-gnu/4.5"
// CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64-linux-gnu/4.5/../../../powerpc64-linux-gnu"
// CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/usr/lib/powerpc64-linux-gnu"
// CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/usr/lib/gcc/powerpc64-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-PPC64: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS %s
// CHECK-DEBIAN-MIPS: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-MIPS: "{{.*}}/usr/lib/gcc/mips-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5"
// CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5/../../../mips-linux-gnu"
// CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/usr/lib/mips-linux-gnu"
// CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-MIPS: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPSEL %s
// CHECK-DEBIAN-MIPSEL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-MIPSEL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.5{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5"
// CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5/../../../mipsel-linux-gnu"
// CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/usr/lib/mipsel-linux-gnu"
// CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-MIPSEL: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64 %s
// CHECK-DEBIAN-MIPS64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-MIPS64: "{{.*}}/usr/lib/gcc/mips-linux-gnu/4.5/64{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-MIPS64: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5/64"
// CHECK-DEBIAN-MIPS64: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5"
// CHECK-DEBIAN-MIPS64: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-MIPS64: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-MIPS64: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64EL %s
// CHECK-DEBIAN-MIPS64EL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-MIPS64EL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.5/64{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-MIPS64EL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5/64"
// CHECK-DEBIAN-MIPS64EL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5"
// CHECK-DEBIAN-MIPS64EL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-MIPS64EL: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-MIPS64EL: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64-linux-gnu -mabi=n32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64-N32 %s
// CHECK-DEBIAN-MIPS64-N32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-MIPS64-N32: "{{.*}}/usr/lib/gcc/mips-linux-gnu/4.5/n32{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-MIPS64-N32: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5/n32"
// CHECK-DEBIAN-MIPS64-N32: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5"
// CHECK-DEBIAN-MIPS64-N32: "-L[[SYSROOT]]/usr/lib/gcc/mips-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-MIPS64-N32: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-MIPS64-N32: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnu -mabi=n32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_multiarch_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-MIPS64EL-N32 %s
// CHECK-DEBIAN-MIPS64EL-N32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-MIPS64EL-N32: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.5/n32{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5/n32"
// CHECK-DEBIAN-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5"
// CHECK-DEBIAN-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.5/../../.."
// CHECK-DEBIAN-MIPS64EL-N32: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib"
//
// Check linker paths on Debian 8 / Sparc
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=sparc-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_8_sparc_multilib_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-SPARC32 %s
// CHECK-DEBIAN-SPARC32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-SPARC32: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../sparc-linux-gnu{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-SPARC32: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../sparc-linux-gnu{{/|\\\\}}crti.o"
// CHECK-DEBIAN-SPARC32: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../sparc-linux-gnu"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../../lib"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/lib/sparc-linux-gnu"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/usr/lib/sparc-linux-gnu"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-SPARC32: "-L[[SYSROOT]]/usr/lib"
// CHECK-DEBIAN-SPARC32: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9{{/|\\\\}}crtend.o"
// CHECK-DEBIAN-SPARC32: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../sparc-linux-gnu{{/|\\\\}}crtn.o"
//
// Check linker paths on Debian 8 / Sparc, with the oldstyle multilib packages
// RUN: %clang -no-canonical-prefixes -m64 %s -### -o %t.o 2>&1 \
// RUN: --target=sparc-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_8_sparc_multilib_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-SPARC32-LIB64 %s
// CHECK-DEBIAN-SPARC32-LIB64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-SPARC32-LIB64: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../../lib64{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-SPARC32-LIB64: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../../lib64{{/|\\\\}}crti.o"
// CHECK-DEBIAN-SPARC32-LIB64: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/64{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/64"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../../lib64"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/usr/lib/../lib64"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-SPARC32-LIB64: "-L[[SYSROOT]]/usr/lib"
// CHECK-DEBIAN-SPARC32-LIB64: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/64{{/|\\\\}}crtend.o"
// CHECK-DEBIAN-SPARC32-LIB64: "[[SYSROOT]]/usr/lib/gcc/sparc-linux-gnu/4.9/../../../../lib64{{/|\\\\}}crtn.o"
//
// Check linker paths on Debian 8 / Sparc64
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=sparc64-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_8_sparc64_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-SPARC64 %s
// CHECK-DEBIAN-SPARC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-SPARC64: "[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9/../../../sparc64-linux-gnu{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-SPARC64: "[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9/../../../sparc64-linux-gnu{{/|\\\\}}crti.o"
// CHECK-DEBIAN-SPARC64: "[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9/../../../sparc64-linux-gnu"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/lib/sparc64-linux-gnu"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/usr/lib/sparc64-linux-gnu"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9/../../.."
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-SPARC64: "-L[[SYSROOT]]/usr/lib"
// CHECK-DEBIAN-SPARC64: "[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9{{/|\\\\}}crtend.o"
// CHECK-DEBIAN-SPARC64: "[[SYSROOT]]/usr/lib/gcc/sparc64-linux-gnu/4.9/../../../sparc64-linux-gnu{{/|\\\\}}crtn.o"
//
// Test linker invocation on Android.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID %s
// CHECK-ANDROID: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ANDROID: "{{.*}}{{/|\\\\}}crtbegin_dynamic.o"
// CHECK-ANDROID: "-L[[SYSROOT]]/usr/lib"
// CHECK-ANDROID-NOT: "gcc_s"
// CHECK-ANDROID: "-lgcc"
// CHECK-ANDROID: "-ldl"
// CHECK-ANDROID-NOT: "gcc_s"
// CHECK-ANDROID: "{{.*}}{{/|\\\\}}crtend_android.o"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android -rtlib=platform \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-SO %s
// CHECK-ANDROID-SO: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ANDROID-SO-NOT: "-Bsymbolic"
// CHECK-ANDROID-SO: "{{.*}}{{/|\\\\}}crtbegin_so.o"
// CHECK-ANDROID-SO: "-L[[SYSROOT]]/usr/lib"
// CHECK-ANDROID-SO-NOT: "gcc_s"
// CHECK-ANDROID-SO: "-lgcc"
// CHECK-ANDROID-SO: "-ldl"
// CHECK-ANDROID-SO-NOT: "gcc_s"
// CHECK-ANDROID-SO: "{{.*}}{{/|\\\\}}crtend_so.o"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android -rtlib=platform \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android -rtlib=platform \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -static \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-STATIC %s
// CHECK-ANDROID-STATIC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ANDROID-STATIC: "{{.*}}{{/|\\\\}}crtbegin_static.o"
// CHECK-ANDROID-STATIC: "-L[[SYSROOT]]/usr/lib"
// CHECK-ANDROID-STATIC-NOT: "gcc_s"
// CHECK-ANDROID-STATIC: "-lgcc"
// CHECK-ANDROID-STATIC-NOT: "-ldl"
// CHECK-ANDROID-STATIC-NOT: "gcc_s"
// CHECK-ANDROID-STATIC: "{{.*}}{{/|\\\\}}crtend_android.o"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android -rtlib=platform \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -pie \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PIE %s
// CHECK-ANDROID-PIE: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ANDROID-PIE: "{{.*}}{{/|\\\\}}crtbegin_dynamic.o"
// CHECK-ANDROID-PIE: "-L[[SYSROOT]]/usr/lib"
// CHECK-ANDROID-PIE-NOT: "gcc_s"
// CHECK-ANDROID-PIE: "-lgcc"
// CHECK-ANDROID-PIE-NOT: "gcc_s"
// CHECK-ANDROID-PIE: "{{.*}}{{/|\\\\}}crtend_android.o"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-NO-DEFAULT-PIE %s
// CHECK-ANDROID-NO-DEFAULT-PIE-NOT: -pie
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-32 %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-64 %s
// CHECK-ANDROID-32: "-dynamic-linker" "/system/bin/linker"
// CHECK-ANDROID-64: "-dynamic-linker" "/system/bin/linker64"
//
// Test that -pthread does not add -lpthread on Android.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android -pthread \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-androideabi -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=arm64-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-linux-android -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: -shared \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD %s
// CHECK-ANDROID-PTHREAD-NOT: -lpthread
//
// RUN: %clang -no-canonical-prefixes %t.o -### -o %t 2>&1 \
// RUN: --target=arm-linux-androideabi -pthread \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_android_tree/sysroot \
// RUN: | FileCheck --check-prefix=CHECK-ANDROID-PTHREAD-LINK %s
// CHECK-ANDROID-PTHREAD-LINK-NOT: argument unused during compilation: '-pthread'
//
// Check linker invocation on Debian 6 MIPS 32/64-bit.
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_6_mips_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPSEL %s
// CHECK-DEBIAN-ML-MIPSEL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-ML-MIPSEL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-ML-MIPSEL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib{{/|\\\\}}crti.o"
// CHECK-DEBIAN-ML-MIPSEL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4"
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib"
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/lib/../lib"
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/usr/lib/../lib"
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/../../.."
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-ML-MIPSEL: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnu \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_6_mips_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64EL %s
// CHECK-DEBIAN-ML-MIPS64EL: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-ML-MIPS64EL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib64{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-ML-MIPS64EL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib64{{/|\\\\}}crti.o"
// CHECK-DEBIAN-ML-MIPS64EL: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/64{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/64"
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib64"
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/lib/../lib64"
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/usr/lib/../lib64"
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/../../.."
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-ML-MIPS64EL: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnu -mabi=n32 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_6_mips_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64EL-N32 %s
// CHECK-DEBIAN-ML-MIPS64EL-N32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib32{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib32{{/|\\\\}}crti.o"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "{{.*}}/usr/lib/gcc/mipsel-linux-gnu/4.4/n32{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/n32"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/../../../../lib32"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/lib/../lib32"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/../lib32"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib/gcc/mipsel-linux-gnu/4.4/../../.."
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-ML-MIPS64EL-N32: "-L[[SYSROOT]]/usr/lib"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64-linux-gnuabi64 -mabi=n64 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_6_mips64_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64-GNUABI %s
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}/usr/lib/gcc/mips64-linux-gnuabi64/4.9/../../../mips64-linux-gnuabi64{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}/usr/lib/gcc/mips64-linux-gnuabi64/4.9/../../../mips64-linux-gnuabi64{{/|\\\\}}crti.o"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}/usr/lib/gcc/mips64-linux-gnuabi64/4.9{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64-linux-gnuabi64/4.9"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64-linux-gnuabi64/4.9/../../../mips64-linux-gnuabi64"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/lib/mips64-linux-gnuabi64"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/usr/lib/mips64-linux-gnuabi64"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64-linux-gnuabi64/4.9"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64-linux-gnuabi64/4.9/../../.."
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "-L[[SYSROOT]]/usr/lib"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}/usr/lib/gcc/mips64-linux-gnuabi64/4.9{{/|\\\\}}crtend.o"
// CHECK-DEBIAN-ML-MIPS64-GNUABI: "{{.*}}/usr/lib/gcc/mips64-linux-gnuabi64/4.9/../../../mips64-linux-gnuabi64{{/|\\\\}}crtn.o"
//
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-linux-gnuabi64 -mabi=n64 \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/debian_6_mips64_tree \
// RUN: | FileCheck --check-prefix=CHECK-DEBIAN-ML-MIPS64EL-GNUABI %s
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}/usr/lib/gcc/mips64el-linux-gnuabi64/4.9/../../../mips64el-linux-gnuabi64{{/|\\\\}}crt1.o"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}/usr/lib/gcc/mips64el-linux-gnuabi64/4.9/../../../mips64el-linux-gnuabi64{{/|\\\\}}crti.o"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}/usr/lib/gcc/mips64el-linux-gnuabi64/4.9{{/|\\\\}}crtbegin.o"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64el-linux-gnuabi64/4.9"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64el-linux-gnuabi64/4.9/../../../mips64el-linux-gnuabi64"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/lib/mips64el-linux-gnuabi64"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/usr/lib/mips64el-linux-gnuabi64"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64el-linux-gnuabi64/4.9"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/usr/lib/gcc/mips64el-linux-gnuabi64/4.9/../../.."
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/lib"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "-L[[SYSROOT]]/usr/lib"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}/usr/lib/gcc/mips64el-linux-gnuabi64/4.9{{/|\\\\}}crtend.o"
// CHECK-DEBIAN-ML-MIPS64EL-GNUABI: "{{.*}}/usr/lib/gcc/mips64el-linux-gnuabi64/4.9/../../../mips64el-linux-gnuabi64{{/|\\\\}}crtn.o"
//
// Test linker invocation for Freescale SDK (OpenEmbedded).
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc-fsl-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/freescale_ppc_tree \
// RUN: | FileCheck --check-prefix=CHECK-FSL-PPC %s
// CHECK-FSL-PPC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-FSL-PPC: "-m" "elf32ppclinux"
// CHECK-FSL-PPC: "{{.*}}{{/|\\\\}}crt1.o"
// CHECK-FSL-PPC: "{{.*}}{{/|\\\\}}crtbegin.o"
// CHECK-FSL-PPC: "-L[[SYSROOT]]/usr/lib"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-fsl-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/freescale_ppc64_tree \
// RUN: | FileCheck --check-prefix=CHECK-FSL-PPC64 %s
// CHECK-FSL-PPC64: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-FSL-PPC64: "-m" "elf64ppc"
// CHECK-FSL-PPC64: "{{.*}}{{/|\\\\}}crt1.o"
// CHECK-FSL-PPC64: "{{.*}}{{/|\\\\}}crtbegin.o"
// CHECK-FSL-PPC64: "-L[[SYSROOT]]/usr/lib64/powerpc64-fsl-linux/4.6.2/../.."
//
// Check that crtfastmath.o is linked with -ffast-math and with -Ofast.
// RUN: %clang --target=x86_64-unknown-linux -### %s \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -ffast-math \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -funsafe-math-optimizations\
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast\
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast -O3\
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -O3 -Ofast\
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -ffast-math -fno-fast-math \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast -fno-fast-math \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -Ofast -fno-unsafe-math-optimizations \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -fno-fast-math -Ofast \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// RUN: %clang --target=x86_64-unknown-linux -### %s -fno-unsafe-math-optimizations -Ofast \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-CRTFASTMATH %s
// We don't have crtfastmath.o in the i386 tree, use it to check that file
// detection works.
// RUN: %clang --target=i386-unknown-linux -### %s -ffast-math \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
// RUN: | FileCheck --check-prefix=CHECK-NOCRTFASTMATH %s
// CHECK-CRTFASTMATH: usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtfastmath.o
// CHECK-NOCRTFASTMATH-NOT: crtfastmath.o
// Check that we link in gcrt1.o when compiling with -pg
// RUN: %clang -pg --target=x86_64-unknown-linux -### %s \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>& 1 \
// RUN: | FileCheck --check-prefix=CHECK-PG %s
// CHECK-PG: gcrt1.o
// GCC forwards -u to the linker.
// RUN: %clang -u asdf --target=x86_64-unknown-linux -### %s \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree 2>& 1 \
// RUN: | FileCheck --check-prefix=CHECK-u %s
// CHECK-u: "-u" "asdf"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armeb-unknown-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-ARMEB %s
// CHECK-ARMEB: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ARMEB-NOT: "--be8"
// CHECK-ARMEB: "-m" "armelfb_linux_eabi"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=armebv7-unknown-linux \
// RUN: --gcc-toolchain="" \
// RUN: --sysroot=%S/Inputs/basic_linux_tree \
// RUN: | FileCheck --check-prefix=CHECK-ARMV7EB %s
// CHECK-ARMV7EB: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-ARMV7EB: "--be8"
// CHECK-ARMV7EB: "-m" "armelfb_linux_eabi"
// Check dynamic-linker for musl-libc
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=i386-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-X86 %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-X86_64 %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-MIPS %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mipsel-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-MIPSEL %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips64-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-MIPS64 %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=mips64el-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-MIPS64EL %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-PPC %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=powerpc64-pc-linux-musl \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-PPC64 %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=thumb-pc-linux-musleabi \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARM %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=thumb-pc-linux-musleabihf \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=thumbv7-pc-linux-musleabi -mhard-float \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=thumbeb-pc-linux-musleabi \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMEB %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=thumbeb-pc-linux-musleabihf \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMEBHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=thumbv7eb-pc-linux-musleabi -mhard-float \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMEBHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=arm-pc-linux-musleabi \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARM %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=arm-pc-linux-musleabihf \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=armv7-pc-linux-musleabi -mhard-float \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=armeb-pc-linux-musleabi \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMEB %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=armeb-pc-linux-musleabihf \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMEBHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=armv7eb-pc-linux-musleabi -mhard-float \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-ARMEBHF %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64-pc-linux-musleabi \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-AARCH64 %s
// RUN: %clang %s -### -o %t.o 2>&1 \
// RUN: --target=aarch64_be-pc-linux-musleabi \
// RUN: | FileCheck --check-prefix=CHECK-MUSL-AARCH64_BE %s
// CHECK-MUSL-X86: "-dynamic-linker" "/lib/ld-musl-i386.so.1"
// CHECK-MUSL-X86_64: "-dynamic-linker" "/lib/ld-musl-x86_64.so.1"
// CHECK-MUSL-MIPS: "-dynamic-linker" "/lib/ld-musl-mips.so.1"
// CHECK-MUSL-MIPSEL: "-dynamic-linker" "/lib/ld-musl-mipsel.so.1"
// CHECK-MUSL-MIPS64: "-dynamic-linker" "/lib/ld-musl-mips64.so.1"
// CHECK-MUSL-MIPS64EL: "-dynamic-linker" "/lib/ld-musl-mips64el.so.1"
// CHECK-MUSL-PPC: "-dynamic-linker" "/lib/ld-musl-powerpc.so.1"
// CHECK-MUSL-PPC64: "-dynamic-linker" "/lib/ld-musl-powerpc64.so.1"
// CHECK-MUSL-ARM: "-dynamic-linker" "/lib/ld-musl-arm.so.1"
// CHECK-MUSL-ARMHF: "-dynamic-linker" "/lib/ld-musl-armhf.so.1"
// CHECK-MUSL-ARMEB: "-dynamic-linker" "/lib/ld-musl-armeb.so.1"
// CHECK-MUSL-ARMEBHF: "-dynamic-linker" "/lib/ld-musl-armebhf.so.1"
// CHECK-MUSL-AARCH64: "-dynamic-linker" "/lib/ld-musl-aarch64.so.1"
// CHECK-MUSL-AARCH64_BE: "-dynamic-linker" "/lib/ld-musl-aarch64_be.so.1"
// Check whether multilib gcc install works fine on Gentoo with gcc-config
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnu -rtlib=platform \
// RUN: --sysroot=%S/Inputs/gentoo_linux_gcc_multi_version_tree \
// RUN: --gcc-toolchain="" \
// RUN: | FileCheck --check-prefix=CHECK-LD-GENTOO %s
// CHECK-LD-GENTOO-NOT: warning:
// CHECK-LD-GENTOO: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-GENTOO: "--eh-frame-hdr"
// CHECK-LD-GENTOO: "-m" "elf_x86_64"
// CHECK-LD-GENTOO: "-dynamic-linker"
// CHECK-LD-GENTOO: "{{.*}}/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3{{/|\\\\}}crtbegin.o"
// CHECK-LD-GENTOO: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3"
// CHECK-LD-GENTOO: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/../../../../x86_64-pc-linux-gnu/lib"
// CHECK-LD-GENTOO: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/../../.."
// CHECK-LD-GENTOO: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// CHECK-LD-GENTOO: "-lc"
// CHECK-LD-GENTOO: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=i686-unknown-linux-gnu -rtlib=platform \
// RUN: --sysroot=%S/Inputs/gentoo_linux_gcc_multi_version_tree \
// RUN: --gcc-toolchain="" \
// RUN: | FileCheck --check-prefix=CHECK-LD-GENTOO-32 %s
// CHECK-LD-GENTOO-32-NOT: warning:
// CHECK-LD-GENTOO-32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-GENTOO-32: "--eh-frame-hdr"
// CHECK-LD-GENTOO-32: "-m" "elf_i386"
// CHECK-LD-GENTOO-32: "-dynamic-linker"
// CHECK-LD-GENTOO-32: "{{.*}}/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/32{{/|\\\\}}crtbegin.o"
// CHECK-LD-GENTOO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/32"
// CHECK-LD-GENTOO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/../../../../x86_64-pc-linux-gnu/lib"
// CHECK-LD-GENTOO-32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/../../.."
// CHECK-LD-GENTOO-32: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// CHECK-LD-GENTOO-32: "-lc"
// CHECK-LD-GENTOO-32: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
// RUN: --target=x86_64-unknown-linux-gnux32 -rtlib=platform \
// RUN: --sysroot=%S/Inputs/gentoo_linux_gcc_multi_version_tree \
// RUN: --gcc-toolchain="" \
// RUN: | FileCheck --check-prefix=CHECK-LD-GENTOO-X32 %s
// CHECK-LD-GENTOO-X32-NOT: warning:
// CHECK-LD-GENTOO-X32: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
// CHECK-LD-GENTOO-X32: "--eh-frame-hdr"
// CHECK-LD-GENTOO-X32: "-m" "elf32_x86_64"
// CHECK-LD-GENTOO-X32: "-dynamic-linker"
// CHECK-LD-GENTOO-X32: "{{.*}}/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/x32{{/|\\\\}}crtbegin.o"
// CHECK-LD-GENTOO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/x32"
// CHECK-LD-GENTOO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/../../../../x86_64-pc-linux-gnu/lib"
// CHECK-LD-GENTOO-X32: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-pc-linux-gnu/4.9.3/../../.."
// CHECK-LD-GENTOO-X32: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
// CHECK-LD-GENTOO-X32: "-lc"
// CHECK-LD-GENTOO-X32: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
|
the_stack_data/220456377.c | int main() {
char t[] = "asdf";
return "asdf" == t;
}
|
the_stack_data/588983.c | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
char grid_coordinates[2];
/* Takes in two lists and their size. Compares the first <size> elements
* Returns 1/0 for True/False
*/
char compare_lists(char a[], char b[], char size) {
for (char i = 0; i < size; i++)
{
if (a[i] != b[i]) {
return 0;
}
}
return 1;
}
void compare_lists_test() {
char x[] = {1,2,3};
char y[] = {1,2,3};
char z[] = {3,2,1};
assert(compare_lists(x, y, 3));
assert(!compare_lists(z, y, 3));
}
/* Takes in a position on the grid (global cell number) and
* converts it into cartesian coordinates (both 0-indexed)
* RETURNS: List[x, y]
*/
char* get_coordinates(char position) {
grid_coordinates[0] = position % 9;
grid_coordinates[1] = position / 9;
return grid_coordinates;
}
void get_cooridinates_test() {
assert(get_coordinates(80)[0] == 8);
assert(get_coordinates(80)[1] == 8);
assert(get_coordinates(79)[0] == 7);
assert(get_coordinates(79)[1] == 8);
}
/* Takes a list of allowed numbers and removes any new illegal numbers it finds
* in the same row as <position>. Modifes list in-place
*/
void check_row(char allowed[], char sudoku[][9], char position) {
char row = get_coordinates(position)[1];
for (char i = 0; i < 9; i++)
{
if (sudoku[row][i])
{
allowed[sudoku[row][i]-1] = 0;
}
}
}
void check_row_test() {
// Generate 1 row of sudoku
char s[1][9];
for (char i = 0; i < 9; i++)
{
s[0][i] = i+1;
}
// Set up allowed list
char allowed[9] = {1,1,1,1,1,1,1,1,1};
// Check if 1 is allowed
s[0][0] = 0;
char fasit1[9] = {1,0,0,0,0,0,0,0,0};
check_row(allowed, s, 0);
assert(compare_lists(allowed, fasit1, 9));
// Check if none are allowed
s[0][0] = 1;
char fasit2[9] = {0,0,0,0,0,0,0,0,0};
check_row(allowed, s, 0);
assert(compare_lists(allowed, fasit2, 9));
}
/* Takes a list of allowed numbers and removes any new illegal numbers it finds
* in the same column as <position>. Modifes list in-place
*/
void check_column(char allowed[], char sudoku[][9], char position) {
char column = get_coordinates(position)[0];
for (char i = 0; i < 9; i++)
{
if (sudoku[i][column])
{
allowed[sudoku[i][column]-1] = 0;
}
}
}
void check_column_test() {
// Generate 1 row of sudoku
char s[9][9];
for (char i = 0; i < 9; i++)
{
s[i][0] = i+1;
}
// Set up allowed list
char allowed[9] = {1,1,1,1,1,1,1,1,1};
// Check if 1 is allowed
s[0][0] = 0;
char fasit1[9] = {1,0,0,0,0,0,0,0,0};
check_column(allowed, s, 0);
assert(compare_lists(allowed, fasit1, 9));
// Check if none are allowed
s[0][0] = 1;
char fasit2[9] = {0,0,0,0,0,0,0,0,0};
check_column(allowed, s, 0);
assert(compare_lists(allowed, fasit2, 9));
}
/* Takes a list of allowed numbers and removes any new illegal numbers it finds
* in the same square as <position>. Modifes list in-place
*/
void check_square(char allowed[], char sudoku[][9], char position) {
char square_x = (get_coordinates(position)[0]/3)*3;
char square_y = (get_coordinates(position)[1]/3)*3;
for (char y_offset = 0; y_offset < 3; y_offset++)
{
for (char x_offset = 0; x_offset < 3; x_offset++)
{
if (sudoku[square_y + y_offset][square_x + x_offset])
{
allowed[sudoku[square_y + y_offset][square_x + x_offset]-1] = 0;
}
}
}
}
void check_square_test() {
char s[9][9] = {
{0,7,8,5,0,0,0,0,0},
{0,0,3,0,0,7,8,0,0},
{0,0,0,1,9,0,0,0,0},
{0,0,7,0,0,0,2,9,0},
{0,9,0,0,6,1,0,4,0},
{0,0,0,0,0,4,0,0,0},
{3,0,6,0,0,2,0,0,0},
{0,1,0,0,0,0,0,0,4},
{0,0,0,0,0,0,5,0,0}
};
char t1[9] = {1,1,1,1,1,1,1,1,1};
char s1[9] = {1,1,0,1,1,1,0,0,1};
check_square(t1, s, 0);
assert(compare_lists(t1, s1, 9));
char t3[9] = {1,1,1,1,1,1,1,1,1};
char s3[9] = {1,1,1,1,1,1,1,0,1};
check_square(t3, s, 26);
assert(compare_lists(t3, s3, 9));
}
/* Prints a standard 9x9 sudoku array
* Purely for visualization
*/
void print_sudoku(char sudoku[][9]) {
for (char y = 0; y < 9; y++)
{
for (char x = 0; x < 9; x++)
{
printf("%d ", sudoku[y][x]);
}
printf("\n");
}
}
/* Recursively attempt to place a valid number in one
* cell at a time, backtracking if we hit a dead end.
* Solves the soduoku in-place
*/
char solve(char sudoku[][9], char position) {
// If we hit position 81, then we managed to place
// a number on every tile a.k.a. we completed it
if (position == 81) {
return 1;
}
// If not, then we have some work to do
// Get current cartesian coordinates
char x = get_coordinates(position)[0];
char y = get_coordinates(position)[1];
// If the current cell already has a value: skip
if (sudoku[y][x]) {
return solve(sudoku, position+1);
}
// Set up list to keep track of possible numbers
char allowed[9] = {1,1,1,1,1,1,1,1,1};
// Eliminate all dissalowed values
check_row(allowed, sudoku, position);
check_column(allowed, sudoku, position);
check_square(allowed, sudoku, position);
// Go through every number 1-9 and check if it was available
for (char i = 0; i < 9; i++)
{
if (allowed[i]) {
// If a number is available, we test it
sudoku[y][x] = i+1;
char result = solve(sudoku, position+1);
// If we get back 1, then we know we completed it
if (result) {
return 1;
}
}
}
// If none of the available options worked,
// then we reset this cell and go back
sudoku[y][x] = 0;
return 0;
}
int main(int argc, char const *argv[]) {
// Pain and suffering
char sudoku_base[9][9] = {
{0,7,8,5,0,0,0,0,0},
{0,0,3,0,0,7,8,0,0},
{0,0,0,1,9,0,0,0,0},
{0,0,7,0,0,0,2,9,0},
{0,9,0,0,6,1,0,4,0},
{0,0,0,0,0,4,0,0,0},
{3,0,6,0,0,2,0,0,0},
{0,1,0,0,0,0,0,0,4},
{0,0,0,0,0,0,5,0,0}
};
// Double check that we solve it and it returns 1
assert(solve(sudoku_base, 0));
print_sudoku(sudoku_base);
system("PAUSE");
} |
the_stack_data/88792.c | #include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
int decode(void *out_buf, size_t out_len, const void *in_buf, size_t in_len, unsigned char key) {
if (out_len != in_len) {
return -1;
}
for (unsigned int i = 0; i < out_len; i++) {
((char *)out_buf)[i] = ((char *)in_buf)[i] ^ key;
}
if (out_len > 0) {
((char *)out_buf)[out_len - 1] = 0;
}
return 0;
}
int main(int argc, char **argv) {
char in[] = "idmmn!vnsme";
char out[12] = {0};
unsigned char key = 0x1;
if (decode(out, sizeof(out), in, sizeof(in), 0x1)) {
perror("failed to decode.\n");
return -1;
}
printf("%s\n", out);
return 0;
}
|
the_stack_data/175143759.c | /*
Copyright (c) 2017, Lawrence Livermore National Security, LLC.
Produced at the Lawrence Livermore National Laboratory
Written by Chunhua Liao, Pei-Hung Lin, Joshua Asplund,
Markus Schordan, and Ian Karlin
(email: [email protected], [email protected], [email protected],
[email protected], [email protected])
LLNL-CODE-732144
All rights reserved.
This file is part of DataRaceBench. For details, see
https://github.com/LLNL/dataracebench. Please also see the LICENSE file
for our additional BSD notice.
Redistribution and use in source and binary forms, with
or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the disclaimer below.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the disclaimer (as noted below)
in the documentation and/or other materials provided with the
distribution.
* Neither the name of the LLNS/LLNL nor the names of its contributors
may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL LAWRENCE LIVERMORE NATIONAL
SECURITY, LLC, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
For a variable declared in a scope inside an OpenMP construct:
* private if the variable has an automatic storage duration
* shared if the variable has a static storage duration.
Dependence pairs:
tmp@73:5 vs. tmp@73:5
tmp@73:5 vs. tmp@74:12
*/
#include<stdio.h>
#include <omp.h>
int main(int argc,char *argv[])
{
int i;
int len = 100;
int a[len];
int b[len];
#pragma omp parallel for private (i)
for (i = 0; i <= len - 1; i += 1) {
a[i] = i;
b[i] = i;
}
/* static storage for a local variable */
{
static int tmp;
#pragma omp parallel for private (tmp,i)
for (i = 0; i <= len - 1; i += 1) {
tmp = a[i] + i;
a[i] = tmp;
}
}
/* automatic storage for a local variable */
{
int tmp;
#pragma omp parallel for private (tmp,i) firstprivate (len)
for (i = 0; i <= len - 1; i += 1) {
tmp = b[i] + i;
b[i] = tmp;
}
}
printf("a[50]=%d b[50]=%d\n",a[50],b[50]);
return 0;
}
|
the_stack_data/20450026.c | // This file is part of CPAchecker,
// a tool for configurable software verification:
// https://cpachecker.sosy-lab.org
//
// SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>
//
// SPDX-License-Identifier: Apache-2.0
struct mutex;
struct kref;
typedef struct {
int counter;
} atomic_t;
int __VERIFIER_nondet_int(void);
extern void mutex_lock(struct mutex *lock);
extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
extern int mutex_lock_interruptible(struct mutex *lock);
extern int mutex_lock_killable(struct mutex *lock);
extern int mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass);
extern int mutex_lock_killable_nested(struct mutex *lock, unsigned int subclass);
static inline int mutex_is_locked(struct mutex *lock);
extern int mutex_trylock(struct mutex *lock);
extern void mutex_unlock(struct mutex *lock);
extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
static inline int kref_put_mutex(struct kref *kref,
void (*release)(struct kref *kref),
struct mutex *lock);
static void specific_func(struct kref *kref);
void ldv_check_final_state(void);
void main(void)
{
struct mutex *mutex_1, *mutex_2, *mutex_3, *mutex_4, *mutex_5;
struct kref *kref;
atomic_t *counter;
int res = mutex_is_locked(&mutex_1);
if (res) {
// wrong return value check
mutex_unlock(mutex_3);
}
ldv_check_final_state();
}
|
the_stack_data/526249.c | /// Test we close file handle on flush, so the .gcda file can be deleted on
/// Windows while the process is still running. In addition, test we create
/// a new .gcda on flush, so there is a file when the process exists.
// RUN: mkdir -p %t.d && cd %t.d
// RUN: %clang --coverage -o %t %s
// RUN: test -f gcov-dump-and-remove.gcno
// RUN: rm -f gcov-dump-and-remove.gcda && %run %t
// RUN: llvm-cov gcov -t gcov-dump-and-remove.gcda | FileCheck %s
extern void __gcov_flush(void);
extern int remove(const char *); // CHECK: -: [[#@LINE]]:extern int remove
int main(void) { // CHECK-NEXT: #####: [[#@LINE]]:
__gcov_flush(); // CHECK-NEXT: #####: [[#@LINE]]:
if (remove("gcov-dump-and-remove.gcda") != 0) // CHECK-NEXT: #####: [[#@LINE]]:
return 1; // CHECK-NEXT: #####: [[#@LINE]]: return 1;
// CHECK-NEXT: -: [[#@LINE]]:
__gcov_flush(); // CHECK-NEXT: #####: [[#@LINE]]:
__gcov_flush(); // CHECK-NEXT: #####: [[#@LINE]]:
if (remove("gcov-dump-and-remove.gcda") != 0) // CHECK-NEXT: #####: [[#@LINE]]:
return 1; // CHECK-NEXT: #####: [[#@LINE]]: return 1;
return 0;
}
|
the_stack_data/147023.c | extern int printf(const char *, ...);
int main(void)
{
struct{
int twobit:2;
int :1;
int threebit:3;
unsigned int onebit:1;
} s3;
s3.onebit = 1;
if(s3.onebit != 1){
printf("Be especially careful with 1-bit fields! %d\n", (int) s3.onebit);
return 1;
}
return 0;
} |
the_stack_data/25283.c | /*
* $XConsortium: RHead.c,v 1.3 94/04/17 20:16:40 gildea Exp $
*
*
Copyright (c) 1989 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
* *
* Author: Keith Packard, MIT X Consortium
*/
#include <X11/Xos.h>
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xdmcp.h>
int
XdmcpReadHeader (buffer, header)
XdmcpBufferPtr buffer;
XdmcpHeaderPtr header;
{
if (XdmcpReadCARD16 (buffer, &header->version) &&
XdmcpReadCARD16 (buffer, &header->opcode) &&
XdmcpReadCARD16 (buffer, &header->length))
return TRUE;
return FALSE;
}
|
the_stack_data/11073944.c | #include <stdio.h>
#define BUFSIZE 100
char buf[BUFSIZE]; /* buffer for ungetch */
int bufp = 0; /* next free position in buffer */
int getch(void) /* get a (possibly pushed back) character */ {
return (bufp > 0) ? buf[--bufp] : getchar();
}
|
the_stack_data/115138.c | #include <stdio.h>
int main(){
int c;
while ((c = getchar ()) != EOF) {
if (c == ' ') {
putchar ('\n');
}
putchar (c);
}
} |
the_stack_data/156392987.c | /*
* Copyright (c) 2017 Nordic Semiconductor ASA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list
* of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic Semiconductor ASA
* integrated circuit in a product or a software update for such product, must reproduce
* the above copyright notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its contributors may be
* used to endorse or promote products derived from this software without specific prior
* written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary or object form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#if (defined(DEVICE_FLASH) && defined(DEVICE_LPTICKER))
#include "hal/flash_api.h"
#include "hal/lp_ticker_api.h"
#include "nrf_fstorage.h"
#if defined(SOFTDEVICE_PRESENT)
#include "nrf_fstorage_sd.h"
#else
#include "nrf_fstorage_nvmc.h"
#endif
#include <stdbool.h>
#define PAGE_ERASE_TIMEOUT_US (200 * 1000) // Max. value from datasheet: 89.7 ms
#define WORD_SIZE_IN_BYTES 4
NRF_FSTORAGE_DEF(static nrf_fstorage_t nordic_fstorage) = { 0 };
int32_t flash_init(flash_t *obj)
{
(void)(obj);
ret_code_t result = NRF_SUCCESS;
/* Only initialize once. */
static bool do_init = true;
if (do_init) {
do_init = false;
/* Set instance to cover the whole flash. */
nordic_fstorage.p_flash_info = NULL;
nordic_fstorage.evt_handler = NULL;
nordic_fstorage.start_addr = 0;
nordic_fstorage.end_addr = NRF_FICR->CODESIZE * NRF_FICR->CODEPAGESIZE;
/* Initialize either SoftDevice API or NVMC API.
* SoftDevice API should work both when the SoftDevice is enabled or disabled.
* NVMC API is used when the SoftDevice is not present.
*/
#if defined(SOFTDEVICE_PRESENT)
result = nrf_fstorage_init(&nordic_fstorage, &nrf_fstorage_sd, NULL);
#else
result = nrf_fstorage_init(&nordic_fstorage, &nrf_fstorage_nvmc, NULL);
#endif
}
/* Convert Nordic SDK error code to mbed HAL. */
return (result == NRF_SUCCESS) ? 0 : -1;
}
int32_t flash_free(flash_t *obj)
{
(void)(obj);
return 0;
}
int32_t flash_erase_sector(flash_t *obj, uint32_t address)
{
(void)(obj);
ret_code_t result = NRF_ERROR_NO_MEM;
/* Setup stop watch for timeout. */
uint32_t start_us = lp_ticker_read();
uint32_t now_us = start_us;
/* Retry if flash is busy until timeout is reached. */
while (((now_us - start_us) < PAGE_ERASE_TIMEOUT_US) &&
(result == NRF_ERROR_NO_MEM)) {
/* Map mbed HAL call to Nordic fstorage call. */
result = nrf_fstorage_erase(&nordic_fstorage, address, 1, NULL);
/* Read timeout timer. */
now_us = lp_ticker_read();
}
/* Convert Nordic SDK error code to mbed HAL. */
return (result == NRF_SUCCESS) ? 0 : -1;
}
int32_t flash_program_page(flash_t *obj, uint32_t address, const uint8_t *data, uint32_t size)
{
(void)(obj);
/* Check that data pointer is not NULL. */
ret_code_t result = NRF_ERROR_NULL;
if (data) {
/* nrf_fstorage_write only accepts word aligned input buffers.
* Cast data pointer to word pointer and read word into temporary word variable
* which should be word aligned. This should be safe on Cortex-m4 which is able
* to load unaligned data.
*/
const uint32_t *data_word = (const uint32_t *) data;
/* Loop through input buffer 4 bytes at a time. */
for (size_t index = 0; index < (size / WORD_SIZE_IN_BYTES); index++) {
/* Load 4 bytes into temporary variable. */
uint32_t word = data_word[index];
/* Setup stop watch for timeout. */
uint32_t start_us = lp_ticker_read();
uint32_t now_us = start_us;
/* Retry if flash is busy until timeout is reached. */
do {
/* Write one word at a time. */
result = nrf_fstorage_write(&nordic_fstorage,
address + (WORD_SIZE_IN_BYTES * index),
&word,
WORD_SIZE_IN_BYTES,
NULL);
/* Read timeout timer. */
now_us = lp_ticker_read();
/* Loop if queue is full or until time runs out. */
} while (((now_us - start_us) < PAGE_ERASE_TIMEOUT_US) &&
(result == NRF_ERROR_NO_MEM));
/* Break loop if write command wasn't accepted. */
if (result != NRF_SUCCESS) {
break;
}
}
}
/* Convert Nordic SDK error code to mbed HAL. */
return (result == NRF_SUCCESS) ? 0 : -1;
}
uint32_t flash_get_size(const flash_t *obj)
{
(void)(obj);
return nordic_fstorage.end_addr - nordic_fstorage.start_addr;
;
}
uint32_t flash_get_sector_size(const flash_t *obj, uint32_t address)
{
(void)(obj);
/* Check if passed address is in flash area. Note end_addr is outside valid range. */
if ((address >= nordic_fstorage.start_addr) && (address < nordic_fstorage.end_addr)) {
return nordic_fstorage.p_flash_info->erase_unit;
}
/* Return invalid size if request is outisde flash area. */
return MBED_FLASH_INVALID_SIZE;
}
uint32_t flash_get_page_size(const flash_t *obj)
{
(void)(obj);
/* Return minimum writeable page size. */
return WORD_SIZE_IN_BYTES;
}
uint32_t flash_get_start_address(const flash_t *obj)
{
return 0;
}
#endif
|
the_stack_data/132952147.c | /* { dg-lto-do link } */
/* { dg-extra-ld-options "-w" } */
/* Make sure we do not ICE on the invalid re-declaration of s. */
extern void f(void);
const char *s = "Hello, world!";
int main(void)
{
f();
return 0;
}
|
the_stack_data/1063114.c | #include<stdio.h>
main(){
int n1,n2,n3;
printf("escreva três numeros que representem os lados de um triangulo\n");
scanf("%d",&n1);
scanf("%d",&n2);
scanf("%d",&n3);
if (n1<n2+n3 && n2<n1+n3 && n1<n2+n3){
if (n1==n2&& n2==n3){
printf("o triangulo eh equilatero");
}
else if (n1==n2 || n2==n3 || n1==n3){
printf("o triangulo eh isosceles");
}
else if(n1!=n2&& n2!=n3){
printf("o triangulo eh equilatero");
}
}
else{
printf("nao pode ser um triangulo");
}
getch();
}
|
the_stack_data/64201024.c | //
// Created by forgot on 2019-08-03.
//
//1013 数素数 (20 point(s))
/*令 P
i
表示第 i 个素数。现任给两个正整数 M≤N≤10
4
，请输出 P
M
到 P
N
的所有素数。
输入格式：
输入在一行中给出 M 和 N，其间以空格分隔。
输出格式：
输出从 P
M
到 P
N
的所有素数，每 10 个数字占 1 行，其间以空格分隔，但行末不得有多余空格。
输入样例：
5 27
输出样例：
11 13 17 19 23 29 31 37 41 43
47 53 59 61 67 71 73 79 83 89
97 101 103*/
//此题麻烦在最后的格式化打印
#include <stdio.h>
//判断是否素数，是则返回1，不是返回0
//int isPrime(int a) {
// for (int i = 2; i * i <= a; i++) {
// if (a % i == 0) {
// return 0;
// }
// }
//
// return 1;
//}
//
//int main() {
// int M, N;
// scanf("%d %d", &M, &N);
// int prime[10001];
// int count = 1;
// int n = 2;
// while (count <= N) {
// if (isPrime(n)) {
// prime[count] = n;
// count++;
// }
// n++;
// }
//
//// 当前正在打印第几位
// int printCount = 1;
//// 需要打印的数量
// int needPrint = N - M + 1;
// for (int i = M; i <= N; i++) {
// printf("%d", prime[i]);
//// 如果当前不是在打印最后一位，则再判断
// if (printCount != needPrint) {
// if (printCount % 10 != 0) {
// printf(" ");
// } else {
// //如果打印10的整数倍，换行
// printf("\n");
// }
// }
//
// printCount++;
// }
//
// return 0;
//}
|
the_stack_data/94805.c | #include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#define MAX_ALLOC 50
//int read_char(char * txt, size_t * max_size) {
// if (txt == NULL || *max_size < MAX_ALLOC) return 1;
// if (strlen(txt) + 2 > *max_size) { // try to alloc more memory
// char * tmp = realloc(txt, *max_size + MAX_ALLOC);
// if (tmp == NULL) { return 2; }
// else {
// txt = tmp;
// *max_size = *max_size + MAX_ALLOC;
// }
// }
// char c = getc(stdin); if (c == '\n') return 3;
// strncat(txt, &c, 1);
// return 0;
//}
int main() {
char * text = realloc(NULL, MAX_ALLOC);
size_t size = MAX_ALLOC;
if (text == NULL) {
printf("Failed to allocate memory");
return 8;
}
printf("Podaj tekst: ");
while (1) {
if (strlen(text) + 2 > size) { // try to alloc more memory
char * tmp = realloc(text, size + MAX_ALLOC);
if (tmp == NULL) { break; }
else {
text = tmp;
size = size + MAX_ALLOC;
}
}
char c = getc(stdin); if (c == '\n') break;
strncat(text, &c, 1);
}
printf("%s", text);
free(text);
return 0;
} |
the_stack_data/59513226.c |
void main() {
while(1) {
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.