diff --git "a/tokenizer.json" "b/tokenizer.json" new file mode 100644--- /dev/null +++ "b/tokenizer.json" @@ -0,0 +1,15904 @@ +{ + "char2idx": { + "": 0, + "": 1, + "": 2, + "": 3, + "\n": 4, + " ": 5, + "!": 6, + "\"": 7, + "#": 8, + "$": 9, + "%": 10, + "&": 11, + "'": 12, + "(": 13, + ")": 14, + "*": 15, + "+": 16, + ",": 17, + "-": 18, + ".": 19, + "/": 20, + "0": 21, + "1": 22, + "2": 23, + "3": 24, + "4": 25, + "5": 26, + "6": 27, + "7": 28, + "8": 29, + "9": 30, + ":": 31, + ";": 32, + "<": 33, + "=": 34, + ">": 35, + "?": 36, + "@": 37, + "A": 38, + "B": 39, + "C": 40, + "D": 41, + "E": 42, + "F": 43, + "G": 44, + "H": 45, + "I": 46, + "J": 47, + "K": 48, + "L": 49, + "M": 50, + "N": 51, + "O": 52, + "P": 53, + "Q": 54, + "R": 55, + "S": 56, + "T": 57, + "U": 58, + "V": 59, + "W": 60, + "X": 61, + "Y": 62, + "Z": 63, + "[": 64, + "\\": 65, + "]": 66, + "^": 67, + "_": 68, + "`": 69, + "a": 70, + "b": 71, + "c": 72, + "d": 73, + "e": 74, + "f": 75, + "g": 76, + "h": 77, + "i": 78, + "j": 79, + "k": 80, + "l": 81, + "m": 82, + "n": 83, + "o": 84, + "p": 85, + "q": 86, + "r": 87, + "s": 88, + "t": 89, + "u": 90, + "v": 91, + "w": 92, + "x": 93, + "y": 94, + "z": 95, + "{": 96, + "|": 97, + "}": 98, + "~": 99, + "\u00a5": 100, + "\u00b0": 101, + "\u00ba": 102, + "\u00e0": 103, + "\u00e1": 104, + "\u00e7": 105, + "\u00e9": 106, + "\u00ea": 107, + "\u00ed": 108, + "\u00f3": 109, + "\u00fa": 110, + "\u3000": 111, + " ": 112, + "\n ": 113, + " (": 114, + ") ": 115, + "= ": 116, + "\n ": 117, + " = ": 118, + "; ": 119, + "or": 120, + " 1": 121, + "for": 122, + "((": 123, + " +": 124, + " *": 125, + "in": 126, + " <": 127, + "][": 128, + ";\n ": 129, + "\n ": 130, + "++": 131, + "}\n": 132, + "for (": 133, + ", ": 134, + ") +": 135, + "))": 136, + "le": 137, + "; i": 138, + " = 0": 139, + "[i": 140, + "ar": 141, + "mp": 142, + " * ": 143, + "++)": 144, + "int": 145, + "al": 146, + "te": 147, + " < ": 148, + " (-": 149, + "00": 150, + ";\n": 151, + "re": 152, + " 16": 153, + "st": 154, + " p": 155, + " ((": 156, + "omp": 157, + "int ": 158, + " = 0; i": 159, + "\n ": 160, + " -": 161, + "{\n ": 162, + "for (i": 163, + "\n{\n ": 164, + ")) ": 165, + "[i]": 166, + " (-1": 167, + ";\n ": 168, + ") + ": 169, + "ri": 170, + "co": 171, + " =": 172, + "at": 173, + "lo": 174, + "si": 175, + " + (-1": 176, + " (((": 177, + "um": 178, + " par": 179, + "if": 180, + "ou": 181, + "alle": 182, + "allel": 183, + " for": 184, + "for (i = 0; i": 185, + "; j": 186, + " parallel": 187, + "; i++)": 188, + "{\n ": 189, + " parallel for": 190, + "\n {\n ": 191, + "ed": 192, + " + ": 193, + "de": 194, + "j]": 195, + "}\n\n": 196, + "ic": 197, + "ra": 198, + "omp parallel for": 199, + "ma": 200, + ") ?": 201, + ");\n ": 202, + "->": 203, + ";\n ": 204, + " + (-1))": 205, + "16": 206, + "se": 207, + "ble": 208, + ") /": 209, + ") *": 210, + " (n": 211, + "ate": 212, + "col": 213, + "}\n\n ": 214, + "dou": 215, + "ch": 216, + "double": 217, + "if (": 218, + "ro": 219, + "ti": 220, + ") + 1": 221, + "] = ": 222, + " + 1": 223, + "][i": 224, + " - 1": 225, + "ge": 226, + "t_": 227, + "el": 228, + "on": 229, + "(i": 230, + "(n": 231, + "s[": 232, + "riv": 233, + "rivate": 234, + "; i++)\n{\n ": 235, + "; ++": 236, + "sum": 237, + "[i][": 238, + "_p": 239, + ") -": 240, + "i)": 241, + ".0": 242, + "omp parallel for ": 243, + "nd": 244, + "ad": 245, + ";\n}\n": 246, + "er": 247, + "c2": 248, + "for (i = 0; i < ": 249, + "for (i = 0; i <": 250, + "ze": 251, + ") <": 252, + " - ": 253, + ") :": 254, + ";\n ": 255, + " += ": 256, + " = 1": 257, + "for (int ": 258, + "f(": 259, + "0) ?": 260, + "c4": 261, + "; ++i)": 262, + "id": 263, + "di": 264, + "th": 265, + "uc": 266, + "ur": 267, + ") / 16": 268, + "((((": 269, + ") * ": 270, + "nt": 271, + "; j++)": 272, + "16 * ": 273, + "][k": 274, + " = (": 275, + "c1": 276, + "for (j": 277, + "temp": 278, + "{\n ": 279, + " = 0; ": 280, + "\n {\n ": 281, + "000": 282, + "size": 283, + "me": 284, + "private": 285, + "c3": 286, + " = 0; j": 287, + "tion": 288, + "pe": 289, + "][j": 290, + "num": 291, + "ce": 292, + "{\n ": 293, + "ty": 294, + "row": 295, + ")) :": 296, + "red": 297, + "_b": 298, + "ul": 299, + ") + (": 300, + " + (": 301, + "gma": 302, + ")) /": 303, + "ragma": 304, + "#p": 305, + "#pragma": 306, + "#pragma ": 307, + "((((-": 308, + ") - 1": 309, + " (-((((-": 310, + "la": 311, + ")\n{\n ": 312, + " >": 313, + "log": 314, + ") + 16": 315, + "double ": 316, + "MP": 317, + ") + 15": 318, + ");\n ": 319, + "pr": 320, + ")\n {\n ": 321, + "ne": 322, + " <=": 323, + " == ": 324, + "logic": 325, + "un": 326, + "print": 327, + " (-((((-(n": 328, + "am": 329, + " + (-1))) + 16": 330, + "printf(": 331, + "1]": 332, + "_x": 333, + "omp ": 334, + "}\n\n}\n": 335, + "tmp": 336, + "_m": 337, + "ule": 338, + "sh": 339, + "ched": 340, + "loc": 341, + "sched": 342, + "schedule": 343, + "md": 344, + "bu": 345, + "tion(": 346, + "reduc": 347, + "0]": 348, + "simd": 349, + "for (j = 0; j": 350, + "s(": 351, + "dex": 352, + "reduction(": 353, + "for (int i": 354, + ")) *": 355, + "val": 356, + "\\n": 357, + " * (": 358, + "t ": 359, + "Ma": 360, + "[i][j]": 361, + "); ": 362, + "[j]": 363, + "type": 364, + "s[i]": 365, + "OMP": 366, + "ve": 367, + ") < ": 368, + " x": 369, + ";\n}\n\n": 370, + " ((((": 371, + "; i++)\n ": 372, + "read": 373, + ";\n int ": 374, + "s_": 375, + "ta": 376, + "schedule(": 377, + "ret": 378, + "vtype": 379, + "Max": 380, + "\\n\"": 381, + "an": 382, + "urn": 383, + "return": 384, + "16 * c2": 385, + ") private": 386, + "no": 387, + "it_": 388, + "; ++i)\n ": 389, + ")\n ": 390, + "index": 391, + " /": 392, + "ig": 393, + "2]": 394, + "for (i = 0; i < 16": 395, + "ue": 396, + "[(i": 397, + ") < 0) ?": 398, + " < 0) ?": 399, + "dist": 400, + "20": 401, + ") : (n": 402, + "else": 403, + ") / 16))": 404, + "mat": 405, + "*((": 406, + "[(": 407, + " ((16": 408, + "len": 409, + " 16) < 0) ?": 410, + " ((16 < 0) ?": 411, + ") / 16)) :": 412, + ") - 1) / 16))": 413, + "&&": 414, + "OMP_x": 415, + "OMP_xMax": 416, + "ter": 417, + "for (i = 0; i < 1": 418, + " + (-1))) ?": 419, + "][j][k": 420, + "for (j = 0; j < ": 421, + "for (int i = 0; i": 422, + "thread": 423, + "flo": 424, + "for (i = 0; i < 16; ++i)\n ": 425, + "fa": 426, + "ult": 427, + "fi": 428, + ";\n\n": 429, + "for (i = 0; i < 16; ++i)\n ;\n": 430, + ", int ": 431, + ") + j]": 432, + "}\n\n ": 433, + "char": 434, + ";\n }\n\n ": 435, + "sig": 436, + "ff": 437, + " %": 438, + "float": 439, + "[k": 440, + "2 * ": 441, + "hs[": 442, + " = (((": 443, + "nj": 444, + ") < (n": 445, + "num_": 446, + "; j++)\n {\n ": 447, + "ke": 448, + "sign": 449, + "dy": 450, + "ata": 451, + ") private(i": 452, + " <= ": 453, + "double) ": 454, + "nk": 455, + "cur": 456, + "out": 457, + "[i] = ": 458, + "stat": 459, + "\n {\n ": 460, + "16 * c2) + 15": 461, + "32": 462, + "printf(\"": 463, + "pu": 464, + "data": 465, + "++)\n{\n ": 466, + "])": 467, + ") * (": 468, + " = 0;\n ": 469, + "rix": 470, + "_mm": 471, + "ct": 472, + "res": 473, + "igh": 474, + "rid": 475, + "po": 476, + " private": 477, + "{\n ": 478, + ") reduction(": 479, + "omp parallel for schedule(": 480, + "to": 481, + "u[": 482, + ";\n ": 483, + "and": 484, + " *) ": 485, + "ex": 486, + ") - 1) / 16))) :": 487, + "2)": 488, + "] * ": 489, + "ic,": 490, + "25": 491, + ")))": 492, + ", i": 493, + "ray": 494, + " &": 495, + "16 * c1": 496, + "max": 497, + " *)": 498, + "ind": 499, + "][i][j][k": 500, + "for (int i = 0; i < ": 501, + "rr": 502, + "nam": 503, + "[i][j": 504, + "ed ": 505, + "dynam": 506, + " 16) < 0) ? ((16 < 0) ?": 507, + ") + 1) / 16)) :": 508, + "; k": 509, + ", \"": 510, + " = 1; i": 511, + "lu": 512, + ")) / 16": 513, + ")) * 16) < 0) ? ((16 < 0) ?": 514, + "OMP_xMax) + ": 515, + "t(": 516, + "unsign": 517, + "[(i * ": 518, + "grid": 519, + ") / ": 520, + " / ": 521, + ") - 1) / 16))) : ((": 522, + ")) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 523, + ") + 1) / 16)) : (-((((-(n": 524, + " + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 525, + " + (-1))) + 16) + 1) / 16)) : (-((((-(n": 526, + " + (-1))) + 16) - 1) / 16))) : ((": 527, + " + (-1)) / 16": 528, + "unsigned ": 529, + "arge": 530, + " + (-1))) ? ((": 531, + " = ((": 532, + ")) / ": 533, + "0000": 534, + "con": 535, + " parallel for ": 536, + "&& (": 537, + "simd ": 538, + " !": 539, + "omp parallel for private": 540, + "bit_": 541, + "key": 542, + "vo": 543, + "new": 544, + "logic_": 545, + "result": 546, + "+:": 547, + "ph": 548, + "].": 549, + "_s": 550, + "ic,1": 551, + "ared": 552, + "es": 553, + ";\n }\n\n}\n": 554, + "FF": 555, + " * 1": 556, + "d_": 557, + "#pragma omp ": 558, + "48": 559, + " < (": 560, + "for (i = 0; i < 1000": 561, + ")) + ": 562, + "str": 563, + "vtype x": 564, + "\n {\n ": 565, + "0][": 566, + "] = (((": 567, + "for (k": 568, + "omp parallel for schedule(dynam": 569, + "return ": 570, + "shared": 571, + "; ++i)\n{\n ": 572, + "DE": 573, + " + i": 574, + "ac": 575, + ";\n vtype x": 576, + "12": 577, + "++)\n {\n ": 578, + "buf": 579, + "= (": 580, + ") + ((": 581, + "_ps(": 582, + " ^": 583, + "ic,1) private(i": 584, + "array": 585, + ", &": 586, + "nl": 587, + " < 1": 588, + " ((((n": 589, + "16 * c1) + 15": 590, + "lhs[": 591, + ");\n }\n\n ": 592, + "logics[i]": 593, + "}\n\n ": 594, + "tr": 595, + "] = (((double) ": 596, + "n_": 597, + "iff": 598, + ";\n x": 599, + "ng": 600, + " + (-1))); ": 601, + "if ((": 602, + ")\n {\n ": 603, + "}\n\n}\n\n": 604, + "0.": 605, + "for (i = 1; i": 606, + " = x": 607, + " > ": 608, + " = 0.0": 609, + "matrix": 610, + ";\n }\n\n ": 611, + "omp parallel for schedule(dynamic,1) private(i": 612, + "omp parallel for schedule(dynamic,1) private(i) reduction(": 613, + ";\n\n ": 614, + "wor": 615, + "; i++)\n {\n ": 616, + " - (": 617, + "[j": 618, + "art": 619, + "stprivate": 620, + "ams": 621, + "void": 622, + "ol": 623, + "lock": 624, + "targe": 625, + "fprintf(": 626, + " (-16": 627, + "%d": 628, + "it": 629, + " = i": 630, + ")) -": 631, + ");\n ": 632, + " = 0; k": 633, + "ing": 634, + "(x": 635, + "10": 636, + "diff": 637, + "nm": 638, + "bor": 639, + " - 1]": 640, + "64": 641, + " - 1)": 642, + ");\n}\n": 643, + "ribu": 644, + "ribute": 645, + "(&": 646, + ")\n ": 647, + "distribute": 648, + "pse": 649, + "\n ": 650, + "OMP_xMax) + OMP_xMax) + ": 651, + ") && (": 652, + "char *) ": 653, + "cou": 654, + ") - ": 655, + "1000": 656, + "lapse": 657, + "as": 658, + "collapse": 659, + "or ": 660, + "> ": 661, + "], ": 662, + "rand": 663, + "++)\n {\n ": 664, + "static": 665, + " + 2": 666, + "_mm_": 667, + "for (int j": 668, + "33": 669, + "omp targe": 670, + "fir": 671, + ", (": 672, + "al_": 673, + "eigh": 674, + "}\n ": 675, + " * ((": 676, + "oint": 677, + "\\n\", ": 678, + ") + i": 679, + "(((": 680, + "sizeo": 681, + "0x": 682, + "ni": 683, + "[c3": 684, + "node": 685, + "[c3][": 686, + "[c3][c4": 687, + " + 1]": 688, + "[c3][c4] = (((double) ": 689, + "[c3][c4] = (((double) c3": 690, + "ca": 691, + "st_": 692, + "count": 693, + "mage": 694, + "DES": 695, + "[i][j][k": 696, + "min": 697, + ";\n u": 698, + "distribute parallel for ": 699, + ";\n double ": 700, + "2048": 701, + "time": 702, + "collapse(": 703, + "com": 704, + "sizeof(": 705, + " + (-1)) / 16))": 706, + "now": 707, + "num_thread": 708, + "ion": 709, + "float ": 710, + "ree": 711, + "void ": 712, + "dx": 713, + "3]": 714, + "][j]": 715, + " (&": 716, + "clu": 717, + "ell": 718, + "for (i = 0; i < n": 719, + "shared(": 720, + " <<": 721, + "[iel": 722, + "16 * c2) + 15) < (n": 723, + " + (-1))) ? ((16 * c2) + 15": 724, + " + (-1))) ? ((16 * c2) + 15) : (n": 725, + "][0]": 726, + "24": 727, + "fprintf(st": 728, + " *= ": 729, + "||": 730, + "DES_b": 731, + "DES_bs_": 732, + "dt": 733, + " <= ((((": 734, + " %d": 735, + "256": 736, + "set": 737, + "sk": 738, + "ry": 739, + "know": 740, + " *) (((": 741, + "ver": 742, + "omp_": 743, + "))))": 744, + "derr": 745, + "s, ": 746, + "11": 747, + "ile": 748, + " logics[i]": 749, + "derr, \"": 750, + "fprintf(stderr, \"": 751, + "op": 752, + "long": 753, + "0.0": 754, + "_c": 755, + "j * ": 756, + "_g": 757, + "1.0": 758, + "par": 759, + "a[i]": 760, + "t->": 761, + "++)\n {\n ": 762, + ")]": 763, + ");\n}\n\n": 764, + ") + k": 765, + "; j++)\n{\n ": 766, + " <= (": 767, + "s->": 768, + "im": 769, + "_point": 770, + "[0]": 771, + "}\n else": 772, + "word": 773, + "#pragma omp simd": 774, + " = j": 775, + "for (k = 0; k": 776, + ", j": 777, + "get_": 778, + "alloc": 779, + "[((": 780, + "end": 781, + "ation": 782, + "[index": 783, + "[1": 784, + "--": 785, + "lin": 786, + "y_": 787, + " + 3": 788, + " = 1; j": 789, + ") * (c4": 790, + "m]": 791, + "i * ": 792, + "2 * i": 793, + "[c3][c4] = (((double) c3) * (c4": 794, + "; ++i)\n {\n ": 795, + "++;\n ": 796, + " * 100": 797, + " = _mm_": 798, + "++)\n {\n ": 799, + "ound": 800, + " != ": 801, + "curre": 802, + "start": 803, + "reduction(+:": 804, + "load": 805, + "idx": 806, + "nx": 807, + ") - (": 808, + "_t ": 809, + "][1]": 810, + "for (int j = 0; j": 811, + "][i][j][k]": 812, + "for (c4": 813, + "sa": 814, + " == 0": 815, + "_i": 816, + "rc": 817, + ")\n{\n int ": 818, + "all": 819, + "ctor": 820, + "2.0": 821, + "v_b": 822, + "[n": 823, + "**": 824, + "Val": 825, + " *) (&": 826, + "v_": 827, + "ci": 828, + "ste": 829, + " + 1)": 830, + "edge": 831, + "ance": 832, + "err": 833, + "rhs[": 834, + " < n": 835, + "rows": 836, + "clusi": 837, + "n_sum": 838, + "[i].": 839, + ": ": 840, + "uint": 841, + "known_sum": 842, + "1 * 100": 843, + "exclusi": 844, + "exclusiv_b": 845, + "exclusiv_bit_": 846, + "logic_and": 847, + "bit_and": 848, + "bin": 849, + "exclusiv_bit_or": 850, + "}\n\n }\n\n ": 851, + "((-": 852, + "][i2": 853, + "512": 854, + "F_": 855, + "li": 856, + " + (-1))); c4": 857, + "1, ": 858, + "sq": 859, + "][i]": 860, + " <= (((": 861, + "; i++)\n{\n for (j = 0; j < ": 862, + "#pragma omp simd\n ": 863, + "; c4": 864, + ");\n\n": 865, + ")) + (": 866, + "#pragma omp simd\n for (c4": 867, + "}\n\n ": 868, + "pro": 869, + ")) - 1": 870, + "value": 871, + "dim": 872, + " >= ": 873, + "[col": 874, + "firstprivate": 875, + "));\n ": 876, + "Err": 877, + "om": 878, + "][0][": 879, + "in ": 880, + "int *": 881, + "_y": 882, + "In": 883, + "eight": 884, + "22": 885, + "omp parallel for reduction(+:": 886, + "bl": 887, + "1 * ": 888, + "ha": 889, + " = a": 890, + "is": 891, + "add": 892, + "if (!": 893, + "_r": 894, + " ((((-": 895, + ")) : (((": 896, + "cell": 897, + "for (j = 1; j": 898, + "Error ": 899, + ")\n {\n result": 900, + ", b": 901, + "sp": 902, + "gra": 903, + "];\n ": 904, + " + (-1))); c4++)\n {\n ": 905, + "of": 906, + "[i3": 907, + "ctx": 908, + "line": 909, + "buf[": 910, + "][1": 911, + ") schedule(": 912, + "55": 913, + "tic": 914, + "st ": 915, + "\", ": 916, + "ele": 917, + "inpu": 918, + ";\n\n ": 919, + "16 * c1) + 15) < (n": 920, + " + (-1))) ? ((16 * c1) + 15": 921, + " + (-1))) ? ((16 * c1) + 15) : (n": 922, + " += 1": 923, + "ow": 924, + ", 0": 925, + "#pragma omp simd\n for (c4 = ": 926, + "fprintf(stderr, \"Error ": 927, + "BF_": 928, + "));\n ": 929, + "_points[": 930, + "))\n {\n ": 931, + "ec": 932, + "for (i = 0; i < N": 933, + ")\n {\n result++;\n ": 934, + ")\n {\n result++;\n fprintf(stderr, \"Error ": 935, + ")\n {\n result++;\n fprintf(stderr, \"Error in ": 936, + "omp_get_": 937, + " < 5": 938, + "p = ": 939, + " & ": 940, + "#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 941, + ") : (": 942, + "m1": 943, + " + 16": 944, + "ab": 945, + "[i + 1": 946, + "rand(": 947, + ", y": 948, + "grid_points[": 949, + ";\n }\n\n ": 950, + "malloc": 951, + "omp parallel for private(": 952, + " == 1": 953, + " (-((-": 954, + ")) - 1) /": 955, + "[m": 956, + "atrix": 957, + "];\n ": 958, + "lhs[n": 959, + " + 4": 960, + "long ": 961, + " ^ x": 962, + "spe": 963, + "_t": 964, + "block": 965, + ") + t": 966, + "del": 967, + "IN": 968, + "mag": 969, + "up": 970, + "; j++)\n ": 971, + "CC": 972, + "2] = ": 973, + ";\n}\n\n\n": 974, + "omp target": 975, + ") %": 976, + "current": 977, + "distribute parallel for simd ": 978, + ") + (-16": 979, + "1 = ": 980, + "omp parallel for simd ": 981, + " = 0;\n ": 982, + ") =": 983, + "][4": 984, + "_f": 985, + "for (i = 1; i <= ": 986, + ")) * (": 987, + "neigh": 988, + "fo": 989, + " 16) < 0) ? (-((-": 990, + " ((16 < 0) ? ((((-": 991, + ") + (-16)) - 1) /": 992, + ") + (-16)) - 1) / (-16": 993, + ") + (-16)) - 1) / (-16)) : (((": 994, + "[i][j] = ": 995, + "tex": 996, + "cale": 997, + ") / 16)) : ((16 < 0) ? ((((-": 998, + "defa": 999, + "il": 1000, + "sum += ": 1001, + "MPI": 1002, + "old": 1003, + ")) <": 1004, + "(int ": 1005, + ";\n int i": 1006, + "(*((": 1007, + "duc": 1008, + "ams.": 1009, + " * 16) < 0) ? (-((-": 1010, + "[1]": 1011, + "MPI_": 1012, + ")\n ": 1013, + "99": 1014, + "][2]": 1015, + "; i < ": 1016, + "src": 1017, + "c0": 1018, + "-1": 1019, + " |": 1020, + "_num": 1021, + "ps": 1022, + "vector": 1023, + "bo": 1024, + "default": 1025, + "ak": 1026, + "logic_or": 1027, + "bit_or": 1028, + "teams": 1029, + " ,": 1030, + "combin": 1031, + "combined": 1032, + "all_p": 1033, + ") == ": 1034, + "s[i].": 1035, + " ": 1036, + ";\n }\n\n }\n\n}\n": 1037, + "idth": 1038, + "blic": 1039, + "off": 1040, + "sha": 1041, + " *) (((char *) ": 1042, + "combined *) (((char *) ": 1043, + "))).": 1044, + "all_p) + t": 1045, + "all_p) + t))).": 1046, + "024": 1047, + "len(": 1048, + "num_threads(": 1049, + "vtype *) (&": 1050, + "orde": 1051, + "mo": 1052, + "blic.": 1053, + " + 1)) / ": 1054, + "ed_": 1055, + "_col": 1056, + "teams ": 1057, + ", 1": 1058, + "bre": 1059, + "2 = ": 1060, + "omp target parallel for ": 1061, + "width": 1062, + "const ": 1063, + " >> ": 1064, + " <= ((((16 * c2) + 15) < (n": 1065, + "}\n ": 1066, + "break": 1067, + "if (i": 1068, + "0] = ": 1069, + "sum = ": 1070, + "arr": 1071, + "_size": 1072, + "_sha": 1073, + "ptr": 1074, + "for (i = 0; i < 20": 1075, + "hash": 1076, + "ix": 1077, + "lastprivate": 1078, + "mor": 1079, + "error": 1080, + "ub": 1081, + "double *": 1082, + ") ^": 1083, + "en": 1084, + "distance": 1085, + "pt": 1086, + "do": 1087, + "graph": 1088, + "static ": 1089, + "ist": 1090, + "nn": 1091, + "ber": 1092, + "3 * ": 1093, + "Index": 1094, + "[i] = (": 1095, + "21": 1096, + "test_": 1097, + "30": 1098, + " + k": 1099, + ") + j": 1100, + "0.5": 1101, + "ize": 1102, + "][m]": 1103, + "unsigned char": 1104, + ") |": 1105, + "; m": 1106, + "}\n else\n {\n ": 1107, + "abs": 1108, + "one": 1109, + "[x": 1110, + "eta": 1111, + "51": 1112, + "40": 1113, + "sqr": 1114, + "bit": 1115, + "Val(": 1116, + ", n": 1117, + "B[": 1118, + "_mul": 1119, + " = v": 1120, + "wh": 1121, + "Matrix": 1122, + "vertic": 1123, + "r_": 1124, + " + 16) - 1) / 16))": 1125, + "duct": 1126, + "rank": 1127, + "vec": 1128, + "++)\n ": 1129, + "for (i = 0; i < 1000; ++i)\n{\n ": 1130, + "u1": 1131, + "for (int j = 0; j < ": 1132, + "CH": 1133, + "1 - ": 1134, + "ho": 1135, + ";\n }\n\n ": 1136, + ",j": 1137, + "cent": 1138, + "*(": 1139, + ")));\n ": 1140, + " * x": 1141, + "_T": 1142, + "neighbor": 1143, + " * (((": 1144, + "for (k = 0; k < ": 1145, + "omp parallel for shared(": 1146, + " = 1;\n ": 1147, + "t teams ": 1148, + "local_": 1149, + "real": 1150, + "omp target teams ": 1151, + "->n": 1152, + "for (i = ": 1153, + "outpu": 1154, + "unsigned char *) ": 1155, + "absVal(": 1156, + "for (i = 0; i < 1000; ++i)\n {\n ": 1157, + "Scale": 1158, + "speed": 1159, + "[2]": 1160, + "params.": 1161, + "0)": 1162, + " a": 1163, + " != (": 1164, + " + (-1))) < (n": 1165, + " + (-1))) : (n": 1166, + " <= (grid_points[": 1167, + "Size": 1168, + "77": 1169, + "; ++j": 1170, + "while": 1171, + " logics[i];\n}\n": 1172, + "ent": 1173, + "s = ": 1174, + "; c4 <= ((((16 * c2) + 15) < (n": 1175, + "sc": 1176, + "delta": 1177, + "mem": 1178, + ");\n }\n\n}\n": 1179, + "_par": 1180, + "[(i * N": 1181, + "DES_bs_combined *) (((char *) ": 1182, + "DES_bs_combined *) (((char *) DES_bs_": 1183, + ")) * ": 1184, + "][3": 1185, + "DES_bs_combined *) (((char *) DES_bs_all_p) + t))).": 1186, + " + ((": 1187, + ";\n }\n\n ": 1188, + "tot": 1189, + " - 2": 1190, + "ny": 1191, + "cp": 1192, + " = 0.": 1193, + "19": 1194, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).": 1195, + "pa": 1196, + "\\n\");\n }\n\n ": 1197, + "_sal": 1198, + "omp distribute parallel for simd ": 1199, + ") reduction(+:": 1200, + " & (": 1201, + "cry": 1202, + "sum = sum": 1203, + " += 2": 1204, + ") ? (": 1205, + "][j][i": 1206, + "}\n else": 1207, + "; j++)\n {\n ": 1208, + "[k]": 1209, + "struc": 1210, + ") shared(": 1211, + "), ": 1212, + "for (c3": 1213, + "mask": 1214, + "for (c2": 1215, + "[idx": 1216, + "][i1]": 1217, + "uint32": 1218, + "for (j = 0; j < 1": 1219, + "AR": 1220, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1221, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj": 1222, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1223, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj": 1224, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((": 1225, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj": 1226, + " logics[i];\n }\n\n ": 1227, + "abor": 1228, + "ffer": 1229, + "[i - 1": 1230, + "m_": 1231, + "AT": 1232, + "D5": 1233, + "teration": 1234, + "abort(": 1235, + "bound": 1236, + ")\n for (i = 0; i < 1000; ++i)\n {\n ": 1237, + "leng": 1238, + "96": 1239, + "*((vtype *) (&": 1240, + "val2": 1241, + "rhs[m": 1242, + "k * ": 1243, + "point": 1244, + "length": 1245, + "2;\n ": 1246, + " = 0.0;\n ": 1247, + " * (1 * 100": 1248, + "y * ": 1249, + ") > ": 1250, + "4)": 1251, + "][i][j][k] = ": 1252, + " = _mm_load": 1253, + "] += ": 1254, + "comp": 1255, + "omp parallel for private(i": 1256, + "arg": 1257, + "c3++)\n {\n ": 1258, + "c3++)\n {\n #pragma omp simd\n for (c4 = ": 1259, + "c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2": 1260, + ".i": 1261, + "PE": 1262, + "nt_": 1263, + "ce[": 1264, + "; col": 1265, + "vertices": 1266, + "omp parallel for default": 1267, + " >>": 1268, + " -= ": 1269, + "image": 1270, + "schedule (": 1271, + ")) ?": 1272, + "set_": 1273, + "return 1": 1274, + "1;\n ": 1275, + "offset": 1276, + ") ||": 1277, + "ore": 1278, + "gr": 1279, + "2.": 1280, + "nsi": 1281, + "[j] = ": 1282, + "for (m": 1283, + "free": 1284, + "ame": 1285, + "cols": 1286, + ") | (": 1287, + "boundry": 1288, + "boundryScale": 1289, + " = 0; m": 1290, + " *= boundryScale": 1291, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2": 1292, + ";\n }\n\n}\n\n": 1293, + ";\n u3": 1294, + "ss": 1295, + "fab": 1296, + "abort();\n\n": 1297, + "dpt": 1298, + "; i++)\n {\n ": 1299, + "table": 1300, + ") % ": 1301, + " + (-1)) / 16))) ?": 1302, + "[i] = i": 1303, + "it(": 1304, + "public.": 1305, + "for (i = 0; i < 64": 1306, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1307, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk": 1308, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1309, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk": 1310, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((": 1311, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk": 1312, + "yz": 1313, + ")) && (": 1314, + "large": 1315, + "TR": 1316, + "MD5": 1317, + ",k": 1318, + "nex": 1319, + ")\n {\n ": 1320, + "cont": 1321, + "umn": 1322, + " << ": 1323, + "vi": 1324, + "rec": 1325, + "cryp": 1326, + "_mul_ps(": 1327, + "cur_sal": 1328, + "; x": 1329, + "b[i]": 1330, + ".x": 1331, + "OR": 1332, + "_h": 1333, + "LL": 1334, + "5A": 1335, + "MD5_": 1336, + ";\n if (": 1337, + "_pro": 1338, + "ode": 1339, + "get": 1340, + "pos": 1341, + ") >": 1342, + "je": 1343, + "%f": 1344, + "(p": 1345, + "; c3": 1346, + "omp parallel for private (": 1347, + "YPE": 1348, + "][i1": 1349, + ") (": 1350, + "ment": 1351, + "ES": 1352, + " - 2)": 1353, + ", k": 1354, + "44": 1355, + ".0 * ": 1356, + "ARCH": 1357, + "if (((": 1358, + " of": 1359, + " *) malloc": 1360, + "ap": 1361, + "2) * ": 1362, + ");\n x": 1363, + "])) + (": 1364, + " = 0;\n}\n": 1365, + "ordered": 1366, + "lex": 1367, + " + 2)) / ": 1368, + "ith": 1369, + "chun": 1370, + "for (c3 = ": 1371, + "; i++)\n if (": 1372, + "us": 1373, + "dest": 1374, + " + (-1))) ? ((((": 1375, + "j + (-1))) ? ((16 * c2) + 15) : (n": 1376, + "j + (-1))) ? ((16 * c2) + 15) : (nj": 1377, + "3)": 1378, + "thread_num": 1379, + "(x, y": 1380, + " (nj": 1381, + "][c2": 1382, + ";\n }\n\n }\n\n ": 1383, + "rs": 1384, + "[3": 1385, + "] + ": 1386, + ";\n ": 1387, + "Ind": 1388, + "]) + ": 1389, + "gree": 1390, + "for (col": 1391, + "in2": 1392, + "eck": 1393, + " + OMP_xMax) + OMP_xMax) + ": 1394, + "cur_salt->": 1395, + "BF_current": 1396, + ") firstprivate": 1397, + "BF_current.": 1398, + "));\n ": 1399, + "cb": 1400, + ";\n\n}\n": 1401, + "}\n\n\n": 1402, + " += (": 1403, + "_C": 1404, + "); k": 1405, + ") && (i": 1406, + "];\n ": 1407, + "add_ps(": 1408, + " + 2)) / nk": 1409, + "dsum": 1410, + "_idx": 1411, + "int) ": 1412, + "num_threads": 1413, + "[i][k": 1414, + "[iel][": 1415, + "stats->": 1416, + "nu": 1417, + "; c2": 1418, + "ddiff": 1419, + "}\n else\n ": 1420, + "ip": 1421, + " + 3)) / ": 1422, + "chunk": 1423, + "_mm_mul_ps(": 1424, + ";\n\n\n": 1425, + "fe": 1426, + "for (int i = 0; i < 1": 1427, + "s[j]": 1428, + "weight": 1429, + " < N": 1430, + "loop": 1431, + " < (n": 1432, + "number": 1433, + " = 0; col": 1434, + "23": 1435, + "[(j * ": 1436, + "threads": 1437, + "ll": 1438, + "_row": 1439, + " *= boundryScale;\n ": 1440, + "#pragma omp": 1441, + " %d ": 1442, + "((2 * i": 1443, + "] = (": 1444, + " % ": 1445, + "low": 1446, + "omp_get_thread_num": 1447, + "Col": 1448, + ", c": 1449, + "rom": 1450, + "28": 1451, + "be": 1452, + "000000": 1453, + " <= ((((16 * c1) + 15) < (n": 1454, + "vl": 1455, + "face": 1456, + "omp_get_thread_num(": 1457, + "2.0 * ": 1458, + "m2": 1459, + "_TYPE": 1460, + "Num": 1461, + "fabs(": 1462, + "_parallel": 1463, + "tx": 1464, + "que": 1465, + " = col": 1466, + " + 3)) / nl": 1467, + "****": 1468, + "assign": 1469, + ".r": 1470, + ")) + ((": 1471, + "check": 1472, + " + 1)) / nj": 1473, + "last": 1474, + "return 0": 1475, + "if (n": 1476, + "yzInd": 1477, + "for (m = 0; m": 1478, + "struct ": 1479, + "\\n\", i": 1480, + "unsigned int ": 1481, + "p[": 1482, + "ux": 1483, + " <= ((": 1484, + "ld": 1485, + " ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk": 1486, + "larger": 1487, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16": 1488, + "pow": 1489, + "my": 1490, + "for (i = 0; i < n; i++)\n{\n ": 1491, + ");\n": 1492, + "graph->": 1493, + "zeta": 1494, + ")))) + (": 1495, + "rime": 1496, + " = _mm_add_ps(": 1497, + "foo": 1498, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1499, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl": 1500, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1501, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl": 1502, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((": 1503, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl": 1504, + "ixel": 1505, + "][i][j": 1506, + "._": 1507, + "IT": 1508, + "i + ": 1509, + "while (": 1510, + "ted": 1511, + "]);\n ": 1512, + "}\n\n }\n\n }\n\n ": 1513, + "_mm256": 1514, + " ((((nm": 1515, + "yte": 1516, + "2, ": 1517, + "ster": 1518, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1519, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm": 1520, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1521, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm": 1522, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((": 1523, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm": 1524, + "29": 1525, + "0F": 1526, + "76": 1527, + "_array": 1528, + "))) ^": 1529, + " * (sizeof(": 1530, + "500": 1531, + " << (": 1532, + "are": 1533, + " & (~": 1534, + "j = ": 1535, + "[ntemp": 1536, + "params.nx": 1537, + "bit._": 1538, + "lh": 1539, + "SI": 1540, + "i = 0; i": 1541, + "Th": 1542, + "][3]": 1543, + "rho": 1544, + "36": 1545, + "for (i = 1; i <= 1000": 1546, + ");\n }\n\n ": 1547, + ") / ni": 1548, + "ord": 1549, + "ker": 1550, + ", (MPI_": 1551, + "product": 1552, + "[l": 1553, + "for (i = j": 1554, + "))) + ((": 1555, + "for (col = 0; col": 1556, + "c1][c2": 1557, + "{\n ": 1558, + ")) + j": 1559, + "speeds[": 1560, + "for (int k": 1561, + "\n {\n ": 1562, + "[i] * ": 1563, + "for (i = 0; i < (": 1564, + "_parallel_": 1565, + "[i3][i2": 1566, + "= ((": 1567, + "xi": 1568, + "ato": 1569, + "EN": 1570, + "njac": 1571, + "3C": 1572, + "omp parallel for collapse(": 1573, + "sph": 1574, + ") private(": 1575, + "artic": 1576, + "3F": 1577, + "_bu": 1578, + "l++": 1579, + "temp = ": 1580, + ") + u": 1581, + "sav": 1582, + "static void ": 1583, + "omp_parallel_": 1584, + "))\n {\n ": 1585, + "Row": 1586, + "_in": 1587, + " *= boundryScale;\n u[": 1588, + "pre": 1589, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 1590, + "_n": 1591, + "test_omp_parallel_": 1592, + "(none": 1593, + "ucke": 1594, + "(((n": 1595, + "run": 1596, + "omp target parallel for simd ": 1597, + "&buf[": 1598, + "float *": 1599, + "; y": 1600, + "ere": 1601, + "iled": 1602, + "static, ": 1603, + "for (int i = 0; i < n": 1604, + "ori": 1605, + "t1": 1606, + "; i < k": 1607, + "for (j = ": 1608, + "t2": 1609, + "0 * (1 * 100": 1610, + "; j++)\n ": 1611, + ") 0x": 1612, + "geR": 1613, + ", z": 1614, + "Node": 1615, + "article": 1616, + " ^= ": 1617, + " - 1); i": 1618, + "31": 1619, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl": 1620, + ", _mm_mul_ps(": 1621, + "D[c3][c4] = (((double) c3) * (c4": 1622, + "D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 1623, + " << (32": 1624, + "sw": 1625, + "OMP_": 1626, + "g->": 1627, + "66": 1628, + ");\n if (": 1629, + "first": 1630, + "2[i]": 1631, + "indx": 1632, + "Res": 1633, + "[ARCH": 1634, + ") &&": 1635, + "tmp1 * ": 1636, + ";\n int j": 1637, + " >> 1": 1638, + "absVal(val": 1639, + "data->": 1640, + "float) ": 1641, + "[0][": 1642, + "; p": 1643, + "lex ": 1644, + "c1][c2] = (((double) ": 1645, + "c1][c2] = (((double) c1": 1646, + "] = 1": 1647, + "step": 1648, + "] - ": 1649, + "max_": 1650, + "}\n else\n {\n ": 1651, + ")) - (": 1652, + "nz": 1653, + "free(": 1654, + "map": 1655, + "date": 1656, + ".y": 1657, + "50": 1658, + "x = 0; ": 1659, + "AA": 1660, + "uint32_t ": 1661, + " < 16": 1662, + "; i++)\n for (j = 0; j < ": 1663, + "file": 1664, + ";\n\n ": 1665, + "my_": 1666, + "46": 1667, + " = c": 1668, + "else\n ": 1669, + "= (((": 1670, + "mean": 1671, + "14": 1672, + "\n abort();\n\n": 1673, + "_sha1": 1674, + ")) +": 1675, + "atoi": 1676, + "])) + ": 1677, + " - 1) * ": 1678, + "bel": 1679, + "nel": 1680, + "buffer": 1681, + "Se": 1682, + "u[i][j][k": 1683, + "ure": 1684, + "#pragma omp for": 1685, + "819": 1686, + "x[i]": 1687, + "crypt_": 1688, + "degree": 1689, + "ult ": 1690, + "[k][j]": 1691, + "ii": 1692, + "case": 1693, + "sition": 1694, + " += 2)\n ": 1695, + "label": 1696, + "c00": 1697, + "[2": 1698, + "linear": 1699, + "for (p = ": 1700, + ");\n\n ": 1701, + ") * ((": 1702, + "m3": 1703, + "dE": 1704, + ")\n{\n return": 1705, + "][5": 1706, + "x < ": 1707, + "->data": 1708, + "][2": 1709, + ") == 0": 1710, + "; ++k": 1711, + " (nk": 1712, + "sum = sum + i": 1713, + "sal": 1714, + "column": 1715, + "[v": 1716, + "sum)": 1717, + "UM": 1718, + " \", ": 1719, + "output": 1720, + "lob": 1721, + "ut": 1722, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (n": 1723, + "Comp": 1724, + " + (N": 1725, + "for (col = 0; col < ": 1726, + "8192": 1727, + "St": 1728, + "= (-1": 1729, + "BF_word": 1730, + "firstprivate(": 1731, + " += 1)\n{\n ": 1732, + "00000": 1733, + "fin": 1734, + "]);\n ": 1735, + "_IN": 1736, + "3276": 1737, + "->ve": 1738, + "curr": 1739, + "y(": 1740, + "_ptr": 1741, + ") || (": 1742, + "he": 1743, + "A[": 1744, + " <= ((((((": 1745, + "pow(": 1746, + "s; i++)\n{\n ": 1747, + ")\n{\n int i": 1748, + "\n ": 1749, + "BIT": 1750, + "pha": 1751, + "BF_current.S": 1752, + "buf[i]": 1753, + "*out": 1754, + "); c2": 1755, + "3))": 1756, + "gr->": 1757, + "B[c3][c4] = (((double) c3) * (c4": 1758, + "B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 1759, + "C[c3][c4] = (((double) c3) * (c4": 1760, + "C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 1761, + " = 0.0;\n ": 1762, + "; i++)\n if (buf[i]": 1763, + " = tmp": 1764, + "_id": 1765, + "safe": 1766, + "saved_": 1767, + "(x)": 1768, + "][m] + (": 1769, + ";\n u[": 1770, + "for (i = 0; i < 64; i++)\n if (buf[i]": 1771, + "))))\n abort();\n\n": 1772, + "our": 1773, + "ank": 1774, + "15": 1775, + "*((BF_word": 1776, + "*((BF_word *) (((": 1777, + "*((BF_word *) (((unsigned char *) ": 1778, + "*((BF_word *) (((unsigned char *) BF_current.S": 1779, + ".bit._": 1780, + " = 1.0": 1781, + "city": 1782, + "per": 1783, + "omp parallel for num_threads(": 1784, + "logics[": 1785, + " OR": 1786, + " OR par": 1787, + "DAT": 1788, + "ID": 1789, + "iteration": 1790, + "with": 1791, + "DATA": 1792, + "height": 1793, + "iff(": 1794, + "_INDE": 1795, + "_INDEX": 1796, + "eighbor": 1797, + "able": 1798, + "Di": 1799, + "box": 1800, + "xyzInd": 1801, + "col = col": 1802, + "col = col + 4": 1803, + "logics[1000": 1804, + "test_omp_parallel_for": 1805, + "DATA_TYPE": 1806, + "new_": 1807, + "element": 1808, + " + 1) * ": 1809, + ", a": 1810, + "[ARCH_INDEX": 1811, + "failed": 1812, + "vassign": 1813, + "}\n ": 1814, + "for (i = 1; i < (": 1815, + "TRI": 1816, + "; i++)\n{\n if (": 1817, + "_a": 1818, + "nor": 1819, + "[i]);\n}\n": 1820, + "_EN": 1821, + "_ps": 1822, + "is_": 1823, + ", double ": 1824, + "(*": 1825, + "iti": 1826, + " = _mm_load1": 1827, + "; j < ": 1828, + "2;\n ": 1829, + ") collapse(": 1830, + "j1": 1831, + "ELL": 1832, + "inue": 1833, + "s)": 1834, + "yer": 1835, + "C0": 1836, + "int p": 1837, + "fp": 1838, + "_CELL": 1839, + "_CELL_EN": 1840, + "_CELL_ENTRI": 1841, + "_CELL_ENTRIES": 1842, + ", p": 1843, + "continue": 1844, + ") - 1][": 1845, + ",i": 1846, + "ep": 1847, + "omp target teams distribute parallel for ": 1848, + "1.": 1849, + "2))": 1850, + "i + (-1))) ? ((16 * c1) + 15) : (n": 1851, + "i + (-1))) ? ((16 * c1) + 15) : (ni": 1852, + "2000": 1853, + "34": 1854, + "__": 1855, + "color": 1856, + " + (N_CELL_ENTRIES": 1857, + ")) * (1 * 100": 1858, + ")\n{\n double ": 1859, + "alpha": 1860, + "t, ": 1861, + "emp": 1862, + "for (i = 0; i < 1000; i++)\n{\n ": 1863, + "sje": 1864, + "printf(\"%": 1865, + " + i) + ": 1866, + "[0": 1867, + "input_": 1868, + ")) * (1 * 100))))": 1869, + "z1": 1870, + ") + y": 1871, + "roid": 1872, + ";\n }\n else\n {\n ": 1873, + "Dist": 1874, + "RS": 1875, + "}\n\n }\n\n }\n\n}\n": 1876, + ";\n }\n\n }\n\n ": 1877, + "u_ps(": 1878, + " | ": 1879, + "Thread": 1880, + "nsion": 1881, + "][j][i]": 1882, + ", x": 1883, + "mension": 1884, + "case ": 1885, + ") + j] = ": 1886, + "_v": 1887, + "[i];\n}\n": 1888, + "[4": 1889, + "char *": 1890, + "; c3 <= ((((16 * c1) + 15) < (n": 1891, + ";\n }\n\n #pragma omp simd\n for (c4 = ": 1892, + "lef": 1893, + "chan": 1894, + ") * c4": 1895, + "lhs": 1896, + "][k]": 1897, + " = 1; k": 1898, + "lastprivate(": 1899, + "l + (-1))) ? ((16 * c2) + 15) : (n": 1900, + "l + (-1))) ? ((16 * c2) + 15) : (nl": 1901, + "size_t ": 1902, + "(shared": 1903, + " + (N_CELL_ENTRIES * ((": 1904, + "[(i * (": 1905, + "centD": 1906, + "sqrt(": 1907, + "private.": 1908, + "geRank": 1909, + "] * nu": 1910, + "centDiff(": 1911, + "1 + ": 1912, + "tmp_": 1913, + "Cou": 1914, + "\\t": 1915, + "u_": 1916, + "x = ": 1917, + "ten": 1918, + "(&ctx": 1919, + "}\n\n }\n\n ": 1920, + "c5": 1921, + " * (ce[": 1922, + "A[c3][c4] = (((double) c3": 1923, + "A[c3][c4] = (((double) c3) * c4": 1924, + "A[c3][c4] = (((double) c3) * c4) / ni": 1925, + "jac": 1926, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj": 1927, + "ign": 1928, + " == 0)\n {\n ": 1929, + "sec": 1930, + "var": 1931, + "Bu": 1932, + "tid": 1933, + "line ": 1934, + "next": 1935, + "[y": 1936, + "}\n else": 1937, + "inline ": 1938, + ".0f": 1939, + "sum = 0;\n ": 1940, + "ytes": 1941, + "fjac": 1942, + "[i + 1]": 1943, + "))\n ": 1944, + "x_": 1945, + "vertex": 1946, + "align": 1947, + "for (p = &buf[": 1948, + "FFFF": 1949, + "1024": 1950, + ") - 1][((2 * i": 1951, + ") | (temp": 1952, + "[(k * ": 1953, + "test": 1954, + "4, ": 1955, + "unsigned char *": 1956, + "with ": 1957, + "[(i * 1": 1958, + "35": 1959, + "m + (-1))); c4++)\n {\n ": 1960, + "80": 1961, + "tab": 1962, + "jj * ": 1963, + "tra": 1964, + "OMP_xMax) + OMP_xMax": 1965, + " + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 1966, + "for (k = 1; k": 1967, + "A[(i * ": 1968, + "ass": 1969, + " ((double) ": 1970, + "std_": 1971, + "();\n ": 1972, + ", int *": 1973, + "round": 1974, + "_sub": 1975, + "lag": 1976, + "[3]": 1977, + "vel": 1978, + " - p": 1979, + "safelen(": 1980, + "];\n}\n": 1981, + "omp parallel for default(none": 1982, + "ace": 1983, + "cnt": 1984, + "0000000": 1985, + "5)": 1986, + "seed": 1987, + "; k++)\n {\n ": 1988, + " += 2)\n l++": 1989, + " += 2)\n l++;\n\n\n": 1990, + "atoi16": 1991, + "] *= boundryScale;\n u[": 1992, + "Table": 1993, + "ER": 1994, + "was": 1995, + " / (": 1996, + "DATA_TYPE) ": 1997, + "ull": 1998, + "32767": 1999, + "Result ": 2000, + ";\n }\n\n }\n\n }\n\n }\n\n ": 2001, + "aligned": 2002, + "atoi16[ARCH_INDEX": 2003, + "inste": 2004, + "instead": 2005, + "instead of": 2006, + "iel": 2007, + ") + (j": 2008, + "p1": 2009, + ") * (c2": 2010, + "A[((": 2011, + "t 1": 2012, + "yy": 2013, + "for (col = 0; col < 9": 2014, + "total_": 2015, + "dknown_sum": 2016, + ": Result ": 2017, + ": Result was": 2018, + " logics[i];\n }\n\n if (!": 2019, + " logics[i];\n }\n\n if (": 2020, + " + (-1)) / 16))) ? ((((n": 2021, + ";\n tmp": 2022, + ", s": 2023, + "m;\n ": 2024, + "_sq": 2025, + "RSComp": 2026, + "runtime": 2027, + " + (i * ": 2028, + ";\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2029, + "bucke": 2030, + "omp parallel for reduction(+: ": 2031, + "printf(\"%d": 2032, + "dynamic": 2033, + ")) ? (": 2034, + "steps": 2035, + "for (col = 0; col < 951": 2036, + "for (col = 0; col < 95100": 2037, + "for (col = 0; col < 95100; col": 2038, + "NUM": 2039, + "v1": 2040, + "logics[1000 / ": 2041, + "test_omp_parallel_for_": 2042, + " &= ": 2043, + "position": 2044, + "static,": 2045, + " - i": 2046, + "scan": 2047, + "simdlen(": 2048, + "[j][i": 2049, + "RSComplex ": 2050, + "Ar": 2051, + "];\n ": 2052, + " = ((((": 2053, + "omp parallel for private(j": 2054, + " * i": 2055, + "dia": 2056, + "ity": 2057, + "_to": 2058, + "input": 2059, + ");\n }\n\n}\n\n": 2060, + ") = ": 2061, + "A + i": 2062, + ", i)": 2063, + "DATA_TYPE) i": 2064, + "for (x = 0; ": 2065, + "Image": 2066, + "idmo": 2067, + "3.": 2068, + "stri": 2069, + "01": 2070, + "work": 2071, + ";\n p": 2072, + "fil": 2073, + ");\n ": 2074, + " - (2.0 * ": 2075, + "[i + 1][": 2076, + "18": 2077, + "cal": 2078, + "random": 2079, + " < 5; k": 2080, + "c1][c2] = (((double) c1) * (c2": 2081, + "sph_sha1": 2082, + " != 0": 2083, + "A[i]": 2084, + "acc": 2085, + "MD5_std_": 2086, + "OMP_Index": 2087, + "][0][0]": 2088, + "memcp": 2089, + "omp parallel for shared(col": 2090, + "y = ": 2091, + "saved_key": 2092, + "++;\n }\n\n}\n\n": 2093, + "))) ^ (": 2094, + "y < ": 2095, + "}\n else\n if (": 2096, + "][col": 2097, + "ing_": 2098, + "; i += ": 2099, + "\\n\");\n}\n": 2100, + "y = 0; ": 2101, + "for (k = ": 2102, + "AD": 2103, + "sqrt": 2104, + " : ": 2105, + "omp parallel for schedule (": 2106, + "lf": 2107, + ");\n }\n\n ": 2108, + "zero": 2109, + "scanf(": 2110, + "pixel": 2111, + "ype": 2112, + "xx": 2113, + "centroid": 2114, + "Grid": 2115, + "nce": 2116, + ") - d": 2117, + "->me": 2118, + ";\n }\n\n }\n\n}\n\n": 2119, + "Array": 2120, + "ave": 2121, + "s++": 2122, + "[ii": 2123, + "255": 2124, + "for (int k = 0; k": 2125, + "for (c3 = 16 * c1": 2126, + "33CC": 2127, + " & (~x": 2128, + ", int n": 2129, + "flu": 2130, + "ome": 2131, + "[i]]": 2132, + "total": 2133, + "Ve": 2134, + "lhs[n + 3": 2135, + "for (i = 0; i < 1000; i++)\n {\n ": 2136, + "reg": 2137, + "AN": 2138, + "ts": 2139, + "ntemp": 2140, + "os": 2141, + " == 3": 2142, + "[indx": 2143, + ";\n }\n\n if (": 2144, + "_count": 2145, + "t = ": 2146, + "_per": 2147, + "nter": 2148, + " = %d": 2149, + " %f": 2150, + "j2": 2151, + "str->": 2152, + "i2": 2153, + "num_vertices": 2154, + " + (-1))) < (nm": 2155, + "prime": 2156, + "ath": 2157, + "cing": 2158, + " &= 0x": 2159, + "local": 2160, + "for (i = 0; i < 64; i++)\n if (buf[i] != (": 2161, + " &= 0x3F": 2162, + " &= 0x3FC": 2163, + "))) ^ (*((vtype *) (&": 2164, + "))) ^ (*((vtype *) (&k": 2165, + "))), (": 2166, + "vtype a": 2167, + "))) + (": 2168, + ") * j": 2169, + "0 + (": 2170, + "!= ": 2171, + "conte": 2172, + "int i": 2173, + "node *": 2174, + " = 0; c2": 2175, + "flag": 2176, + "int)": 2177, + "1] = ": 2178, + "for (c2 = 0; c2": 2179, + "k + (-1))) ? ((16 * c2) + 15) : (n": 2180, + "k + (-1))) ? ((16 * c2) + 15) : (nk": 2181, + "_rows": 2182, + "----": 2183, + "for (i = 0; i <= ": 2184, + "da": 2185, + ", m": 2186, + "content": 2187, + "_bytes": 2188, + "[k], ": 2189, + "[%d": 2190, + "[i][ind": 2191, + "[i + 1][ind": 2192, + "coord": 2193, + " == '": 2194, + "forcing": 2195, + "SIZ": 2196, + "SIZE": 2197, + "z * ": 2198, + "va": 2199, + "for (i = 0; i < n; i++)\n ": 2200, + "ource": 2201, + "veri": 2202, + "s[v": 2203, + "update": 2204, + "DF": 2205, + "][(": 2206, + " + (jj * ": 2207, + " = 0;\n ": 2208, + "[i], ": 2209, + "c8": 2210, + "skip": 2211, + "R0": 2212, + " &&": 2213, + ")) * (1 * 100))))) + i": 2214, + "jtr": 2215, + "pc": 2216, + "ute": 2217, + "L0": 2218, + "dimension": 2219, + "jtr_sha": 2220, + "j + (-1))) ? ((16 * c1) + 15) : (n": 2221, + "j + (-1))) ? ((16 * c1) + 15) : (nj": 2222, + ", double *": 2223, + "u2": 2224, + " < ((": 2225, + "ities": 2226, + "cs": 2227, + "Neighbor": 2228, + "++)\n {\n for (c3 = 16 * c1": 2229, + "min_": 2230, + "[i];\n ": 2231, + "star": 2232, + "comm": 2233, + "if (i == ": 2234, + "lock(&": 2235, + ".real": 2236, + "skip_bytes": 2237, + "adj": 2238, + "for (i = 0; i < 20; ++i)\n{\n ": 2239, + "_M": 2240, + ";\n #pragma ": 2241, + "state": 2242, + "m0": 2243, + "for (i = 0; i < size": 2244, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))": 2245, + " - 1][i2": 2246, + "a2": 2247, + ") &": 2248, + " < 5; m": 2249, + " * u": 2250, + " + j": 2251, + ".imag": 2252, + "private.d_": 2253, + "avera": 2254, + "v[": 2255, + "sin": 2256, + "omp parallel for reduction(+: l": 2257, + "omp parallel for default(shared": 2258, + "[col]": 2259, + "[ig": 2260, + "diag": 2261, + "CL": 2262, + "or |": 2263, + "gh": 2264, + " + p": 2265, + ");\n}\n\nvoid ": 2266, + "; row": 2267, + "][m": 2268, + "cmp": 2269, + "[i3 - 1][i2": 2270, + "));\n}\n": 2271, + "X[": 2272, + " private(": 2273, + " * c": 2274, + "m1]": 2275, + "gr->vl": 2276, + "b = ": 2277, + "][4]": 2278, + "foo(": 2279, + "rand() %": 2280, + "layer": 2281, + "p1]": 2282, + "for (index": 2283, + "_temp": 2284, + "imag": 2285, + "2048 + 1)": 2286, + ")\n {\n ": 2287, + "aux": 2288, + "pow(dt": 2289, + " = 0; index": 2290, + "; index": 2291, + "exclusiv_bit_or = ": 2292, + "dpt *= ": 2293, + "dpt *= dt": 2294, + "Cities": 2295, + "logic_and = ": 2296, + "logic_and = logic_and": 2297, + "logic_and = logic_and &&": 2298, + "bit_and = ": 2299, + "bit_and = bit_and": 2300, + "bit_and = bit_and &": 2301, + "logics[i] = 1": 2302, + "logic_or = ": 2303, + "logic_or = logic_": 2304, + "logic_or = logic_or ": 2305, + "logic_or = logic_or ||": 2306, + "bit_or = ": 2307, + "bit_or = bit_": 2308, + "bit_or = bit_or |": 2309, + " | x": 2310, + " * r": 2311, + "[i - 1]": 2312, + "exp": 2313, + "c_": 2314, + "x1": 2315, + ") * (((": 2316, + "))\n {\n ": 2317, + "seq": 2318, + "for (index = 0; index": 2319, + "^:": 2320, + ";\n if (": 2321, + "core": 2322, + "current_": 2323, + " + (N_CELL_ENTRIES * ((0 + (": 2324, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100": 2325, + "order": 2326, + " %d\\n\", ": 2327, + "pageRank": 2328, + "|:": 2329, + "tition": 2330, + "][0]))), (": 2331, + "_ps((": 2332, + " *) malloc(": 2333, + ",b": 2334, + " with ": 2335, + "filter": 2336, + "_l": 2337, + "1f": 2338, + "exclusiv_bit_or = exclusiv_bit_or": 2339, + "exclusiv_bit_or = exclusiv_bit_or ^": 2340, + "^:exclusiv_bit_or": 2341, + "cess": 2342, + "&&:": 2343, + "&&:logic_and": 2344, + "; ++j)\n {\n ": 2345, + "t + k": 2346, + "particle": 2347, + "4.0 * ": 2348, + "ey": 2349, + "omp parallel for reduction(+:sum": 2350, + "[i1]": 2351, + "ew": 2352, + "a1": 2353, + "fac1": 2354, + "unsigned char ": 2355, + "for (int i = 1; i": 2356, + "Temp": 2357, + "-:": 2358, + "Count": 2359, + "the": 2360, + "16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni": 2361, + "for (j = 1; j < (": 2362, + "Distance": 2363, + "to ": 2364, + "&:": 2365, + "AND": 2366, + "[b": 2367, + "left": 2368, + "&:bit_and": 2369, + "||:": 2370, + "||:logic_or": 2371, + "|:bit_or": 2372, + " / 1": 2373, + "ive": 2374, + "list": 2375, + "n_pro": 2376, + " AND": 2377, + "visi": 2378, + " 0x": 2379, + "y = 0; y < ": 2380, + "unc": 2381, + "[(i * 2048": 2382, + "; i++)\n{\n if (!": 2383, + "known_pro": 2384, + "for (i = 0; i < 20; ++i)\n {\n ": 2385, + ")\n {\n result++;\n fprintf(stderr, \"Error in logic": 2386, + " AND par": 2387, + ")\n {\n result++;\n fprintf(stderr, \"Error in BIT": 2388, + "kernel": 2389, + "4.0": 2390, + "sse": 2391, + " + (-1)) <": 2392, + " + (-1)) :": 2393, + "[row": 2394, + "_t *": 2395, + ") + k] * ": 2396, + "UL": 2397, + "for (int i = 0; i < N": 2398, + "37": 2399, + " + (jj * params.nx": 2400, + "1010": 2401, + "a[i] = ": 2402, + "#pragma omp ordered": 2403, + "cluster": 2404, + "u[m": 2405, + "1000 * (": 2406, + "1000 * (1000": 2407, + "1000 * (1000 + 1)) / ": 2408, + "j, ": 2409, + ") + 2": 2410, + "27": 2411, + "A, ": 2412, + " < count": 2413, + "A + i) + k": 2414, + "[i][k] * ": 2415, + "for (c1": 2416, + "for (size_t ": 2417, + "; jj": 2418, + ") + 1)": 2419, + "13": 2420, + "lobal": 2421, + "runtime)": 2422, + "exit(": 2423, + "for (i = 0; i < 10": 2424, + "s[j].": 2425, + "(x, y, z": 2426, + "ds": 2427, + "= (*((": 2428, + "*((C": 2429, + "][i][j][k] = lhs[": 2430, + "gest": 2431, + ") + p": 2432, + "47": 2433, + " = 1.": 2434, + "_cell": 2435, + "Value": 2436, + "png": 2437, + "digest": 2438, + " /= ": 2439, + "j + ": 2440, + "ided": 2441, + "((sizeof(": 2442, + " * z": 2443, + "c9": 2444, + ") - ((": 2445, + " + 2]": 2446, + ") / (": 2447, + "mj": 2448, + " = ((double) ": 2449, + ") + n": 2450, + "word0": 2451, + ");\n }\n\n }\n\n}\n": 2452, + "out_": 2453, + "[index]": 2454, + "84": 2455, + "lam": 2456, + ")\n p[": 2457, + "grid->": 2458, + "if ((i": 2459, + "der": 2460, + ")) ||": 2461, + "sub": 2462, + ", i, j": 2463, + " < 4": 2464, + ") + x": 2465, + ");\n b": 2466, + " = 1; ": 2467, + " <= (grid_points[1]": 2468, + "ublic.": 2469, + "iface": 2470, + " (&buf[": 2471, + "c1 <=": 2472, + "in_": 2473, + "info": 2474, + "[index], ": 2475, + "] * nu;\n u[": 2476, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) <": 2477, + " + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16": 2478, + " + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) :": 2479, + " (ni": 2480, + "ature": 2481, + " <= (grid_points[2]": 2482, + "hz": 2483, + "sor": 2484, + "][0][0][": 2485, + "c[iel": 2486, + "[(((": 2487, + ", )": 2488, + "input->": 2489, + "jo": 2490, + "OL": 2491, + "] += u[": 2492, + "vb": 2493, + " = 1;\n ": 2494, + "send": 2495, + "NY": 2496, + "i, int ": 2497, + "[ie": 2498, + "2D": 2499, + "Point": 2500, + "dev": 2501, + "[(int) ": 2502, + "; c2++)\n {\n ": 2503, + "x * ": 2504, + "5]": 2505, + "][i][j][k] - (": 2506, + " == 1)\n {\n ": 2507, + "; j++)\n {\n if (": 2508, + ".z": 2509, + "for (m = 0; m < 5; m": 2510, + "Com": 2511, + "26": 2512, + "pass": 2513, + " + r": 2514, + "][j][k]": 2515, + "store": 2516, + "tz": 2517, + "_SIZE": 2518, + "ter ": 2519, + "_buff": 2520, + "0.01": 2521, + "value[col": 2522, + " <= n": 2523, + "RE": 2524, + "for (i = 0; i < 1024": 2525, + ") += (*((": 2526, + "double x": 2527, + "ner": 2528, + ")\n ": 2529, + "ase": 2530, + " = ((-": 2531, + "ack": 2532, + "4 = ": 2533, + "dEo": 2534, + " <= ((((((n": 2535, + " + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 2536, + ") num_threads(": 2537, + "t3": 2538, + ") + k]": 2539, + "Comm": 2540, + "dir": 2541, + "ser": 2542, + "verif": 2543, + ") + (((": 2544, + ")))\n {\n ": 2545, + ".t": 2546, + "(((((": 2547, + "] + (": 2548, + "rhs[k": 2549, + "key_": 2550, + "force": 2551, + "*b": 2552, + ", _mm_mul_ps(a": 2553, + "); c2++)\n {\n for (c3 = 16 * c1": 2554, + ";\n }\n\n }\n\n for (c3 = ": 2555, + "fail": 2556, + "for (int i = 0; i < n; i++)\n{\n ": 2557, + "ET": 2558, + "qu": 2559, + "Mask": 2560, + "g_": 2561, + "double) (": 2562, + "\n\n": 2563, + ";\n}\n\n\nint ": 2564, + "mac": 2565, + " | tmp": 2566, + " * j": 2567, + "ertex": 2568, + "for (j = 0; j < n": 2569, + "00; i++)\n{\n ": 2570, + ") += (*((A + i) + k": 2571, + "i = ": 2572, + "}\n else\n {\n ": 2573, + "5 - 1": 2574, + " <= 4": 2575, + "++;\n }\n\n}\n\nint ": 2576, + "head": 2577, + "_mm256_": 2578, + "tmp1": 2579, + "densi": 2580, + " * 16) < 0) ? (-((-nj": 2581, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-": 2582, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj": 2583, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((": 2584, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj": 2585, + ");\n if (": 2586, + ";\n }\n\n ": 2587, + "ot": 2588, + "; k++)\n {\n ": 2589, + ";\n printf(\"": 2590, + ") / 8": 2591, + "for (index = 0; index < count": 2592, + ") + j] += ": 2593, + "hi": 2594, + "++)\n{\n for (": 2595, + "swap": 2596, + "*((C + i) + ": 2597, + "_bar": 2598, + "high": 2599, + "..": 2600, + "array[x": 2601, + "compute": 2602, + "density": 2603, + "++)\n ": 2604, + "coun": 2605, + ", 0, 0": 2606, + ") + z": 2607, + "na": 2608, + "Grid[(": 2609, + "source": 2610, + "1 - val2": 2611, + "[(int) fi": 2612, + "}\n else\n ": 2613, + ", \"%": 2614, + " ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16))": 2615, + ") - (tmp1 * ": 2616, + ") - (tmp1 * njac": 2617, + "ue[m": 2618, + "_pad": 2619, + "for (index = 0; index < count; index": 2620, + "_of": 2621, + "cmp(": 2622, + "][i][j][k];\n ": 2623, + "for (i = 0; i < len": 2624, + "=%f": 2625, + "edges_": 2626, + "1)": 2627, + "is_larger": 2628, + "ard": 2629, + "pstr->": 2630, + "ice": 2631, + ") * n": 2632, + "atom": 2633, + "crypt_out": 2634, + "ary": 2635, + "; k++)\n{\n ": 2636, + " * d": 2637, + "m + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 2638, + "00F": 2639, + "sid": 2640, + "for (j = 0; j < 4": 2641, + "))\n {\n num_": 2642, + "))\n {\n num_failed": 2643, + "))\n {\n num_failed++;\n }\n\n}\n\nint ": 2644, + "Dat": 2645, + "Datat": 2646, + "Datatype": 2647, + "ck": 2648, + ") + (-1": 2649, + "else\n ": 2650, + "u[(": 2651, + "for (i = 0; i < 20; i++)\n{\n if (!": 2652, + " = (1000 * (1000 + 1)) / ": 2653, + " = (1000 * (1000 + 1)) / 2;\n ": 2654, + ")\n for (i = 1; i <= 1000": 2655, + "Score": 2656, + "test_rank": 2657, + "********": 2658, + "\", &": 2659, + "ob": 2660, + "4c": 2661, + "A_": 2662, + "(int x": 2663, + "omp target teams distribute parallel for simd ": 2664, + "Pro": 2665, + "regis": 2666, + " = f": 2667, + "; i++)\n ": 2668, + "ication": 2669, + " (nm": 2670, + "][1] = ": 2671, + "[i] - ": 2672, + "j, int ": 2673, + ".0f * ": 2674, + ";\n float ": 2675, + "A[i][j]": 2676, + "a[i] = i": 2677, + "ant": 2678, + "->n_bar": 2679, + ", sizeof(": 2680, + "df": 2681, + "_xx": 2682, + "; ++k)\n {\n ": 2683, + "][0] = ": 2684, + "register ": 2685, + "[0] = ": 2686, + "Datatype) 0x": 2687, + "Datatype) 0x4c": 2688, + "Datatype) 0x4c000": 2689, + ",j,k": 2690, + "for (x = 0; x < ": 2691, + "; j++)\n for (i = j": 2692, + "omp parallel for reduction(+: l) collapse(": 2693, + "86": 2694, + "erature": 2695, + " + (n": 2696, + " + (-1)) / 16)) <": 2697, + " + (-1)) / 16)) :": 2698, + "BB": 2699, + "7B": 2700, + "0) ? (": 2701, + "k + 1": 2702, + ", (MPI_Datatype) 0x4c000": 2703, + "public.in2": 2704, + "cond": 2705, + "graph->num_vertices": 2706, + ");\n}\n\n\n": 2707, + " = 0.5": 2708, + "; ++i": 2709, + "next_": 2710, + " & x": 2711, + "id]": 2712, + "_cpu": 2713, + "++;\n": 2714, + "Lo": 2715, + "inte": 2716, + "erence": 2717, + "sum = sum + (": 2718, + " < 3": 2719, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))": 2720, + "go": 2721, + ", d": 2722, + "1_": 2723, + "ffff": 2724, + "Re": 2725, + "k + ": 2726, + "l + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n ": 2727, + " + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 2728, + "][0]))), (*((vtype *) (&": 2729, + "#pragma omp parallel for private (": 2730, + " = -1": 2731, + ");\n }\n\n if (": 2732, + "100": 2733, + "x2": 2734, + "ym": 2735, + "v < ": 2736, + "start_": 2737, + "a[i][j]": 2738, + "vassign[iel][": 2739, + "Comm) 0x": 2740, + "Comm) 0x44": 2741, + "Comm) 0x44000000": 2742, + "_mm_load": 2743, + "_X": 2744, + "OMP_y": 2745, + "OMP_yMax": 2746, + ") + j] = (((": 2747, + "; c4 <= ((((((": 2748, + "const int ": 2749, + ") < 0.01": 2750, + "b[i][j]": 2751, + "bk": 2752, + "px": 2753, + "for (int j = 0; j < n": 2754, + ");\n return ": 2755, + "omp parallel for schedule(static": 2756, + "Off": 2757, + "inter": 2758, + "ms": 2759, + "tmp2) * ": 2760, + "dz": 2761, + "512_": 2762, + ")) = ": 2763, + "radi": 2764, + " * ((i": 2765, + "float p": 2766, + " + 1][k": 2767, + " <= (grid_points[0]": 2768, + "suma": 2769, + "[i];\n": 2770, + "n = ": 2771, + "uint64": 2772, + ";\n }\n\n ": 2773, + "set_lock(&": 2774, + ", (MPI_Comm) 0x44000000": 2775, + "c = ": 2776, + " & 3": 2777, + "-7": 2778, + "][i] = ": 2779, + "at(&": 2780, + "c7": 2781, + "logics[i] = 0;\n}\n": 2782, + " > 0": 2783, + " :": 2784, + "NX": 2785, + "':": 2786, + "rowptr": 2787, + "[k] = ": 2788, + "printf(\"\\n\");\n}\n": 2789, + "v = 0; ": 2790, + " - 2); k": 2791, + " = (-": 2792, + ") / 1": 2793, + "_con": 2794, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 2795, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni": 2796, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(n": 2797, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni": 2798, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((": 2799, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni": 2800, + "acti": 2801, + "malloc(": 2802, + "ind + ": 2803, + "tail": 2804, + "l + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 2805, + " << (32 - 1": 2806, + "s[i] = ": 2807, + "; v": 2808, + "um_": 2809, + " + (b": 2810, + " - first": 2811, + "ang": 2812, + "\\n\");\n ": 2813, + "Bo": 2814, + "s[(": 2815, + "i;\n ": 2816, + "curr_": 2817, + "stride": 2818, + "uint32_t": 2819, + "lhs[n + 2": 2820, + " - (lhs[n": 2821, + ")) && (i": 2822, + "1);\n ": 2823, + "dssp": 2824, + ") == 2": 2825, + "(&ctx, ": 2826, + "case '": 2827, + "rite": 2828, + "elem_": 2829, + "INT": 2830, + "[c1][c2] = (((double) c1) * (c2": 2831, + "))) ^ (*((vtype *) (&k[": 2832, + "vtype ": 2833, + " = 0; row": 2834, + " - x": 2835, + "omp parallel for private(c2": 2836, + "_matrix": 2837, + "ext": 2838, + " * (*((": 2839, + " ((temp": 2840, + "for (j = 1; j <= ((": 2841, + "elem_at(&": 2842, + " + 2)": 2843, + "j = 0; j": 2844, + " = i + 1": 2845, + " >= 0": 2846, + "[%d]": 2847, + "\\n\");\n ": 2848, + "_mo": 2849, + "[k][j][i": 2850, + "sna": 2851, + "snake": 2852, + "][i1 - 1]": 2853, + ", int y": 2854, + "center": 2855, + " + 1][i2": 2856, + "i < ": 2857, + "));\n *((C + i) + ": 2858, + "for (i = 1; i <= (grid_points[0]": 2859, + "for (i = 1; i <= (grid_points[0] - 2)": 2860, + "; c1": 2861, + "char ": 2862, + "); c4": 2863, + "][ii": 2864, + ") + ((-1": 2865, + "0FF": 2866, + " - 1); i++)\n{\n ": 2867, + "for (i1": 2868, + "Buf": 2869, + "rection": 2870, + ")) + i": 2871, + ");\n ": 2872, + ";\n if (": 2873, + " *out": 2874, + "srcGrid[(": 2875, + "live": 2876, + "[], ": 2877, + " + (((": 2878, + "[i3][i2][i1]": 2879, + ", i, ": 2880, + "\\n\", i, ": 2881, + ")\n{\n int sum": 2882, + ") - 1) / 16))) : (((": 2883, + "[i] += ": 2884, + "v = 0; v < ": 2885, + "mer": 2886, + "[v]": 2887, + " (nl": 2888, + "ment_": 2889, + "so": 2890, + "rand() % 1": 2891, + " <= (grid_points[1] - 2)": 2892, + "m + (-1))) ? ((16 * c2) + 15) : (n": 2893, + "counter": 2894, + "][x": 2895, + "fra": 2896, + "tsteps": 2897, + "long long ": 2898, + "row = 0; row": 2899, + ") == 2) && (i": 2900, + " <= (grid_points[2] - 2); k": 2901, + ";\n sum = 0;\n ": 2902, + "2] = 1;\n ": 2903, + "97": 2904, + "; l": 2905, + "69": 2906, + "omp distribute parallel for ": 2907, + "comz": 2908, + "}\n\n ": 2909, + "[ie][": 2910, + ";\n u2 = ": 2911, + "F4": 2912, + "));\n}\n\n": 2913, + ") + 3": 2914, + "for (i = 0; i < N; i++)\n ": 2915, + "v2[i]": 2916, + "tot_": 2917, + ") * 1": 2918, + " + (2 * ": 2919, + "[i + 1][j]": 2920, + "queue": 2921, + "tmp_vec": 2922, + "3333": 2923, + ")\n p[2] = ": 2924, + ")\n{\n if ((": 2925, + " == (": 2926, + "gers": 2927, + "(i & 3": 2928, + "(i & 3) == 2) && (i": 2929, + "(i & 3) == 2) && (i >= ": 2930, + "(i & 3) == 2) && (i >= 18": 2931, + "(i & 3) == 2) && (i >= 18)) && (i": 2932, + ")) ? (((": 2933, + "for (j = 1; j <= (grid_points[1] - 2)": 2934, + "[i][j - 1]": 2935, + "test_rank_array": 2936, + "nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj": 2937, + ";\n u1 = ": 2938, + ";\n u3 = ": 2939, + ";\n u3 += ": 2940, + "vtype *out": 2941, + " = (*out": 2942, + ") ^ x": 2943, + "diff = ": 2944, + " != (-1": 2945, + "rounding_": 2946, + "rounding_error": 2947, + "known_product": 2948, + "integers": 2949, + "integers: Result was": 2950, + "integers: Result was %d ": 2951, + "integers: Result was %d instead of": 2952, + "t 1.": 2953, + "t 1.\\n\");\n }\n\n ": 2954, + "t 2.": 2955, + "t 2.\\n\");\n }\n\n ": 2956, + "logics[i] = 0": 2957, + "y1": 2958, + "ij": 2959, + "edges_array": 2960, + "for (k = 1; k <= (grid_points[2] - 2); k": 2961, + ";\n double ": 2962, + "coe": 2963, + "; i <= ": 2964, + "dd": 2965, + "ted_": 2966, + " ^ ": 2967, + " & 0x": 2968, + ";\n int known_sum": 2969, + "logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2970, + "2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2971, + "x * x": 2972, + "ans": 2973, + ")) + 8": 2974, + "lhs[j": 2975, + "Alive": 2976, + " == (-1": 2977, + "for (i = 0; i < 1000; i++)\n{\n logics[i] = 0;\n}\n": 2978, + "[m]": 2979, + "buf[1": 2980, + " += (((": 2981, + "for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2982, + " = 0;\n logics[1000 / ": 2983, + " = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2984, + "j_temp": 2985, + "bkdf": 2986, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 2987, + " >= (((": 2988, + ": %": 2989, + ";\n\n}\n\n": 2990, + "x = (": 2991, + "A[(i * N": 2992, + "omp parallel for collapse(2)": 2993, + "Diff": 2994, + "s[k": 2995, + "S->": 2996, + "[i];\n ": 2997, + "return (": 2998, + "uint8": 2999, + ") schedule(static,": 3000, + " of ": 3001, + "bkdf2": 3002, + "p->": 3003, + "name": 3004, + "tMask": 3005, + "sje[ntemp": 3006, + "[ie][iface": 3007, + "_mm_store": 3008, + "k = ": 3009, + "_sum": 3010, + ") & 0x": 3011, + "i + 1": 3012, + ";\n else\n ": 3013, + "56": 3014, + " + (-1))) < (nm + (-1))) ? ((((": 3015, + "nm * 16) < 0) ? (-((-": 3016, + "nm * 16) < 0) ? (-((-nm": 3017, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-": 3018, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm": 3019, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm) + (-16)) - 1) / (-16)) : (((": 3020, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm) + (-16)) - 1) / (-16)) : (((nm": 3021, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm) + (-16)) - 1) / (-16)) : (((nm + 16) - 1) / 16))": 3022, + " = x00": 3023, + ";\n *out": 3024, + "A9": 3025, + "r2": 3026, + "rsd": 3027, + "1.0 - (": 3028, + "_new": 3029, + "node->": 3030, + "2000 - 1": 3031, + "23 * ": 3032, + "data[(i * (": 3033, + "elements": 3034, + "n2": 3035, + "ciph": 3036, + "; ii": 3037, + "inline static void ": 3038, + "cbc": 3039, + "average": 3040, + "[((i": 3041, + "[id": 3042, + "[i3 + 1][i2": 3043, + "orig": 3044, + "];\n": 3045, + "grid[": 3046, + "direction": 3047, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100))) + ((": 3048, + ") num_threads": 3049, + "yload": 3050, + " + (-1)); c2++)\n {\n ": 3051, + "3, ": 3052, + "omp parallel for default(shared) private(i": 3053, + "for (i = 0; i < N; i++)\n{\n ": 3054, + "[i][0]": 3055, + "; (": 3056, + "k1": 3057, + "u = ": 3058, + "[i - 1][j]": 3059, + "->content": 3060, + "}\n\n }\n\n }\n\n}\n\n": 3061, + "G->": 3062, + "cand": 3063, + "8 * ((": 3064, + "8 * ((2000 - 1": 3065, + "8 * ((2000 - 1) / 8": 3066, + "8 * ((2000 - 1) / 8)) + 8": 3067, + " * 16) < 0) ? (-((-nk": 3068, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-": 3069, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk": 3070, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((": 3071, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((nk": 3072, + "payload": 3073, + "elem": 3074, + "sym": 3075, + "*((vtype": 3076, + "iv": 3077, + "_po": 3078, + " != ((": 3079, + "for (k = 0; k < 5; k": 3080, + "[(i * 2048) + j]": 3081, + "strlen(": 3082, + " * (j": 3083, + "C5": 3084, + "verification": 3085, + "lose": 3086, + "for (j = 1; j <= ((last": 3087, + "_re": 3088, + "for (v = 0; v < ": 3089, + "columns": 3090, + "++)\n {\n ": 3091, + "j3": 3092, + " * 16": 3093, + "; i++)\n{\n for (j = 0; j < N": 3094, + "lhs[n + 4": 3095, + ";\n vtype x00": 3096, + " << (32 - ": 3097, + "[i + ": 3098, + "; v++)\n{\n ": 3099, + "resid": 3100, + ".c": 3101, + "gb": 3102, + "rand() % ": 3103, + ") firstprivate (": 3104, + "ED": 3105, + "final": 3106, + "output_": 3107, + "active": 3108, + "gen": 3109, + "][c": 3110, + "dt * ": 3111, + "hal": 3112, + "bv": 3113, + "pcmor": 3114, + "0.0f": 3115, + "j < ": 3116, + "disp": 3117, + "p[i] = ": 3118, + "omp parallel for\n ": 3119, + "joh": 3120, + ".5": 3121, + "c1 >= (((": 3122, + "L2": 3123, + "));\n }\n\n}\n\n": 3124, + ") + r": 3125, + " + (-1))) < (nk": 3126, + " + (-1))) : (nk": 3127, + ")) ^": 3128, + ";\n }\n\n }\n\n }\n\n }\n\n if ((": 3129, + "; j2": 3130, + "[i1": 3131, + "3.0": 3132, + "base": 3133, + "hh": 3134, + "1024 + 1)": 3135, + " = (int": 3136, + "float per": 3137, + "double val": 3138, + "shif": 3139, + "(int *": 3140, + "for (i = 1; i <= 1000; i++)\n{\n ": 3141, + "fac1 * ": 3142, + ") + j] = (((DATA_TYPE) i": 3143, + "max = ": 3144, + "] = ((": 3145, + "AliveNeighbor": 3146, + "Start": 3147, + "righ": 3148, + "1, double ": 3149, + "0 = ": 3150, + "x[": 3151, + "c)": 3152, + ".tv_": 3153, + "_cols": 3154, + "3 = ": 3155, + "ir": 3156, + "float percentDiff(": 3157, + "float percentDiff(double val": 3158, + "float percentDiff(double val1, double ": 3159, + "float percentDiff(double val1, double val2": 3160, + "lhs[i][j][k": 3161, + "sup": 3162, + ");\n double ": 3163, + "team": 3164, + " = 0.0;\n ": 3165, + "mid": 3166, + "tmor": 3167, + " + 1)) + j": 3168, + " & m": 3169, + "; i++)\n{\n for (int j = 0; j < ": 3170, + "tag": 3171, + ")) - ": 3172, + "inal": 3173, + "s[(i": 3174, + "numAliveNeighbor": 3175, + ";\n\n }\n\n}\n": 3176, + "percentDiff(": 3177, + ")));\n}\n": 3178, + "pos_": 3179, + " = _mm_load1_ps(": 3180, + "][i][j1": 3181, + "Y[": 3182, + ") + j];\n }\n\n }\n\n}\n": 3183, + ") * p": 3184, + "Number": 3185, + "ax": 3186, + "temp_": 3187, + "memcpy(": 3188, + "); i++)\n{\n ": 3189, + "; n": 3190, + " + u": 3191, + "m_temp": 3192, + ")\n{\n if (": 3193, + " + i)": 3194, + ") != ": 3195, + " * (sizeof(int": 3196, + "ns": 3197, + "last_": 3198, + "john_": 3199, + "_min": 3200, + "nk * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((nk": 3201, + "a = ": 3202, + "zz": 3203, + "time(": 3204, + "pla": 3205, + "729": 3206, + "opad": 3207, + "][k][j][i]": 3208, + "[(i * 512": 3209, + ";\n ": 3210, + " << 1": 3211, + "s[i][j][k": 3212, + "2) + 1": 3213, + "alive": 3214, + "2) + (": 3215, + "Of": 3216, + "from": 3217, + "scal": 3218, + "for (i = 0; i < num_": 3219, + "0, ": 3220, + "i;\n}\n": 3221, + "c = c": 3222, + "]);\n}\n": 3223, + "Set": 3224, + "for (i = 0; i < 10000": 3225, + "norm": 3226, + "v1[i] * ": 3227, + "v1[i] * v2[i]": 3228, + "}\n ": 3229, + " == 0)\n {\n ": 3230, + "rowstr": 3231, + " = i;\n ": 3232, + "_global": 3233, + "den": 3234, + "FB": 3235, + "4) ": 3236, + "; (&buf[": 3237, + " \\n\", ": 3238, + "7F": 3239, + ")) + 1": 3240, + "mage->content": 3241, + "argv": 3242, + ") - (*": 3243, + "B3": 3244, + "u[((2 * i": 3245, + "u[((2 * i3": 3246, + ") - 1][((2 * i2": 3247, + ") - 1][((2 * i1": 3248, + ", 16": 3249, + "k + (-1))) ? ((16 * c1) + 15) : (n": 3250, + "k + (-1))) ? ((16 * c1) + 15) : (nk": 3251, + "m + (-1))) ? ((16 * c2) + 15) : (nm + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 3252, + "2 * i3": 3253, + "][2 * i": 3254, + "][(2 * i": 3255, + ")) + (-": 3256, + ";\n tmp = v": 3257, + "))) - (": 3258, + "\\t ": 3259, + ", int y, int ": 3260, + ") + jj]": 3261, + ")) || (": 3262, + "c00 = _mm_add_ps(": 3263, + "c00 = _mm_add_ps(c00": 3264, + "4096": 3265, + "Temperature": 3266, + "omp_get_num_threads(": 3267, + "accum": 3268, + "sage": 3269, + "ple": 3270, + " - firstcol": 3271, + "READ": 3272, + "jj": 3273, + "set(": 3274, + "the ": 3275, + ", cur_salt->": 3276, + "HREAD": 3277, + "[1] = ": 3278, + "0'": 3279, + "512)": 3280, + "_table": 3281, + "Dim": 3282, + "scale": 3283, + " is": 3284, + "[i][j + 1]": 3285, + "nuc": 3286, + "94": 3287, + "j + (-1))) ? ((16 * c2) + 15) : (nj + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 3288, + "vassign[iel": 3289, + ", i);\n}\n": 3290, + "_data": 3291, + "phi": 3292, + "for (int i = ": 3293, + " = &": 3294, + "r = ": 3295, + "bucket_": 3296, + "mes": 3297, + "rhs[k][j][i": 3298, + "cells->": 3299, + "][1] * ": 3300, + ") * c2": 3301, + "From": 3302, + "payload *": 3303, + "ener": 3304, + "i = 0; i < ": 3305, + "s + k": 3306, + "dst": 3307, + ")\n{\n int i;\n int j": 3308, + " < 0": 3309, + " = 0;\n int ": 3310, + "ipad": 3311, + "temp2": 3312, + ") + ((-1) * n": 3313, + "return 100": 3314, + " = 0; i1": 3315, + "AX": 3316, + " = 0.0;\n}\n": 3317, + "distribute parallel for": 3318, + "((((((": 3319, + ") + (j * ": 3320, + "e[iel": 3321, + " + z": 3322, + ", \"%d": 3323, + ") lastprivate": 3324, + "16]": 3325, + "c = c + (b": 3326, + "))\n ": 3327, + "for (j = 0; j < 4; j++)\n for (i = j": 3328, + "; i++)\n for (k = 0; k < 5; k": 3329, + "; i++)\n for (k = 0; k < 5; k += 2)\n l++;\n\n\n": 3330, + "2.0) * ": 3331, + "))\n {\n ": 3332, + "[i]);\n ": 3333, + "5, ": 3334, + "key_buff": 3335, + "0 * (1 * 100)) * (1 * 100))))) + i": 3336, + "A[(((i": 3337, + "2 * c0": 3338, + " * 16) < 0) ? (-((-nl": 3339, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-": 3340, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl": 3341, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((": 3342, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((nl": 3343, + "3CC": 3344, + "5A5A": 3345, + "return 0.0f": 3346, + " - 1); i1": 3347, + "; i++)\n{\n for (j = 0; j < 1": 3348, + "400": 3349, + "find": 3350, + ") schedule(static": 3351, + "0 * ": 3352, + "eps": 3353, + " <= (m": 3354, + "g->N": 3355, + "(int x, int y, int ": 3356, + "+ : ": 3357, + "45": 3358, + "1.0 + (": 3359, + "symmat": 3360, + "mean[j]": 3361, + " += 1)\n {\n ": 3362, + " += ((": 3363, + ") ? (nj": 3364, + ") ? (nj) : (n": 3365, + "[i * ": 3366, + "[i] + (": 3367, + "List": 3368, + "5) * ": 3369, + "outlen": 3370, + "[j][i]": 3371, + " - 3": 3372, + "[idx[i]]": 3373, + "] == ": 3374, + "0.0000000": 3375, + "][j - 1]": 3376, + "norm_temp": 3377, + "sum2": 3378, + "for (i = 0; i < 2048": 3379, + ")\n{\n return (((": 3380, + "world": 3381, + "if (table": 3382, + "-2) * ": 3383, + "vtype *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 3384, + "return 0.0f;\n }\n else\n {\n ": 3385, + "return 0.0f;\n }\n else\n {\n return 100": 3386, + "return 0.0f;\n }\n else\n {\n return 100.0f * ": 3387, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(": 3388, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val": 3389, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2": 3390, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / ": 3391, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val": 3392, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + ": 3393, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.0000000": 3394, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f": 3395, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f));\n }\n\n}\n\n": 3396, + ") + c": 3397, + "(double *": 3398, + " + (-1))) ? (((": 3399, + "matrix->": 3400, + "mul": 3401, + "[i][j - 1": 3402, + ";\n int ": 3403, + "for (col = 0; col < 95100; col++)\n{\n ": 3404, + "col = col + 4;\n}\n": 3405, + "ING": 3406, + "c6": 3407, + "}\n\n\n ": 3408, + "(int x, int y, int z": 3409, + "known_sum = (1000 * (1000 + 1)) / 2;\n ": 3410, + ")\n for (i = 1; i <= 1000; i++)\n {\n ": 3411, + "for (i = 0; i < 20; i++)\n{\n if (!test_omp_parallel_for_": 3412, + "))\n {\n num_failed++;\n }\n\n}\n\nint test_omp_parallel_for_": 3413, + "known_sum == ": 3414, + "known_sum == sum": 3415, + "->nb": 3416, + "pi": 3417, + "mor_": 3418, + "Po": 3419, + ")))) + (0.0": 3420, + "newe[iel": 3421, + " >> 6": 3422, + "for (col = 0; col < 95100; col++)\n {\n ": 3423, + "col = col + 4;\n }\n\n ": 3424, + "(x, y)": 3425, + "; ++j)\n{\n ": 3426, + "col - firstcol": 3427, + "col - firstcol) + 1)": 3428, + ") + i]": 3429, + "][i + 1": 3430, + "numAliveNeighbors++": 3431, + "ga": 3432, + " ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj": 3433, + "linear(": 3434, + "for (i = 0; i < 5": 3435, + "to_": 3436, + "54": 3437, + "alloc(": 3438, + ") > (((": 3439, + " + (-1))) < (nl": 3440, + " + (-1))) : (nl": 3441, + ";\n x00": 3442, + "_of_": 3443, + ";\n\n if (": 3444, + "u_ps(s + k": 3445, + ";\n\n if (": 3446, + "ciphertex": 3447, + " = a1": 3448, + ") shared": 3449, + ".2": 3450, + "omp parallel for shared": 3451, + " = y": 3452, + "dep": 3453, + "cells": 3454, + "v = ": 3455, + "MatrixDim": 3456, + "fprintf(f": 3457, + "reduction": 3458, + " *) malloc((sizeof(": 3459, + "*:": 3460, + ") : ((": 3461, + "[c": 3462, + "Vector": 3463, + "chro": 3464, + ") schedule(static, ": 3465, + ") default": 3466, + "scalar": 3467, + "43": 3468, + "omp parallel for shared(col)": 3469, + "energ": 3470, + "; k < ": 3471, + "neto": 3472, + "s ": 3473, + "tial": 3474, + "break;\n\n ": 3475, + "v.": 3476, + "params.ny": 3477, + "nl * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((nl": 3478, + "long *) (&": 3479, + "for (v = 0; v < graph->num_vertices": 3480, + "for (v = 0; v < graph->num_vertices; v++)\n{\n ": 3481, + "dynamic, ": 3482, + "[i3 - 1][i2 - 1": 3483, + "fscanf(": 3484, + "[i] = 0;\n}\n": 3485, + " == 2": 3486, + "}\n else": 3487, + ") + (2 * ": 3488, + "Box": 3489, + "john_MD5_": 3490, + "input_array[x": 3491, + "s[((": 3492, + "He": 3493, + "ce[m": 3494, + "B, ": 3495, + "] = a": 3496, + "reduction (": 3497, + "HREADS": 3498, + "Next": 3499, + "len_p": 3500, + " + (-1))) : (nm": 3501, + "atoi16[ARCH_INDEX(p": 3502, + ")) + k": 3503, + "schedule (static, ": 3504, + " = _mm_load1_ps(t + k": 3505, + ");\n int ": 3506, + ")] = ": 3507, + ";\n }\n\n }\n\n ": 3508, + "Rec": 3509, + "4) * ": 3510, + "ciphertext": 3511, + "3;\n ": 3512, + "cur_": 3513, + " * N": 3514, + "_last": 3515, + ";\n }\n\n }\n\n }\n\n}\n": 3516, + " > max": 3517, + "level": 3518, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100))) + ((0 * (1 * 100)) * (1 * 100))))) + i": 3519, + "nk * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((nk + 16) - 1) / 16))": 3520, + "16 * c1) + 15) < (nj + (-1))) ? ((16 * c1) + 15) : (nj": 3521, + "B0": 3522, + "imit": 3523, + "ULL": 3524, + "\nvoid ": 3525, + "_from": 3526, + ", 2": 3527, + "img": 3528, + "xc": 3529, + "][y": 3530, + "][5 - 1": 3531, + "A0": 3532, + "nodes": 3533, + " * ((((": 3534, + "for (j2": 3535, + ";\n }\n\n }\n\n ": 3536, + "][n": 3537, + ", u": 3538, + "_NUM": 3539, + ")));\n ": 3540, + "Tx": 3541, + "for (j = 1; j <= ((lastcol - firstcol) + 1)": 3542, + "MD5_std_combined *) (((char *) ": 3543, + "MD5_std_combined *) (((char *) MD5_std_": 3544, + "MD5_std_combined *) (((char *) MD5_std_all_p) + t))).": 3545, + "7777": 3546, + "omp parallel for shared(col)\n ": 3547, + "omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 3548, + "size; i++)\n{\n ": 3549, + "Send": 3550, + "omp parallel for reduction(": 3551, + " ,u": 3552, + " = u": 3553, + "x0": 3554, + "{\n ": 3555, + "_pointer": 3556, + "write": 3557, + "tmp_cell": 3558, + ";\n\n }\n\n ": 3559, + " + (j * ": 3560, + ";\n for (j = 0; j < ": 3561, + "it(&": 3562, + ";\n}\n\n\nvoid ": 3563, + "flush": 3564, + "_A": 3565, + "neighb": 3566, + "salt": 3567, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))) ?": 3568, + "for (int i = 0; i < 10": 3569, + "_output": 3570, + "strcmp(": 3571, + "Par": 3572, + "[i] = 0;\n ": 3573, + ") || ((": 3574, + "Data": 3575, + "[col] = ": 3576, + "row, ": 3577, + " = _mm_load1_ps((": 3578, + "neare": 3579, + " 4)": 3580, + "v(": 3581, + "main": 3582, + " * p": 3583, + "result = ": 3584, + ") * s": 3585, + "#pragma omp for ": 3586, + "filter_": 3587, + "s[idx": 3588, + " + (-": 3589, + "9E": 3590, + "1_ps(": 3591, + "2(": 3592, + "solu": 3593, + ")\n for (int i": 3594, + "m->": 3595, + "; j++)\n {\n C": 3596, + ")\n {\n printf(\"": 3597, + "cop": 3598, + "num_p": 3599, + "hf": 3600, + "CE": 3601, + ";\n lhs[": 3602, + "lc": 3603, + "90": 3604, + "init_": 3605, + "omp parallel for reduction(+: l) collapse(3": 3606, + ") && ": 3607, + "av": 3608, + "symmat[(": 3609, + "cbc[ntemp": 3610, + "16 * c2) + 15) < (nk + (-1))) ? ((16 * c2) + 15) : (nk": 3611, + "nl * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((nl + 16) - 1) / 16))": 3612, + " + (-1))) < (nk + (-1))) ? ((((": 3613, + "local_density": 3614, + " >> 22": 3615, + "6F": 3616, + "#pragma omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 3617, + "*((vtype *) (((": 3618, + "*((vtype *) (((long *) (&": 3619, + "(u": 3620, + "FP": 3621, + "s;\n ": 3622, + "Ver": 3623, + ", i);\n ": 3624, + "cul": 3625, + "d = ": 3626, + "s);\n ": 3627, + "Up": 3628, + "i + j": 3629, + ", v": 3630, + "D_": 3631, + "vol": 3632, + ", _mm_mul_ps(_mm_load": 3633, + "loops": 3634, + "bi": 3635, + "nb": 3636, + "message": 3637, + "R23": 3638, + "R46": 3639, + "Vertic": 3640, + "elem_at(&g->": 3641, + "elem_at(&g->vertices": 3642, + "v_data->": 3643, + ") <<": 3644, + ")\n{\n return ": 3645, + "cesse": 3646, + " == 1)\n {\n ": 3647, + " % 2": 3648, + "; i++)\n{\n printf(\"": 3649, + ".2f": 3650, + ")) * (*((": 3651, + "61": 3652, + "dat": 3653, + "for (k = 0; k < 1": 3654, + "fprintf(fp": 3655, + "change": 3656, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))); c2++)\n {\n for (c3 = 16 * c1": 3657, + "BF_current.P": 3658, + "128": 3659, + ",m": 3660, + "beta": 3661, + "gin": 3662, + ", (unsigned char *) ": 3663, + "#pragma omp flush": 3664, + " / 2": 3665, + "for (j = 0; j < 1000": 3666, + "riple": 3667, + "diff = diff": 3668, + "while ((": 3669, + "Div": 3670, + "; t": 3671, + "x; i++)\n ": 3672, + "a0": 3673, + "nes": 3674, + "(const ": 3675, + "pageRanks[v": 3676, + ") * x": 3677, + "second": 3678, + "for (i = 0; i < 8192": 3679, + ", h": 3680, + "; c": 3681, + " + 1] = ": 3682, + ") + y) * ": 3683, + "fr": 3684, + "real_": 3685, + "pl": 3686, + "gu": 3687, + "sion": 3688, + "j - 1) * ": 3689, + "(png": 3690, + "squ": 3691, + "return 1;\n\n": 3692, + " << 4": 3693, + "_image": 3694, + "y(&": 3695, + "4)\n{\n ": 3696, + "rol": 3697, + "1 <<": 3698, + "ei": 3699, + " * size": 3700, + "in_mo": 3701, + "[o": 3702, + "6;\n x": 3703, + "k + (-1))) ? ((16 * c2) + 15) : (nk + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 3704, + " = a5": 3705, + "bufs[idx": 3706, + "tmp = ": 3707, + "[(j * n": 3708, + "OD": 3709, + "lon": 3710, + "stats->pageRanks[v": 3711, + " < 16; ++i": 3712, + "OMP_Index(int x, int y, int z": 3713, + "OMP_Index(int x, int y, int z)\n{\n return (((": 3714, + "OMP_Index(int x, int y, int z)\n{\n return (((z * ": 3715, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax": 3716, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * ": 3717, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + ": 3718, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + x": 3719, + "side": 3720, + "07": 3721, + "element_": 3722, + "temp + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 3723, + "[i]);\n": 3724, + "pow(dt, i);\n}\n": 3725, + "SCH": 3726, + "out_degree": 3727, + "dtemp": 3728, + "goto ": 3729, + "for (i = 0; i < 20; ++i)\n{\n dpt *= dt": 3730, + "for (i = 0; i < 20; ++i)\n{\n dpt *= dt;\n}\n": 3731, + "logic_and = logic_and && logics[i];\n}\n": 3732, + "act": 3733, + "bit_and = bit_and & logics[i];\n}\n": 3734, + "logic_or = logic_or || logics[i];\n}\n": 3735, + "logics[i] = 1;\n}\n": 3736, + "bit_or = bit_or | logics[i];\n}\n": 3737, + "[l]": 3738, + "_width": 3739, + "8)": 3740, + "for (j = 1; j <= ": 3741, + " = 0;\n #pragma ": 3742, + "e+": 3743, + "2; i": 3744, + "_X86": 3745, + "; j++)\n {\n ": 3746, + "_type": 3747, + "y2": 3748, + " - ((": 3749, + "board": 3750, + "u[4": 3751, + "aligned(": 3752, + "SCHED": 3753, + ") >= ": 3754, + "matri": 3755, + ", r": 3756, + "1,": 3757, + " & 1": 3758, + "][i][j][k] = fac1 * ": 3759, + " - (lhs[n + 1": 3760, + "][k] * ": 3761, + ") * d": 3762, + ")) >": 3763, + "8 * ": 3764, + "private.d_in2": 3765, + "MAT": 3766, + "tmp1 * 2.0) * ": 3767, + "; c3 <= ((((((": 3768, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((((": 3769, + " + (-1))) < (nl + (-1))) ? ((((": 3770, + " params.": 3771, + " + 16) - 1) / 16))) : (((": 3772, + "n = 0; ": 3773, + "++)\n{\n if (": 3774, + "i)\n{\n ": 3775, + "[j + 1]": 3776, + "ref": 3777, + "1;\n ": 3778, + "code": 3779, + "2 * ((": 3780, + "shift": 3781, + "use": 3782, + "for (i = 1; i <= 10": 3783, + "EX": 3784, + "ite": 3785, + "jtr_sha256": 3786, + "rhs[m][i][j][k": 3787, + "guided": 3788, + "2;\n ": 3789, + "ntemp = ": 3790, + "epi": 3791, + "y_data": 3792, + "9999": 3793, + "dt);\n ": 3794, + ";\n\n ": 3795, + ", int i, int ": 3796, + "age": 3797, + "#pragma omp for\n ": 3798, + "zone": 3799, + "sect": 3800, + "kp": 3801, + "dsum += ": 3802, + "map(": 3803, + "nnz": 3804, + "exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n}\n": 3805, + "^:exclusiv_bit_or)": 3806, + "status": 3807, + ";\n if ((": 3808, + "task": 3809, + "&&:logic_and)": 3810, + "mu": 3811, + "diff = diff - i": 3812, + "ddiff -= ": 3813, + "product *= ": 3814, + "] = temp": 3815, + "5 * ": 3816, + "for (l": 3817, + " <= (((((((": 3818, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk": 3819, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) :": 3820, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) : ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16))": 3821, + ";\n vtype x0": 3822, + " & m;\n ": 3823, + " + 1][i1]": 3824, + "do\n {\n ": 3825, + "(x, y, z)": 3826, + "));\n *((C + i) + mj": 3827, + "Difference": 3828, + "string": 3829, + ", (MPI_Datatype) 0x4c00040": 3830, + "nc": 3831, + "_G": 3832, + "DD": 3833, + " + (jj * params.nx)]": 3834, + "png_": 3835, + "ai": 3836, + "JTR": 3837, + "] = i": 3838, + " + (-1))); c1": 3839, + "&:bit_and)": 3840, + "omp parallel for simd": 3841, + "printf(\"\\n": 3842, + "800": 3843, + "s += ": 3844, + "||:logic_or)": 3845, + ") && (n": 3846, + "|:bit_or)": 3847, + "fft": 3848, + "fftblock": 3849, + "m4": 3850, + "a, b": 3851, + ";\n }\n\n return ": 3852, + ";\n }\n\n for (c2": 3853, + "BER": 3854, + ", const ": 3855, + "omp parallel for firstprivate(": 3856, + " = 1. / ": 3857, + "2] = 0;\n ": 3858, + "_j": 3859, + ")) > ": 3860, + "++;\n ": 3861, + "depth": 3862, + "dcomp": 3863, + "frame": 3864, + "for (int i = 0; i < g->N": 3865, + ") ((": 3866, + "lev": 3867, + "] = 0": 3868, + "((((((((": 3869, + " instead of": 3870, + "*:product": 3871, + "t 2": 3872, + "control": 3873, + "[(i * N) + j]": 3874, + "cin": 3875, + "ual": 3876, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n #pragma omp simd\n for (c4 = ": 3877, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n #pragma omp simd\n for (c4 = nl": 3878, + ") private(i, j": 3879, + "for (i = 0; i <= (": 3880, + "++)\n{\n for (c2 = 0; c2": 3881, + "eta * (ce[": 3882, + "zeta * (ce[": 3883, + "omp parallel for simd collapse(": 3884, + " * (*": 3885, + ") / (1 - ": 3886, + "e-": 3887, + "[(i * size": 3888, + "-:diff": 3889, + " = (1 - ": 3890, + "doubles": 3891, + "-:ddiff": 3892, + "NG": 3893, + "1] * ": 3894, + ") : (((": 3895, + " - u": 3896, + "--------": 3897, + "tmp = v": 3898, + "SS": 3899, + "(image": 3900, + "][2] * ": 3901, + "omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)": 3902, + "1))": 3903, + ") / ((double) ": 3904, + "omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)": 3905, + " * h": 3906, + "dsum = 0;\n ": 3907, + "logic_and = 1;\n ": 3908, + "bit_and = 1;\n ": 3909, + ")\n {\n result++;\n fprintf(stderr, \"Error in sum": 3910, + ")\n {\n result++;\n fprintf(stderr, \"Error in sum with ": 3911, + "dpt = 1;\n ": 3912, + "dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n ": 3913, + "dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt": 3914, + "dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 3915, + " = (1 - dpt": 3916, + " = (1 - dpt) / (1 - ": 3917, + " = (1 - dpt) / (1 - dt);\n ": 3918, + ")\n for (i = 0; i < 20; ++i)\n {\n ": 3919, + "pow(dt, i": 3920, + "pow(dt, i);\n }\n\n if (": 3921, + "pow(dt, i);\n }\n\n if (fabs(": 3922, + "dsum - ": 3923, + "dsum - dknown_sum": 3924, + ") > rounding_error": 3925, + "doubles: Result was": 3926, + "duct ": 3927, + "logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic": 3928, + "logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 3929, + "logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic": 3930, + "logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par": 3931, + "bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT": 3932, + "bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 3933, + "bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT": 3934, + "bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par": 3935, + "t 1\\n\");\n }\n\n ": 3936, + "t 2\\n\");\n }\n\n ": 3937, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in ": 3938, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EX": 3939, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCL": 3940, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLU": 3941, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSI": 3942, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV": 3943, + " BIT": 3944, + " BIT OR par": 3945, + "omp_un": 3946, + ", 0, ": 3947, + ") - 1] = ": 3948, + "[k] * ": 3949, + "ime": 3950, + "mor_s_": 3951, + "CA": 3952, + ";\n out": 3953, + "lec": 3954, + "indow": 3955, + "FE": 3956, + "binary": 3957, + "4))": 3958, + "i - 1": 3959, + "logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3960, + "2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3961, + " - 1); ": 3962, + "i, j": 3963, + "0.1": 3964, + "static,1) private(i": 3965, + "*) ": 3966, + "d(": 3967, + "culate": 3968, + "[j].": 3969, + "lug": 3970, + "lamb": 3971, + "omp parallel for schedule(dynamic,1) private(i) reduction(+:": 3972, + "= (n": 3973, + "4,": 3974, + " = 1.0;\n ": 3975, + "for (i = 0; i < 1000; ++i)\n{\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n}\n": 3976, + "for (i = 0; i < 1000; ++i)\n{\n logic_and = logic_and && logics[i];\n}\n": 3977, + "for (i = 0; i < 1000; ++i)\n{\n bit_and = bit_and & logics[i];\n}\n": 3978, + "omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)": 3979, + "#pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:": 3980, + "&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n ": 3981, + "&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&": 3982, + "logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3983, + "t 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3984, + "||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n ": 3985, + "||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||": 3986, + "&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n ": 3987, + "&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &": 3988, + "|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n ": 3989, + "|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |": 3990, + "^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n ": 3991, + "^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^": 3992, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par": 3993, + "[i + 1][ind] = ": 3994, + "}\n else\n {\n ": 3995, + "_init(&": 3996, + ")\n{\n int sum;\n int i": 3997, + " = 1;\n ": 3998, + "for (i = 0; i < 1000; ++i)\n{\n logic_or = logic_or || logics[i];\n}\n": 3999, + "omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)": 4000, + "for (i = 0; i < 1000; ++i)\n{\n bit_or = bit_or | logics[i];\n}\n": 4001, + "omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)": 4002, + "outo": 4003, + " * (*(((*((": 4004, + "p1] - (2.0 * ": 4005, + "] = 1.0": 4006, + "newc[iel": 4007, + "nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj + 16) - 1) / 16))": 4008, + "00FF": 4009, + ";\n *((vtype *) (((long *) (&": 4010, + ";\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 4011, + "_xx_xx": 4012, + "On": 4013, + ") private(j": 4014, + "Cla": 4015, + "; y++)\n {\n ": 4016, + "crypt_key": 4017, + "for (row = 0; row": 4018, + "[i][k]": 4019, + "6.0 * ": 4020, + "od": 4021, + "in_mod_": 4022, + " params.nx": 4023, + "iter": 4024, + "rh": 4025, + "Update": 4026, + "nodes[": 4027, + "[j], ": 4028, + "; i1": 4029, + "tmp = tmp": 4030, + ";\n}\n\n\ndouble ": 4031, + " = omp_get_thread_num(": 4032, + "'0'": 4033, + "ublic.in2": 4034, + "S->P": 4035, + "40]": 4036, + "put": 4037, + ") - 1)": 4038, + "++)\n ": 4039, + "magic": 4040, + "Temperature_last": 4041, + "0.25": 4042, + ", 1, ": 4043, + "y ": 4044, + "_block": 4045, + "1 << ": 4046, + "->label": 4047, + "ours": 4048, + "forcing[m": 4049, + "; i += 1)\n{\n ": 4050, + ") (((": 4051, + "; j < (": 4052, + "ING_M": 4053, + "_no": 4054, + "rm": 4055, + "flux": 4056, + "++;\n ": 4057, + " + 5": 4058, + "m + (-1))) ? ((16 * c1) + 15) : (n": 4059, + "m + (-1))) ? ((16 * c1) + 15) : (nm": 4060, + "factor": 4061, + "++)\n{\n for (int ": 4062, + "; i++)\n{\n int ": 4063, + "ing ": 4064, + "])\n {\n ": 4065, + "lhs[n + 3][i][j][k": 4066, + "raph": 4067, + "Min": 4068, + "[y][x": 4069, + "ntemp = sje": 4070, + "i1": 4071, + " += 1)\n {\n ": 4072, + "omp parallel for schedule(SCHED": 4073, + "omp parallel for schedule(SCHEDUL": 4074, + "x, ": 4075, + "x + (": 4076, + "rand()) / ": 4077, + "_NUMBER": 4078, + ", _mm_mul_ps(_mm_loadu_ps(s + k": 4079, + ")) * (*(": 4080, + "epsi": 4081, + ")) &&": 4082, + "_some": 4083, + "pageRanks": 4084, + "][i - 1": 4085, + "s[0]": 4086, + "7 * (((": 4087, + "orm": 4088, + "m1 - 1); i1": 4089, + "nearest_": 4090, + "omp parallel for private(i, j": 4091, + "omp parallel for schedule(SCHEDULING_M": 4092, + "omp parallel for schedule(SCHEDULING_MET": 4093, + "omp parallel for schedule(SCHEDULING_METH": 4094, + "omp parallel for schedule(SCHEDULING_METHOD": 4095, + "ader": 4096, + "PR": 4097, + "; j += ": 4098, + "for (int k = 0; k < ": 4099, + "double p": 4100, + "ro_x": 4101, + ": %d": 4102, + "ife": 4103, + ";\n int k": 4104, + "static int ": 4105, + "passed_": 4106, + "passed_verification": 4107, + "[bid]": 4108, + ") + ((-1) * n)) + ": 4109, + "0.05": 4110, + "fail++": 4111, + "ran": 4112, + "78": 4113, + ")\n {\n if (": 4114, + "rand()) /": 4115, + "fy": 4116, + " + 1) * (": 4117, + "_max": 4118, + "To": 4119, + " = 0; l": 4120, + "8) * ": 4121, + "best": 4122, + ";\n *": 4123, + "u[i][j]": 4124, + "[i - 1][j][k": 4125, + ")\n {\n int ": 4126, + "}\n else\n if (": 4127, + "A[c1][c2] = (((double) c1": 4128, + "A[c1][c2] = (((double) c1) * c2": 4129, + "A[c1][c2] = (((double) c1) * c2) / ni": 4130, + "Is": 4131, + "std": 4132, + "blue": 4133, + "sizeof(float": 4134, + "[i][j - 1][k": 4135, + "->ve[k]": 4136, + " != (test_rank_array": 4137, + " ((((((n": 4138, + "va = v": 4139, + "vb = v": 4140, + "vassign[iel][0] = ": 4141, + "in.bit._": 4142, + "pend": 4143, + "[i][j + 1][k": 4144, + "val = ": 4145, + "FP_NUMBER": 4146, + "8]": 4147, + "epsilon": 4148, + "Vertices": 4149, + "bucket": 4150, + "matrix + i) + ": 4151, + " = _mm_load1_ps((t": 4152, + ")) * (*((t": 4153, + "channel": 4154, + " + 0": 4155, + "][3] * ": 4156, + "n) + j]": 4157, + "; i++)\n{\n for (j = 0; j < n": 4158, + "for (long ": 4159, + "for (i = 0; i < 100000": 4160, + ")) + (k": 4161, + "[(i * 1024": 4162, + "; i++)\n {\n ": 4163, + "ST": 4164, + "[i][1]": 4165, + ".E": 4166, + "[i + 1][j][k": 4167, + ";\n tmp = v": 4168, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).E": 4169, + "set1_ps(": 4170, + "meas": 4171, + "for (y = 0; y < ": 4172, + "));\n c00 = _mm_add_ps(c00": 4173, + "image->": 4174, + " %= ": 4175, + "++] = ": 4176, + "cod": 4177, + "5 - 1)": 4178, + "0][0]": 4179, + "edge_": 4180, + "pcmor_n": 4181, + "matrixSize": 4182, + "T46": 4183, + ") && (c1 >= (((": 4184, + "[], float ": 4185, + " = (float": 4186, + "c2 * ": 4187, + "CF": 4188, + "Out": 4189, + "n = 0; n": 4190, + "vertice": 4191, + "for (i1 = 0; i1": 4192, + "--)\n{\n ": 4193, + "][3] = ": 4194, + ";\n }\n else\n {\n ": 4195, + "-1.0": 4196, + "v1[i] * v2[i];\n": 4197, + "_work": 4198, + "a[i] + ": 4199, + "[j] * ": 4200, + "cessor": 4201, + "ang * ": 4202, + ";\n }\n\n }\n\n }\n\n }\n\n if ((c1 <=": 4203, + "_mm512_": 4204, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).E.E": 4205, + "reate": 4206, + "omp parallel for firstprivate": 4207, + "ela": 4208, + "for (i2": 4209, + ",j)": 4210, + "h_": 4211, + "pen": 4212, + "prob": 4213, + "val1": 4214, + "int) ((": 4215, + "(\"": 4216, + "\n {\n ": 4217, + ", 0);\n ": 4218, + "neighbors": 4219, + "window": 4220, + "post": 4221, + "rgb": 4222, + ") + (-": 4223, + "408": 4224, + "c3) + ": 4225, + ") + (y * ": 4226, + "non": 4227, + " != (7": 4228, + "est": 4229, + " + 1, ": 4230, + "val3": 4231, + "omp parallel for reduction(+:sum)": 4232, + "[5": 4233, + "calloc(": 4234, + ";\n b": 4235, + "wl": 4236, + " > (": 4237, + "move": 4238, + "][i1 + 1]": 4239, + "(void": 4240, + "uold": 4241, + "nearest_city": 4242, + "uni": 4243, + ");\n }\n\n printf(\"\\n\");\n}\n": 4244, + "omp target parallel for collapse(": 4245, + " is ": 4246, + " > nm": 4247, + " = 0;\n }\n\n}\n": 4248, + "LE": 4249, + "bar": 4250, + ") && ((": 4251, + "match": 4252, + " < 8": 4253, + "uint64_t ": 4254, + "73": 4255, + "stop": 4256, + "].real": 4257, + "].imag": 4258, + "_mul(": 4259, + "]), (": 4260, + " & m;\n tmp": 4261, + " & m;\n tmp = tmp": 4262, + "va = va": 4263, + "va = va | tmp": 4264, + "vb = vb": 4265, + "vb = vb | tmp": 4266, + "lhs[k": 4267, + "63": 4268, + " ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16))": 4269, + "][m] = ": 4270, + "0.5 * (": 4271, + "reduction (+:": 4272, + ");\n\n ": 4273, + "]) + (": 4274, + "dimZ": 4275, + "mat_col": 4276, + "[t": 4277, + "));\n }\n\n}\n": 4278, + "num_pro": 4279, + "#pragma omp parallel for\n ": 4280, + "/im": 4281, + "[(j": 4282, + "IM": 4283, + "512 * ": 4284, + "for (i = 0; i < 512": 4285, + "prev_": 4286, + "C8": 4287, + "2A": 4288, + ") * params.nx": 4289, + "for (index = 0; index < count; index++)\n ": 4290, + "omp parallel for ordered": 4291, + ":%d": 4292, + "for (i = 0; i < 8": 4293, + "sup->": 4294, + "lower": 4295, + "(x :": 4296, + "; k++)\n ": 4297, + " - j": 4298, + "omp target teams distribute parallel for": 4299, + "i0": 4300, + "die": 4301, + "hist": 4302, + "ler": 4303, + "params.ny) * params.nx": 4304, + "params.ny) * params.nx) + (": 4305, + "a, ": 4306, + "private[i].": 4307, + "for (int j = 1; j": 4308, + "_func": 4309, + "acle": 4310, + "total_len": 4311, + "mat_row": 4312, + "][i][j][k] - (dssp": 4313, + "zoneset": 4314, + "void p": 4315, + ");\n }\n\n }\n\n ": 4316, + "visited": 4317, + " - v": 4318, + "omp_get_w": 4319, + "for (int i = 0; i < x; i++)\n ": 4320, + "mor_v": 4321, + "rowval": 4322, + "][j + 1]": 4323, + "dataset": 4324, + "s2": 4325, + "tmp2) * fjac": 4326, + "tmp1 * 2.0) * njac": 4327, + "tmp2 * ": 4328, + "tmp2 * fjac": 4329, + "u_x": 4330, + "[col]);\n ": 4331, + "radius": 4332, + "elt": 4333, + "[(((x": 4334, + " = (nj": 4335, + "[id].": 4336, + ") + u1": 4337, + "debu": 4338, + "lot": 4339, + "++) = ": 4340, + "return result": 4341, + ") <= ": 4342, + "c[i]": 4343, + "] *= boundryScale;\n u[ind + ": 4344, + "memset(": 4345, + "spl": 4346, + "cout": 4347, + "], int ": 4348, + "stacle": 4349, + "2] = 6": 4350, + "3.14": 4351, + "for (z": 4352, + "b[i][j] = ": 4353, + "arr[i]": 4354, + "0.5) * ": 4355, + ");\n printf(\"": 4356, + "first_": 4357, + "ing(": 4358, + "xyzInd + ": 4359, + " + 1)) + j2]": 4360, + "sr": 4361, + "n + (2 * ": 4362, + "n + (2 * tsteps": 4363, + "n + (2 * tsteps)) + (-": 4364, + ";\n out.bit._": 4365, + "absVal(val1": 4366, + "absVal(val2": 4367, + " = 0; j2": 4368, + "obstacle": 4369, + "omp parallel for num_threads": 4370, + "mass": 4371, + "a[j]": 4372, + "CitiesX[": 4373, + "CitiesY[": 4374, + "ouse": 4375, + "1_layer": 4376, + ".speeds[": 4377, + "c134": 4378, + "20408": 4379, + ";\n *((vtype *) (((long *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 4380, + "grid_points[0]": 4381, + " ^ (": 4382, + "for (j2 = 0; j2": 4383, + "for (k2": 4384, + "matriz": 4385, + " * 1.0": 4386, + ") schedule(runtime)": 4387, + "ON": 4388, + ") / N": 4389, + "activeVertices": 4390, + "atoms->": 4391, + "luster": 4392, + "get(": 4393, + "snakes[j].": 4394, + "}\n else\n ": 4395, + "][0]))), (*((vtype *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 4396, + " = a2": 4397, + "lt": 4398, + "target": 4399, + "tz1": 4400, + "sqrt((": 4401, + "[10": 4402, + " de": 4403, + "e+00": 4404, + "spec": 4405, + ")) * (*(t + k": 4406, + "omp parallel for simd simdlen(": 4407, + "m = ": 4408, + "_mat": 4409, + "for (i = 0; i < m": 4410, + "indice": 4411, + "++)\n ": 4412, + "[iOff": 4413, + "lide": 4414, + ", N": 4415, + "life": 4416, + " = (*": 4417, + "1 * ((": 4418, + "2 * h": 4419, + "lient": 4420, + "->edges_array": 4421, + "Ev": 4422, + "____": 4423, + "ull; i < k": 4424, + "ull; i < kull": 4425, + "; i++)\n l++": 4426, + "; i++)\n l++;\n": 4427, + "for (j2 = 0; j2 < 4": 4428, + "for (j2 = 0; j2 < 4; j2": 4429, + "for (j2 = 0; j2 < 4; j2++)\n ": 4430, + "for (j2 = 0; j2 < 4; j2++)\n for (i = j": 4431, + "ll; i < k": 4432, + "ll; i < kll": 4433, + "; i++)\n for (k2": 4434, + "; i++)\n for (k2 = 0; k": 4435, + "; i++)\n for (k2 = 0; k2": 4436, + "; i++)\n for (k2 = 0; k2 < 5; k": 4437, + "; i++)\n for (k2 = 0; k2 < 5; k2": 4438, + "; i++)\n for (k2 = 0; k2 < 5; k2 += 2)\n l++;\n\n\n": 4439, + "Cell": 4440, + "(i, j": 4441, + ") == 0)\n {\n ": 4442, + "omp parallel for simd safelen(": 4443, + "nj + (-1)) <": 4444, + " + (-1))) ? (nj": 4445, + " + (-1))) ? (nj + (-1)) :": 4446, + "mh": 4447, + "c = c + (b != (7": 4448, + "i; i < k": 4449, + "i; i < ki": 4450, + "path": 4451, + "p[i] = v1[i] * v2[i];\n": 4452, + "][k] = ": 4453, + "u; i < k": 4454, + "u; i < ku": 4455, + "[((((": 4456, + "u_data->": 4457, + ", unsigned char *": 4458, + "stddev": 4459, + "[i][j] += ": 4460, + "for (k = 0; k < N": 4461, + "neth": 4462, + ");\n tmp": 4463, + ", &i": 4464, + "cor": 4465, + "384": 4466, + ") + j] = (((DATA_TYPE) i) * j": 4467, + "comz4": 4468, + "C[c1][c2] = (((double) c1) * (c2": 4469, + "C[c1][c2] = (((double) c1) * (c2 + 3)) / nl": 4470, + "master": 4471, + "41": 4472, + "[u": 4473, + "[itemp": 4474, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl": 4475, + "4E": 4476, + " = a4": 4477, + " = a3": 4478, + "d_1": 4479, + "printf(\"%d \", ": 4480, + "Le": 4481, + ") && (i <= ": 4482, + "for (int i = 0; i < (": 4483, + "MPI_Send": 4484, + "omp target teams distribute parallel for collapse(": 4485, + " ,i": 4486, + "rsd[i][j][k": 4487, + " - 1))": 4488, + "03": 4489, + "random_": 4490, + "mar": 4491, + "\\n\");\n exit(": 4492, + "y, ": 4493, + "omp distribute parallel for simd": 4494, + "rint": 4495, + ") : (0": 4496, + "lambda": 4497, + "] + 1": 4498, + " / ((": 4499, + "][m] - (": 4500, + " - 2]": 4501, + "num_elements": 4502, + " + 1); i++)\n{\n ": 4503, + "sum = sum + i;\n}\n": 4504, + ");\n free(": 4505, + "if(": 4506, + ";\n while (": 4507, + "do_some": 4508, + "ash": 4509, + " > 1": 4510, + "_grid": 4511, + "argv[i]": 4512, + "green": 4513, + "mor_s_v": 4514, + "uf": 4515, + "Ty": 4516, + "CD": 4517, + "tlock": 4518, + "newIndex": 4519, + "right": 4520, + "div": 4521, + " = 0.0f": 4522, + "1;\n double ": 4523, + "); p": 4524, + " )\n ": 4525, + "dynamic, 3)": 4526, + "124": 4527, + "3.1415": 4528, + "[(((i": 4529, + ") ? ((": 4530, + "init": 4531, + ") * (1 * 100": 4532, + "_name": 4533, + ")))) + (0.020408": 4534, + "square": 4535, + "omp parallel for private (i": 4536, + "timer": 4537, + "4 * ": 4538, + "Y) + j]": 4539, + ", *": 4540, + "y0": 4541, + "[pos": 4542, + ");\n int ": 4543, + ", S": 4544, + " * (x": 4545, + "pointer": 4546, + " - 4": 4547, + "temp1": 4548, + "], tmp_vec": 4549, + "ex[(i * (": 4550, + ") - d1": 4551, + "cells->speeds[": 4552, + "][i1][j][k": 4553, + "set_lock(&tlock": 4554, + "set_lock(&tlock[ig": 4555, + "ni * 16) < 0) ? (-((-": 4556, + "ni * 16) < 0) ? (-((-ni": 4557, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-": 4558, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-ni": 4559, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-ni) + (-16)) - 1) / (-16)) : (((": 4560, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-ni) + (-16)) - 1) / (-16)) : (((ni": 4561, + "float percentDiff(double val1, double val2)\n{\n if ((": 4562, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1": 4563, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01": 4564, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (": 4565, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2": 4566, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2) < 0.01": 4567, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2) < 0.01))\n {\n ": 4568, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2) < 0.01))\n {\n return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f));\n }\n\n}\n\n": 4569, + "enter": 4570, + ") << ": 4571, + "}\n while (": 4572, + "us_": 4573, + "x)\n{\n ": 4574, + "inc": 4575, + "for (i = 0; i < 100": 4576, + "][2] = ": 4577, + "i + i": 4578, + "omp_get_thread_num(), ": 4579, + "4.0 / (": 4580, + "[2] = ": 4581, + " < 10": 4582, + "[isize": 4583, + "Sum": 4584, + "[j];\n ": 4585, + "d1": 4586, + "ori_row": 4587, + "ori_col": 4588, + "coeff": 4589, + "man": 4590, + "T3": 4591, + "ind + 1": 4592, + "A[i][j] = ": 4593, + "B[c1][c2] = (((double) c1) * (c2": 4594, + "B[c1][c2] = (((double) c1) * (c2 + 1)) / nj": 4595, + "struct time": 4596, + "[col]);\n ": 4597, + "u[i": 4598, + "DA": 4599, + "3.14159": 4600, + "true": 4601, + "saved_key[index], ": 4602, + "do_some_work": 4603, + "++;\n }\n\n}\n": 4604, + "ries": 4605, + "[j - 1": 4606, + "inner": 4607, + "Cluster": 4608, + ", k, ": 4609, + " * (sizeof(double": 4610, + "_buffer": 4611, + ";\n return ": 4612, + "sigma": 4613, + "u_ps((": 4614, + " (-((((-((": 4615, + "lhsp": 4616, + "lhsm": 4617, + "selec": 4618, + "_perm": 4619, + "temp3": 4620, + "tile": 4621, + ") private (": 4622, + "omp parallel for private(i)": 4623, + " < 100": 4624, + " + (-1))) < (nm + (-1))) ? (((": 4625, + ") | ": 4626, + "oral": 4627, + "));\n }\n\n }\n\n}\n": 4628, + "_bound": 4629, + ";\n u2": 4630, + ") + col": 4631, + ";\n int p": 4632, + "for (i = 0; i < n; i++)\n for (j = 0; j < ": 4633, + " \"": 4634, + ";\n register ": 4635, + "public.in_mod_": 4636, + "PU": 4637, + ";\n }\n else\n if (": 4638, + ".p": 4639, + " ^= u": 4640, + "->me[i][j]": 4641, + "[jj]": 4642, + "omp target parallel for": 4643, + "for (unsigned int ": 4644, + " > nk": 4645, + "; j <= ": 4646, + "ian": 4647, + "num_b": 4648, + "ren": 4649, + "for (i = 0; i < 4": 4650, + "; c3 <= ((((16 * c1) + 15) < (nm + (-1))) ? ((16 * c1) + 15) : (nm": 4651, + "z.r": 4652, + " < (n - 1)": 4653, + "_graph": 4654, + "2);\n ": 4655, + "= 2": 4656, + ") * size": 4657, + " + public.in2": 4658, + "1_layer[o": 4659, + "D_3": 4660, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))) ?": 4661, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 4662, + "chroma": 4663, + "].speeds[": 4664, + " ^= BF_current.P": 4665, + ";\n u4 = ": 4666, + " & (~a": 4667, + " | a": 4668, + "0F0": 4669, + "pstr->bufs[idx": 4670, + "omp distribute parallel for simd collapse(": 4671, + "p = p": 4672, + "for (j = 0; j < (": 4673, + "Divided": 4674, + ") + 2]": 4675, + "sing": 4676, + "L1": 4677, + "for (int ii = 0; i": 4678, + " * n": 4679, + "omp target parallel for simd": 4680, + "omp target parallel for simd collapse(": 4681, + ";\n\n\n ": 4682, + "temp + ": 4683, + " == 2)": 4684, + "] = {": 4685, + " = (double": 4686, + "m5": 4687, + ") + j] = 0;\n ": 4688, + "93": 4689, + "2(i": 4690, + "63]": 4691, + ".data": 4692, + "_init(&ctx": 4693, + "; z": 4694, + "(((16 * c1": 4695, + "k;\n ": 4696, + "s->atoms->": 4697, + "calculate": 4698, + "((unsigned char *) ": 4699, + "3][i][j][k]": 4700, + "][i][0]": 4701, + "s1": 4702, + " + OMP_xMax) + OMP_xMax) + OMP_xMax": 4703, + " + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax": 4704, + "OMP_xMax) + OMP_xMax) + OMP_xMax": 4705, + "min = ": 4706, + "s(&": 4707, + "496": 4708, + "Fiel": 4709, + "face_a": 4710, + "key_rank": 4711, + "if (c1": 4712, + "map(to": 4713, + " 1)": 4714, + "(r": 4715, + "params": 4716, + ")\n{\n return (": 4717, + ") schedule(static)": 4718, + "output->": 4719, + "Final": 4720, + "5;\n": 4721, + ", &a": 4722, + "for (i = 0; i < 3": 4723, + "][0][0": 4724, + "postScale": 4725, + "u1;\n ": 4726, + "params.ny) * params.nx) + (ii": 4727, + " + (jj * params.nx))": 4728, + "edge_idx": 4729, + "; i++)\n{\n x": 4730, + "for (c1 = 0; ": 4731, + "nontemp": 4732, + "nontemporal": 4733, + "MAX": 4734, + "b[j]": 4735, + "c(": 4736, + "rt": 4737, + "text ": 4738, + "max + r": 4739, + "max + ru1": 4740, + " to ": 4741, + "[(k * N": 4742, + ") + 4": 4743, + ", &ctx": 4744, + "islarger": 4745, + "atoi16[ARCH_INDEX(": 4746, + " < 3; m": 4747, + " *= postScale": 4748, + "idmo[ie][iface": 4749, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n #pragma omp simd\n for (c4 = nl; c4 <= ((((16 * c2) + 15) < (n": 4750, + " ^= u2": 4751, + " ^= u2;\n ": 4752, + " ^= u3;\n ": 4753, + ";\n }\n\n #pragma omp simd\n for (c4": 4754, + "tom": 4755, + "7;\n": 4756, + "omp parallel for schedule (static, ": 4757, + "));\n }\n\n ": 4758, + ") > 0.05": 4759, + "ameter": 4760, + ", a, b": 4761, + " < 1000": 4762, + ")\n goto ": 4763, + "lines": 4764, + "m - 1)": 4765, + " = 0; z": 4766, + "Pa": 4767, + "exp(": 4768, + "grid_": 4769, + "_is": 4770, + "*p = ": 4771, + "break;\n\n ": 4772, + "; i++)\n {\n for (j = 0; j < ": 4773, + "neighbours": 4774, + "local_A": 4775, + "_chunk": 4776, + "i * params.nx": 4777, + "thid": 4778, + "c1) + ": 4779, + "omp parallel for schedule (runtime)": 4780, + "FromG": 4781, + "FromGpu": 4782, + "vertices->": 4783, + "L)]": 4784, + "for (i = 1; i < ": 4785, + "_color": 4786, + "_start": 4787, + "output->content": 4788, + "X, ": 4789, + "pageRanksNext": 4790, + "(int i, int ": 4791, + "[i] = (int": 4792, + "); c3": 4793, + " = p": 4794, + ");\n }\n else\n {\n ": 4795, + "check_i": 4796, + "check_i_is": 4797, + "check_i_islarger": 4798, + "tw": 4799, + " prime": 4800, + "offset_": 4801, + "ei_new": 4802, + "half": 4803, + "1][i": 4804, + " = (a": 4805, + "nn1": 4806, + "hv": 4807, + "hTable": 4808, + ";\n u4": 4809, + "vassign[iel][1] = ": 4810, + "}\n}\n": 4811, + "public.in2_pad": 4812, + ") * (j": 4813, + " = i;\n ": 4814, + "ait": 4815, + ";\n int i;\n int j": 4816, + " == 0)\n ": 4817, + "veloc": 4818, + "i + 1) * ": 4819, + " = 0; t": 4820, + "10000": 4821, + ", &ipad": 4822, + ", &opad": 4823, + " = ((float) ": 4824, + "85": 4825, + "][jj": 4826, + "sel": 4827, + "ss_": 4828, + ") + jj].speeds[": 4829, + ") * ((8 * ((2000 - 1) / 8)) + 8": 4830, + "Field": 4831, + "shor": 4832, + " << 3": 4833, + "for (p = &buf[16]": 4834, + "ULL)\n p[2] = ": 4835, + "ULL)\n p[2] = -7": 4836, + "ULL)\n p[2] = -7;\n": 4837, + ")\n p[2] = 7;\n": 4838, + "omp parallel for schedule (static, 3)": 4839, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5": 4840, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i": 4841, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= ": 4842, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10": 4843, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i": 4844, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i < 5": 4845, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i < 54": 4846, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i < 54))))\n abort();\n\n": 4847, + "printf(\"\\t ": 4848, + ") firstprivate(i": 4849, + " + (-1))); c2": 4850, + " + (-1))); c2++)\n {\n ": 4851, + "1, n2": 4852, + "1, n2, n": 4853, + "}\n\n\n\n\n": 4854, + "; p >": 4855, + "omp parallel for schedule (dynamic, 3)": 4856, + "-2] = 6": 4857, + "-2] = 6;\n": 4858, + "];\n }\n\n ": 4859, + ", _mm_mul_ps(_mm_loadu_ps(s + km": 4860, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6": 4861, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i": 4862, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1": 4863, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1) && (i <= ": 4864, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1) && (i <= 61": 4865, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1) && (i <= 61))))\n abort();\n\n": 4866, + "for (i = 0; i < (n": 4867, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((": 4868, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7": 4869, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * (((": 4870, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i": 4871, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i <= 4": 4872, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i <= 42": 4873, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i <= 42))))\n abort();\n\n": 4874, + "_index": 4875, + "7]": 4876, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * (((": 4877, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i": 4878, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i < 5": 4879, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i < 53": 4880, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i < 53))))\n abort();\n\n": 4881, + ") && is_larger": 4882, + "col * ": 4883, + "*p = 5;\n": 4884, + "5 = ": 4885, + "filter_list": 4886, + ") / D_3": 4887, + "T23": 4888, + "T23 * ": 4889, + "[itemp]": 4890, + " & 0xFF": 4891, + " & 0xFF;\n u": 4892, + " & 0xFF;\n u1 <<": 4893, + " & 0xFF;\n u1 <<= 2": 4894, + " & 0xFF;\n u1 <<= 2;\n u2 = ": 4895, + " >> 6;\n u2": 4896, + " >> 6;\n u2 &= 0x3FC": 4897, + " >> 6;\n u2 &= 0x3FC;\n u3 = ": 4898, + " >> 14": 4899, + " >> 14;\n u3": 4900, + " >> 14;\n u3 &= 0x3FC": 4901, + " >> 14;\n u3 &= 0x3FC;\n u4 = ": 4902, + " >> 22;\n u4": 4903, + " >> 22;\n u4 &= 0x3FC": 4904, + " >> 22;\n u4 &= 0x3FC;\n u1 = ": 4905, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S": 4906, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]": 4907, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1": 4908, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1))": 4909, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = ": 4910, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S": 4911, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]": 4912, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u": 4913, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2))": 4914, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = ": 4915, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S": 4916, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]": 4917, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u": 4918, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3))": 4919, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += ": 4920, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S": 4921, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]": 4922, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u": 4923, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u4))": 4924, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u4));\n u3": 4925, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u4));\n u3 ^= u2;\n ": 4926, + " + 1];\n u3 += ": 4927, + " + 1];\n u3 += u1;\n ": 4928, + "6666": 4929, + "2222": 4930, + "5555": 4931, + "5F": 4932, + "9A": 4933, + "newc[iel] = ": 4934, + ")) = zero": 4935, + " + 16) - 1) / 16))) > (((": 4936, + "))) ^ ((temp": 4937, + ")) ^ ((temp": 4938, + "_mm512_set1_ps(": 4939, + "#pragma omp parallel": 4940, + ")\n {\n fail++": 4941, + ", \"%f": 4942, + "_THREADS": 4943, + "0;\n ": 4944, + "cos(": 4945, + "x)": 4946, + "outh": 4947, + "4.0 / (1.0 + (": 4948, + "inv": 4949, + " < min": 4950, + "dist = ": 4951, + "))) + (((": 4952, + "uz": 4953, + "params.ny) * params.nx) + (ii + (jj * params.nx))": 4954, + "i * N": 4955, + "parallel": 4956, + "(float *": 4957, + "valid": 4958, + "] / ": 4959, + "; c2 <=": 4960, + "for (i = 0; i < n; i++)\n{\n for (j = 0; j < n": 4961, + "omp distribute parallel for simd safelen(": 4962, + "rows; i++)\n{\n ": 4963, + "_mask": 4964, + "omp distribute parallel for simd simdlen(": 4965, + ")\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i": 4966, + "ten[i][ind": 4967, + "j_temp = j": 4968, + "[i][ind] = ": 4969, + "[i][ind] = j_temp": 4970, + "for (t": 4971, + ";\n }\n\n known_sum = (1000 * (1000 + 1)) / 2;\n ": 4972, + "return (known_sum == sum": 4973, + ";\n int known_sum;\n sum = 0;\n ": 4974, + "Ele": 4975, + " = 3": 4976, + ") private(i)": 4977, + "salt, ": 4978, + "end = ": 4979, + ";\n y": 4980, + ") + ((*": 4981, + "]);\n ": 4982, + "][k][j][i": 4983, + ")) - (4.0 * ": 4984, + ") - d3": 4985, + "cast": 4986, + "bucket_ptr": 4987, + "dge": 4988, + ")) && ((": 4989, + "_vector": 4990, + "[%d]=%f": 4991, + "hashNum": 4992, + "[zoneset": 4993, + "]) + srcGrid[(": 4994, + ") schedule(static, 2)": 4995, + "for (i = 0; i < len; i++)\n{\n ": 4996, + "; j++)\n {\n if (percentDiff(": 4997, + ")\n {\n fail++;\n }\n\n }\n\n}\n\n": 4998, + " - 1); k": 4999, + "for (i = 0; i < size; i++)\n{\n ": 5000, + "rand()) / 32767": 5001, + " <= (n": 5002, + "else\n if (i == ": 5003, + "a[i] = i;\n": 5004, + ";\n temp": 5005, + ") default(none": 5006, + "MPI_Rec": 5007, + "real_t ": 5008, + " = 1.0 / ": 5009, + "iz": 5010, + "saved_key[index": 5011, + "asser": 5012, + ",a": 5013, + "New": 5014, + "if ((((": 5015, + "Result": 5016, + "time();\n ": 5017, + ") if (": 5018, + "2048 + 1)) + j]": 5019, + "D[c1][c2] = (((double) c1) * (c2": 5020, + "D[c1][c2] = (((double) c1) * (c2 + 2)) / nk": 5021, + "; j++)\n ": 5022, + "Fa": 5023, + "schedule (static, 4) ": 5024, + "));\n _mm_store": 5025, + "error = ": 5026, + "omp teams ": 5027, + "for (x = 0; x": 5028, + " = 0; c": 5029, + ") firstprivate(": 5030, + "scanf(\"": 5031, + "483": 5032, + "48364": 5033, + "ged": 5034, + "else\n ": 5035, + "dot": 5036, + "s\\n\", ": 5037, + "omega": 5038, + "key_buff_ptr": 5039, + ")) + (((": 5040, + "))\n {\n ": 5041, + "s[(ii * params.nx": 5042, + "ld_": 5043, + "if ((cbc[ntemp": 5044, + ")) + (h": 5045, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) <": 5046, + " ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) :": 5047, + "MAT *": 5048, + "elaps": 5049, + "riDivided": 5050, + "riDividedOn": 5051, + "riDividedOnDi": 5052, + "riDividedOnDiCla": 5053, + "riDividedOnDiClause": 5054, + "ni + (-1)) <": 5055, + " + (-1))) ? (ni": 5056, + " + (-1))) ? (ni + (-1)) :": 5057, + "single": 5058, + ") > 0.": 5059, + "; i++)\n for (j = 0; j < 1": 5060, + " = 0; i2": 5061, + "];\n }\n\n}\n": 5062, + ") && (j": 5063, + ") ordered": 5064, + "stddev[j]": 5065, + "_time": 5066, + "avg": 5067, + "N - 1": 5068, + "Word": 5069, + "][l": 5070, + "buf[3": 5071, + "Knode": 5072, + ");\n\n}\n": 5073, + "top": 5074, + "++)\n {\n if (": 5075, + "6, ": 5076, + " - 1); i2": 5077, + "[6": 5078, + ")\n goto L": 5079, + "(c": 5080, + "[i] = 0": 5081, + "1) + 1": 5082, + "; i < (": 5083, + "_context ": 5084, + "s = omp_get_num_threads(": 5085, + "begin": 5086, + "for (int j = ": 5087, + "sible": 5088, + "2147": 5089, + "grid[i][j]": 5090, + "s[1]": 5091, + "KL": 5092, + "_pbkdf2": 5093, + ", &ipad, &opad": 5094, + "[iel][face": 5095, + " + k][j]": 5096, + "c15": 5097, + "deno": 5098, + "cost": 5099, + "commun": 5100, + "stats->distance": 5101, + "400) * ((8 * ((2000 - 1) / 8)) + 8": 5102, + ") + 16) + 1) / 16)) :": 5103, + "buf[2": 5104, + "if (key_rank": 5105, + "failed = 1": 5106, + " = in.bit._": 5107, + " < 2": 5108, + ") + (j - 1)": 5109, + "for (i3": 5110, + "_len": 5111, + "#pragma omp single": 5112, + "; i++)\n{\n for (j = 0; j < 2048": 5113, + "dynamic)": 5114, + "omp target parallel for simd safelen(": 5115, + "256 / 1": 5116, + "A[i][k] * ": 5117, + "483647": 5118, + "boxes": 5119, + "4.0 / (1.0 + (x * x": 5120, + "fx": 5121, + "bool": 5122, + "key, ": 5123, + "const float ": 5124, + "PNG": 5125, + "s[j": 5126, + "road": 5127, + "partition": 5128, + ";\n }\n else\n {\n ": 5129, + "u[1": 5130, + "gam": 5131, + " = x4": 5132, + "image[indx": 5133, + "699": 5134, + "tep": 5135, + "Buffer": 5136, + "pend(": 5137, + ", f": 5138, + ", unsigned ": 5139, + "my_grid->": 5140, + "=%f\\n\", ": 5141, + "for (m = 0; m < 5; m++)\n{\n ": 5142, + "lotus_": 5143, + ", float ": 5144, + "[i] = i;\n ": 5145, + " * x[j]": 5146, + "particles": 5147, + "row][col": 5148, + "for (c4 = ": 5149, + "omp parallel for private(j)": 5150, + "))) + ": 5151, + "arch": 5152, + "for (k = 1; k <= (grid_points[2] - 2); k++)\n {\n ": 5153, + "D.": 5154, + ") ? (ni": 5155, + ") ? (ni) : (n": 5156, + "trans": 5157, + "swit": 5158, + "switch": 5159, + "De": 5160, + "bodie": 5161, + "jg": 5162, + "act_": 5163, + "row, col": 5164, + "1.0 - ": 5165, + "(xyzInd": 5166, + "idmo[ntemp": 5167, + "2048 - 1": 5168, + ") + row": 5169, + "for (m = 0; m < 3; m": 5170, + "ql": 5171, + "head.": 5172, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < ": 5173, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < y": 5174, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < y; i++)\n ": 5175, + " = ((-tmp2) * fjac": 5176, + "symmat[(j1": 5177, + "symmat[(j1 * (": 5178, + ";\n }\n\n #pragma omp simd\n for (c4 = nm": 5179, + " *= postScale;\n u[": 5180, + "if (key_rank != (test_rank_array": 5181, + "[idx[i]], &": 5182, + " ^= u3;\n ;\n u1 = ": 5183, + "A6": 5184, + " <= ((((((((n": 5185, + "cptr": 5186, + "5_r": 5187, + "i - ": 5188, + " - 1); j": 5189, + "Center": 5190, + "gene": 5191, + "points": 5192, + " + 1) % ": 5193, + ";\n }\n\n for (c2 = ": 5194, + "[i3][i2 - 1": 5195, + "struct": 5196, + "_iter": 5197, + ", 0, (MPI_Comm) 0x44000000": 5198, + "recv": 5199, + "for (z = 0; z": 5200, + ";\n int i;\n int ": 5201, + "value = ": 5202, + "omp target teams distribute parallel for simd collapse(": 5203, + "])\n {\n ": 5204, + "su": 5205, + ";\n else\n ": 5206, + "i += ": 5207, + ") + ((((": 5208, + "array[i]": 5209, + ") - 1) / ": 5210, + ", float *": 5211, + "fun": 5212, + "1, n2, n3": 5213, + "lotus_magic": 5214, + "lotus_magic_table": 5215, + "40e+00": 5216, + ") reduction(+:c)": 5217, + "for (i = 0; i < 16; ++i)\n{\n ": 5218, + "page": 5219, + "2;\n double ": 5220, + "long long int ": 5221, + "quen": 5222, + "z.": 5223, + " + (a": 5224, + "(&b": 5225, + "else\n ": 5226, + "n1": 5227, + "1111": 5228, + "Wor": 5229, + "m * ": 5230, + "c[": 5231, + ";\n double ": 5232, + "origin": 5233, + ";\n x0": 5234, + "thread_count": 5235, + "tx[i": 5236, + "tx[il": 5237, + "utex": 5238, + ") * (1 * 100)) * (1 * 100))))) + i": 5239, + "psc": 5240, + "cptr[idx": 5241, + "; k++)\n ": 5242, + ")\n{\n float ": 5243, + "; row++)\n{\n ": 5244, + ", sup": 5245, + "[j + 1": 5246, + "OMP_Index(x, y, z": 5247, + "_w": 5248, + "979": 5249, + "=%d": 5250, + "mple": 5251, + "m;\n ": 5252, + " = temp": 5253, + "v_size": 5254, + "comz1": 5255, + "][i + 1][j][k": 5256, + "][i][j + 1][k": 5257, + "20.": 5258, + "ia": 5259, + "][0][1": 5260, + ") + (i * ": 5261, + "kk": 5262, + "hy": 5263, + " = j;\n ": 5264, + ") * ny": 5265, + "Time": 5266, + "omp parallel for schedule(dynamic": 5267, + " = 0.0;\n }\n\n}\n": 5268, + "c10": 5269, + "y += ": 5270, + "0][m]": 5271, + ")))))))) + (": 5272, + "omp parallel for private(c2)": 5273, + " + 1); j++)\n {\n ": 5274, + "for (row = 0; row < ": 5275, + "close": 5276, + "])\n {\n ": 5277, + "5 - ": 5278, + "c = 0; c": 5279, + "fabs": 5280, + "local_B": 5281, + "omp target parallel for simd simdlen(": 5282, + "G->g": 5283, + "_ctx": 5284, + ").": 5285, + "2d": 5286, + " = (-1": 5287, + "exact_": 5288, + "exact_solu": 5289, + "Hash": 5290, + "averageR": 5291, + "averageG": 5292, + "averageB": 5293, + "edImage": 5294, + "; c3 <= ((((16 * c1) + 15) < (nm + (-1))) ? ((16 * c1) + 15) : (nm + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 5295, + "; c3 <= ((((16 * c1) + 15) < (nj + (-1))) ? ((16 * c1) + 15) : (nj": 5296, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nm + (-1))) ? ((16 * c2) + 15) : (nm + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 5297, + "curr_p": 5298, + "->v.": 5299, + " & m;\n tmp = tmp": 5300, + "vot": 5301, + "omp target teams distribute parallel for simd": 5302, + "A_i": 5303, + "for (j = 0; j < N": 5304, + "eta * ": 5305, + "deg": 5306, + " = _mm_loadu_ps(": 5307, + " = (b": 5308, + "PageRank": 5309, + "16 * c0": 5310, + "2147483647": 5311, + "rhs[m][i][j][k] = ": 5312, + "B[k][j]": 5313, + "_de": 5314, + " == 1)\n ": 5315, + "(x);": 5316, + "[x][y": 5317, + "];\n ": 5318, + "our_": 5319, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (": 5320, + " * ((8 * ((2000 - 1) / 8)) + 8": 5321, + "][5 - 1]": 5322, + " + 1)]": 5323, + "[i] + ": 5324, + "; i++)\n {\n if (": 5325, + "(num_": 5326, + "add_": 5327, + "ce[1": 5328, + "][m] + (xi": 5329, + "][m] + (xi * (ce[": 5330, + "][m] + (eta * (ce[": 5331, + "][m] + (zeta * (ce[": 5332, + "[1037": 5333, + "b = b": 5334, + ".tv_sec": 5335, + ") + i] = ": 5336, + "s * ": 5337, + "; x++)\n{\n ": 5338, + "omp parallel for simd linear": 5339, + "\\n\\n\", ": 5340, + "_z": 5341, + "mage->content[i][j]": 5342, + "9]": 5343, + " - comz4": 5344, + ", C": 5345, + ") - 1;\n ": 5346, + "ild": 5347, + "maskedImage": 5348, + "diagn": 5349, + " <= (mm1 - 1); i1": 5350, + "969": 5351, + "] = ntemp": 5352, + "]) - ": 5353, + "[bid]].": 5354, + "element_size": 5355, + "555": 5356, + "****************": 5357, + "Limit": 5358, + " <= 4; m": 5359, + " << 4) | ": 5360, + "atomic": 5361, + "}\n}\n\n": 5362, + "s;\n}\n": 5363, + "_int": 5364, + " ,j": 5365, + "omp parallel for private(x": 5366, + "dout": 5367, + "sum, ": 5368, + "info->": 5369, + "[k][i": 5370, + "roo": 5371, + "local_C": 5372, + "multi": 5373, + "tImage": 5374, + "gr->vl[i].": 5375, + "static double ": 5376, + "C[(i * ": 5377, + "++)\n{\n for (c2 = 0; c2 <=": 5378, + "argv[": 5379, + ";\n int ": 5380, + "n)]": 5381, + " = %d\\n\", ": 5382, + "; i++)\n ": 5383, + "; i += 4)\n{\n ": 5384, + ";\n }\n\n }\n else\n {\n ": 5385, + "(double ": 5386, + "stage": 5387, + "omp parallel for simd aligned": 5388, + "_column": 5389, + "ok": 5390, + "])) + (c2": 5391, + "])) + (c3": 5392, + " * xx": 5393, + "j + 1) * ": 5394, + "row_pointer": 5395, + "_here": 5396, + "face[": 5397, + "point_no": 5398, + "[i + 1][ind];\n ": 5399, + "b1": 5400, + "world_": 5401, + "u[((2 * i3) - ": 5402, + "u[((2 * i3) - t3": 5403, + "u[((2 * i3) - t3) - 1][((2 * i2": 5404, + ") - d2": 5405, + ") - d2) - 1][((2 * i1": 5406, + "[i3 - 1][i2 - 1][i1 - 1]": 5407, + ") - t1": 5408, + ") - t2": 5409, + ") - t2) - 1][((2 * i1": 5410, + "nn2": 5411, + "; c3 <= ((((16 * c1) + 15) < (nk + (-1))) ? ((16 * c1) + 15) : (nk": 5412, + "nm) + (-1": 5413, + "u[((2 * i3) - d3": 5414, + "u[((2 * i3) - d3) - 1][((2 * i2": 5415, + " + ni": 5416, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 5417, + "][2 * i2": 5418, + "][(2 * i1) + 1": 5419, + "][(2 * i2) + 1": 5420, + "u[(2 * i3": 5421, + "u[(2 * i3) + 1": 5422, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B": 5423, + "]), (vtype *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 5424, + " ^ a": 5425, + "33FF": 5426, + "AAAA": 5427, + "7A": 5428, + "000F": 5429, + "3B": 5430, + "C9": 5431, + "key_perm": 5432, + "key_permut": 5433, + "key_permutate": 5434, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nl + (-1))) ? ((((": 5435, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nl + (-1))) ? ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj": 5436, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nl + (-1))) ? ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) : (nl": 5437, + " + (-1))) : (nm + (-1))); c4++)\n {\n ": 5438, + "IC": 5439, + ", t": 5440, + "malloc((sizeof(": 5441, + "for (i = 0; i < 2048; i++)\n{\n for (j = 0; j < 2048": 5442, + ", int m": 5443, + "dimY": 5444, + "e = ": 5445, + "threads)": 5446, + "SD.": 5447, + "2];\n ": 5448, + "[ip": 5449, + "s[j] = ": 5450, + "uint8_t": 5451, + "not ": 5452, + "int *b": 5453, + "*j": 5454, + "rack": 5455, + "racked": 5456, + "t(&": 5457, + "))\n ": 5458, + "edgeList": 5459, + "atoi16[ARCH_INDEX(ciphertext": 5460, + "crypt": 5461, + " / 8": 5462, + "};\n ": 5463, + "jtr_sha512_": 5464, + "[(i * 1000": 5465, + "c0 = _mm_add_ps(": 5466, + "c0 = _mm_add_ps(c0": 5467, + "Src": 5468, + ")));\n ": 5469, + "au": 5470, + "++)\n{\n c": 5471, + "[i][j] = (": 5472, + "processe": 5473, + " + (y * ": 5474, + "continue;\n\n ": 5475, + "b:": 5476, + "if (j": 5477, + "[row][col": 5478, + " + i);\n ": 5479, + "difference": 5480, + "index = ": 5481, + ", &status": 5482, + "omp parallel for default(none) shared(": 5483, + "gap": 5484, + "nowait": 5485, + "0.5) * step": 5486, + "rial": 5487, + "s3": 5488, + "i, int *": 5489, + "j));\n}\n\n": 5490, + "cracked": 5491, + "][i][j][k] + ": 5492, + "JTR_A": 5493, + "JTR_AES": 5494, + "q;\n ": 5495, + " - 1] * ": 5496, + "29496": 5497, + "ator": 5498, + "bitmap": 5499, + "256 * ": 5500, + "ifntemp": 5501, + "test_index": 5502, + "test_index_array": 5503, + "].hashNum": 5504, + "u_y": 5505, + "proc": 5506, + "for (i = 0; i < 100; i++)\n{\n ": 5507, + "tern": 5508, + " < (((": 5509, + " )": 5510, + "input->x": 5511, + "result = 0;\n ": 5512, + ": %d\\n\", ": 5513, + " * (sizeof(int)));\n ": 5514, + "gettime": 5515, + "gettimeof": 5516, + "gettimeofda": 5517, + " = j + 1": 5518, + "#pragma omp for\n ": 5519, + "yy * ": 5520, + "}\n ": 5521, + "C + i": 5522, + "Tmp": 5523, + "}\n\n }\n else\n {\n ": 5524, + "]);\n ": 5525, + "72": 5526, + "knodes[": 5527, + "unique": 5528, + "File": 5529, + "e_": 5530, + "a[": 5531, + ")));\n b = b": 5532, + "for (i = 0; i < n; i++)\n{\n for (j = 0; j < n; j++)\n {\n ": 5533, + "linear(b:": 5534, + " = (k": 5535, + "for (i = 0; i < n; ++i)\n{\n ": 5536, + "omp parallel for schedule(dynamic,1": 5537, + "train": 5538, + ") / ((": 5539, + "entries": 5540, + "for (i = 1; i <= (grid_points[0] - 2); i++)\n {\n ": 5541, + " + x": 5542, + ")));\n foo": 5543, + ")));\n foo(&b": 5544, + ")));\n foo(&b, &i": 5545, + "inline static void foo(": 5546, + "inline static void foo(int *b": 5547, + "inline static void foo(int *b, int *": 5548, + "inline static void foo(int *b, int *i, int *": 5549, + "inline static void foo(int *b, int *i, int *j, int ": 5550, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n ": 5551, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b": 5552, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((": 5553, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b": 5554, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x": 5555, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*": 5556, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i": 5557, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*": 5558, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i": 5559, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((": 5560, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((*j": 5561, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((*j) - (*": 5562, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((*j) - (*j));\n}\n\n": 5563, + "dneto": 5564, + "byte": 5565, + "_per_": 5566, + "m1]))) + (": 5567, + "2);\n ": 5568, + "f1_layer[o": 5569, + "ang * ng": 5570, + "snakes[j].head.": 5571, + "start = ": 5572, + "eassign": 5573, + "vl[i].": 5574, + "##": 5575, + "; c4 <= ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 5576, + "for (c2 = ((": 5577, + "[l36": 5578, + "7) | (": 5579, + ")))) + (0.020408 * (*(((*((": 5580, + "col = col + 4;\n }\n\n #pragma omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 5581, + "dlen_p": 5582, + "3,": 5583, + "; r": 5584, + "[(x * ": 5585, + "-c": 5586, + "(num": 5587, + "out[": 5588, + "for (i = 0; i < 8192; i++)\n{\n ": 5589, + "; ++j)\n ": 5590, + "for (int i = 0; i < N; i++)\n{\n ": 5591, + "l->": 5592, + "->tab": 5593, + ")));\n": 5594, + ", temp": 5595, + " th": 5596, + ";\n }\n\n }\n\n if (": 5597, + "x = 0; x < ": 5598, + ", tmp": 5599, + "b[i];\n}\n": 5600, + "[i][j] = i": 5601, + "1F": 5602, + " +=": 5603, + "starting": 5604, + "for (j = 1; j <= (grid_points[1] - 2); j++)\n {\n ": 5605, + "for (i = 0; i < 512; i++)\n{\n for (j = 0; j < ": 5606, + "for (i = 0; i < 512; i++)\n{\n for (j = 0; j < 512": 5607, + "med": 5608, + "password": 5609, + ");\n sph_sha1": 5610, + "_sqr": 5611, + "Lin": 5612, + "[position": 5613, + "B1": 5614, + "29496729": 5615, + "294967295": 5616, + "294967295U": 5617, + "child": 5618, + "y[l36": 5619, + "*((MD5_std_combined *) (((char *) MD5_std_all_p) + t))).": 5620, + "EE": 5621, + "]);\n tmp": 5622, + "212": 5623, + "for (int i = 0; i < g->N; i++)\n{\n ": 5624, + "for (int i = 0; i < g->N; i++)\n{\n node *": 5625, + "elem_at(&g->vertices, i);\n ": 5626, + "#pragma omp simd\n ": 5627, + "c->": 5628, + " >= 1": 5629, + "%s": 5630, + ") reduction (+:": 5631, + "omp parallel for collapse(2": 5632, + ")))\n {\n ": 5633, + "m;\n k": 5634, + ")[i]": 5635, + ", 4)": 5636, + " + 1); ": 5637, + ")\\n\", ": 5638, + ") reduction(+:sum)": 5639, + "Id": 5640, + ";\n }\n else\n ": 5641, + "struct timeval": 5642, + "ow(": 5643, + "omp parallel for schedule(static)": 5644, + "p2": 5645, + "sph_sha1_context ": 5646, + "xx * xx": 5647, + ":%": 5648, + "char *) (&": 5649, + "r[j]": 5650, + "func": 5651, + "velocity": 5652, + "lhs[j][i": 5653, + "hprime": 5654, + "3030": 5655, + "_mutex": 5656, + "][0]))), (*((vtype *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).E.E": 5657, + "device": 5658, + " - 1) - 1)": 5659, + "size; j++)\n {\n ": 5660, + "Ch": 5661, + "for (i1 = 1; i": 5662, + "for (i1 = 1; i1": 5663, + "y - ": 5664, + " = i * ": 5665, + "));\n _mm_storeu_ps(": 5666, + "cos": 5667, + " == (n": 5668, + ") num_threads (": 5669, + "sizeof": 5670, + "Dimension": 5671, + "0)\n {\n ": 5672, + ")) : ((": 5673, + "rhs[m][i][j][k] = rhs[m": 5674, + "Ptr": 5675, + "gettimeofday(&": 5676, + "usec": 5677, + "[j] - ": 5678, + "global": 5679, + "ree(": 5680, + "0][i][j][k] = lhs[": 5681, + "1][i][j][k]": 5682, + "lhs[2": 5683, + "for (i = 1; i < (5 - 1)": 5684, + "u[3": 5685, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100))) + (((": 5686, + "][ii + (jj * params.nx)]": 5687, + "floor": 5688, + ");\n lhs[i][j][k": 5689, + "roadcast": 5690, + "256 * 256": 5691, + "512 * 512)": 5692, + "ue[4": 5693, + "_order": 5694, + "u[2 * i3": 5695, + "temp4": 5696, + "temp5": 5697, + "temp6": 5698, + "speed_": 5699, + "Vec": 5700, + "NK": 5701, + "] + b": 5702, + "memcpy": 5703, + "s, int ": 5704, + "son": 5705, + " > nl": 5706, + "omp parallel for lastprivate": 5707, + "input->d": 5708, + " = 0; i3": 5709, + "(seed": 5710, + "alpha * ": 5711, + "uint8_t *": 5712, + "for (l = 0; l": 5713, + "; c3 <= ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni": 5714, + "ument": 5715, + "matrix->nb": 5716, + "_pd(": 5717, + "union": 5718, + ", sum": 5719, + "sphere": 5720, + "[i] = (double": 5721, + " ": 5722, + "1.0 - (xx * xx": 5723, + "yy * yy": 5724, + "s[m": 5725, + " + (N_CELL_ENTRIES * ((x + (": 5726, + " + (N_CELL_ENTRIES * ((x + (y": 5727, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100": 5728, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((": 5729, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((z": 5730, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((z * (1 * 100": 5731, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((z * (1 * 100)) * (1 * 100))))": 5732, + "idmo[iel][face": 5733, + "rice": 5734, + " = x0": 5735, + "i);\n}\n": 5736, + "filter_list[y": 5737, + "jk": 5738, + "community": 5739, + "rand48": 5740, + "B4": 5741, + "tity": 5742, + "Block": 5743, + "250": 5744, + "encryp": 5745, + "addr": 5746, + "newe[iel] = ": 5747, + "newe[iel] = newe[iel": 5748, + " == 3) && (": 5749, + "[(indx": 5750, + " = idel": 5751, + " = idel[ie][iface": 5752, + "F(": 5753, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni + (-1)) / 16)) <": 5754, + " + (-1)) / 16))) ? ((((ni + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni": 5755, + " + (-1)) / 16))) ? ((((ni + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni + (-1)) / 16)) :": 5756, + "*ha": 5757, + "*ha = ": 5758, + "Knode[bid]].": 5759, + "back": 5760, + ";\n }\n\n #pragma omp simd\n for (c4 = nj": 5761, + "-2) * c3) + ": 5762, + ";\n vtype x4": 5763, + " = a6": 5764, + "(png, ": 5765, + "B[c3][c4] = (((double) c3) * (c4 + 1)) / nj;\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 5766, + "temp7": 5767, + "temp0": 5768, + "] = _mm512_set1_ps(": 5769, + "c1 * ": 5770, + "for (k = 0; k < n": 5771, + "sorted_": 5772, + "elapsed": 5773, + "PP": 5774, + "[i][j];\n }\n\n}\n": 5775, + "_B": 5776, + "] != ": 5777, + " h": 5778, + "datlen": 5779, + "Type": 5780, + "Pos": 5781, + "; iter": 5782, + " - (4.0 * ": 5783, + "data = ": 5784, + "_P": 5785, + "block_size": 5786, + "john_MD5_Update": 5787, + "ERR": 5788, + "ERROR": 5789, + "++;\n}\n": 5790, + "edges": 5791, + "\\t\", ": 5792, + "assert(": 5793, + "cat": 5794, + "Edge": 5795, + " (*": 5796, + "Set->": 5797, + "ff).": 5798, + ") : (-": 5799, + "]))": 5800, + "; fi": 5801, + "gram": 5802, + " << 4) | atoi16[ARCH_INDEX(p": 5803, + "#pragma omp atomic": 5804, + "imum": 5805, + "salt->": 5806, + ") schedule (": 5807, + ";\n\n }\n\n ": 5808, + "[i].x": 5809, + "rev": 5810, + "copy": 5811, + " = ((((DATA_TYPE) i": 5812, + " *) calloc(": 5813, + "row = ": 5814, + "0:": 5815, + "1.0 - (yy * yy": 5816, + "douto": 5817, + "][i][j]": 5818, + "vet": 5819, + "4.": 5820, + ") + km0": 5821, + "Idx": 5822, + "newe[iel] = newe[iel] + 1": 5823, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (i": 5824, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (i * ((8 * ((2000 - 1) / 8)) + 8": 5825, + ".r;\n double ": 5826, + "_mm256_b": 5827, + "_mm256_broadcast": 5828, + "_mm256_broadcast_s": 5829, + "posi": 5830, + "linha": 5831, + "); c4++)\n {\n ": 5832, + "10101010": 5833, + "C3": 5834, + "[i].bit._": 5835, + "initi": 5836, + "weigh": 5837, + "outer": 5838, + "for (m = 0; m <= 4; m": 5839, + ") + k]) * ": 5840, + "for (i = 0; i < 10000; ++i)\n{\n ": 5841, + "));\n }\n\n ": 5842, + "])\n ": 5843, + ")) / ((double) ": 5844, + "mat->": 5845, + "lide_grid": 5846, + "for (i = 0; i < 1024; i++)\n{\n for (j = 0; j < 1": 5847, + "for (i = 0; i < 1024; i++)\n{\n for (j = 0; j < 1024": 5848, + "pad": 5849, + " * re": 5850, + "u[2": 5851, + "s[(ii * params.nx) + jj].speeds[": 5852, + " * (n": 5853, + "vertex_id": 5854, + "75": 5855, + "selected": 5856, + "dataSet": 5857, + "_free(": 5858, + "End": 5859, + "private[i].d_": 5860, + "sqrt(i": 5861, + "omp parallel for schedule(SCHEDULING_METHOD)": 5862, + "fi = 0; ": 5863, + "fi = 0; fi": 5864, + "fi = 0; fi < 1": 5865, + "fi = 0; fi < 10.0": 5866, + "fi = 0; fi < 10.0; fi": 5867, + "fi = 0; fi < 10.0; fi++)\n{\n c": 5868, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi": 5869, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a": 5870, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi": 5871, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi] + b": 5872, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi] + b[(int) fi": 5873, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi] + b[(int) fi];\n}\n": 5874, + "}\n\n\n\n": 5875, + "weights[": 5876, + "arrayY": 5877, + "mark": 5878, + "][i][j2": 5879, + ";\n if (": 5880, + "_close": 5881, + "col, ": 5882, + "tablo": 5883, + "FA": 5884, + "cs.": 5885, + "una": 5886, + "struct timeval ": 5887, + "OMP_xMax; x": 5888, + "Cent": 5889, + "[d": 5890, + "bv_size": 5891, + "bv[": 5892, + "s[i][j]": 5893, + "RO": 5894, + "fprintf(stdout": 5895, + "p.": 5896, + "range": 5897, + "exact_solution(": 5898, + "arr[": 5899, + ") - 1] * nu;\n u[": 5900, + ") + 1] * nu;\n u[": 5901, + "_end": 5902, + "exchange": 5903, + "dw": 5904, + "));\n c00 = _mm_add_ps(c00, _mm_mul_ps(a": 5905, + ") + A": 5906, + "children": 5907, + "ici": 5908, + " + (-1))) : (nm + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((((": 5909, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nk + (-1))) ? ((16 * c2) + 15) : (nk + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 5910, + ") < ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))) ?": 5911, + "); c4 <= ((((16 * c2) + 15) < (n": 5912, + "con4": 5913, + ") + 1;\n ": 5914, + ";\n uint32_t ": 5915, + "all/": 5916, + "v2": 5917, + "j;\n ": 5918, + "FP_NUMBER) ": 5919, + " + (i": 5920, + "for (int jj = 0; j": 5921, + "; col++)\n {\n ": 5922, + "diff;\n double ": 5923, + "[k][j][i]": 5924, + "->entries": 5925, + "->entries + (": 5926, + "[5]": 5927, + "i - 1) * ": 5928, + "0);\n ": 5929, + "num_hf": 5930, + "[i]; j < ": 5931, + " / 2;\n ": 5932, + "local_A->n_bar": 5933, + ") + l": 5934, + "mx": 5935, + "output_array[x": 5936, + "nx) * ny": 5937, + "++;\n\n ": 5938, + "_partition": 5939, + "randlc": 5940, + "Que": 5941, + "pole": 5942, + "_dest": 5943, + "snakes[i].": 5944, + "block_width": 5945, + "tag_h": 5946, + "2 * c3": 5947, + "ijk": 5948, + "ick": 5949, + ") + k] * B": 5950, + "omp distribute parallel for simd aligned": 5951, + "[src": 5952, + " = 0; r": 5953, + "A[c1][c2] = (((double) c1) * c2) / ni;\n ": 5954, + "].neighbor": 5955, + "k - 1": 5956, + "[i1] = ((": 5957, + "[i1 + 1]": 5958, + "_ptr)": 5959, + "time = ": 5960, + ".val": 5961, + "uth": 5962, + "\", \"": 5963, + "prev": 5964, + "];\n int i": 5965, + "oria": 5966, + "z.r * z": 5967, + "};\n ": 5968, + "4]": 5969, + "[(i * NJ": 5970, + "[(i * 1024) + j]": 5971, + "ish": 5972, + "memcmp(": 5973, + "p; ": 5974, + "_aux": 5975, + "2_g": 5976, + "[(col * ": 5977, + "largest_": 5978, + "vide": 5979, + "][ti": 5980, + "#pragma omp flush\n ": 5981, + " == 3) && (sje[ntemp": 5982, + ") - 1] + (": 5983, + "][i1 - 1]) + z": 5984, + "_particle": 5985, + "T4": 5986, + " = box": 5987, + "tmor[ig": 5988, + "je1": 5989, + "E6": 5990, + ") + n) + 1": 5991, + "eta) * ": 5992, + ")) = zero;\n *((vtype *) (((long *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 5993, + ")) ^ (": 5994, + "32_t ": 5995, + "til": 5996, + "sum = 0.0;\n ": 5997, + ");\n if (!": 5998, + "z[j]": 5999, + "#pragma omp parallel for private(c2": 6000, + "[i][j] * ": 6001, + "++;\n\n ": 6002, + "sg": 6003, + "n * ": 6004, + "_length": 6005, + "#pragma omp ordered\n ": 6006, + "s[i];\n ": 6007, + ")) &": 6008, + "i0 = i": 6009, + "encod": 6010, + "sz": 6011, + "inate": 6012, + "c[i] = ": 6013, + "saved_len": 6014, + "public.in2_sub": 6015, + "video": 6016, + " == c2": 6017, + "[r": 6018, + "mod": 6019, + "750": 6020, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (i * ((8 * ((2000 - 1) / 8)) + 8))": 6021, + "new_centroid": 6022, + "halo": 6023, + "edge_label": 6024, + "ue[1": 6025, + "ue[2": 6026, + "ue[3": 6027, + "[element_size": 6028, + "cells[((": 6029, + "Counter": 6030, + "b, ": 6031, + "); i++)\n ": 6032, + "Vertex": 6033, + "nza": 6034, + "exit(1": 6035, + ";\n int i2": 6036, + " > nk) ? (nj) : (n": 6037, + " > nk) ? (nj) : (nk": 6038, + "grou": 6039, + "omp parallel for reduction(+: l) collapse(3)": 6040, + "omp parallel for reduction(+: l) collapse(3) schedule(runtime)": 6041, + "kern_": 6042, + "crypt_out[index": 6043, + "Threads": 6044, + "[col]);\n col = col + 4;\n}\n": 6045, + ".j": 6046, + " %s": 6047, + ")) + 3": 6048, + "rand() % 10": 6049, + "for (i = 0; i < 10; i++)\n{\n ": 6050, + "rhs[m][i][j][k]": 6051, + ", int i, int j, int ": 6052, + ", index": 6053, + " / 4) * ": 6054, + "==": 6055, + "num_threads = omp_get_num_threads(": 6056, + " + (1 * ": 6057, + ") + (d": 6058, + "[j - 1]": 6059, + ") / 2": 6060, + "a[i] * ": 6061, + "(j": 6062, + "for (size_t i = 0; i < ": 6063, + "rowstr[j]": 6064, + "graph *": 6065, + "fprintf(stdout, \"": 6066, + "size_": 6067, + "iterations": 6068, + "switch (": 6069, + "break;\n\n ": 6070, + "[(i * NY) + j]": 6071, + "num_team": 6072, + "1_g": 6073, + "A[i": 6074, + " = (x": 6075, + "omp parallel for reduction(+: l) collapse(3) schedule(static, 2)": 6076, + "tp": 6077, + "ind + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 6078, + "dEo11": 6079, + "dEo22": 6080, + "chunk_idx": 6081, + "for (int i = 0; i < 3": 6082, + "][ti].": 6083, + "3 * h": 6084, + "conver": 6085, + "4294967295U": 6086, + " = (tmp1 * 2.0) * njac": 6087, + " = (tmp2 * fjac": 6088, + "32768": 6089, + "itImage": 6090, + "buffer_": 6091, + "T1;\n ": 6092, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))); c2++)\n {\n for (c3 = 16 * c1": 6093, + "; c3 <= ((((16 * c1) + 15) < (nj + (-1))) ? ((16 * c1) + 15) : (nj + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nm + (-1))) ? ((16 * c2) + 15) : (nm + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 6094, + "nk + ni": 6095, + ") + nj": 6096, + "data.": 6097, + "32 * c0": 6098, + ") + 29": 6099, + "5A0F": 6100, + "D2": 6101, + "B6": 6102, + ";\n vtype x11": 6103, + "33CC33CC": 6104, + "55AA": 6105, + "C0C0": 6106, + "7B7B": 6107, + "5A55": 6108, + "_mm256_broadcast_ss(&": 6109, + "....": 6110, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl": 6111, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) :": 6112, + " <= ((16 * c2) + 15": 6113, + " <= ((16 * c2) + 15); c4++)\n {\n ": 6114, + "7))) ^": 6115, + "7))) ^ ((": 6116, + ")))) ^ (": 6117, + "thread_l": 6118, + ") collapse(2)": 6119, + "2,": 6120, + "_outputFromGpu": 6121, + "tmp += ": 6122, + "keys": 6123, + "for (i = 0; i < NX": 6124, + "for (j = k": 6125, + "ther": 6126, + " 0.0": 6127, + "omp_get_thread_num()": 6128, + "0000000; j++)\n ": 6129, + "(t": 6130, + "y[i]": 6131, + "_hmac": 6132, + "hash = ": 6133, + "}\n else": 6134, + ")) |": 6135, + "Rand": 6136, + "][4] = ": 6137, + ".0;\n ": 6138, + "1'": 6139, + "ron": 6140, + "compute_t": 6141, + "s[thread": 6142, + "coef": 6143, + "unsigned long ": 6144, + ") + (3 * ": 6145, + "][0]))) ^ (*((vtype *) (&k[": 6146, + "3_r": 6147, + "2_r": 6148, + "1_r": 6149, + "4, 8)": 6150, + ";\n}\n\nvoid ": 6151, + "for (int i = 0; i < 64": 6152, + "[i - 1][j - 1]": 6153, + "elem_at(&g->vertices, i);\n payload *": 6154, + ", \"\\n\");\n}\n": 6155, + "termin": 6156, + "sum += (": 6157, + "4 4)": 6158, + "foo())": 6159, + "#pragma omp parallel for private(c2 )\n ": 6160, + "dist_": 6161, + "[j]);\n }\n\n}\n": 6162, + "omp parallel for firstprivate(i": 6163, + ") lastprivate(i": 6164, + "for (i = 0; i < 2": 6165, + "2.5)": 6166, + "4, , 4)": 6167, + "q->": 6168, + "E-": 6169, + "4, )": 6170, + "m; i++)\n{\n ": 6171, + "NO": 6172, + "fff": 6173, + "ctx;\n ": 6174, + ".3": 6175, + "-5)": 6176, + "c3c4": 6177, + "struct tablo": 6178, + "hash = hf": 6179, + "hash = hf[j]": 6180, + "hash = hf[j](": 6181, + "hash %= ": 6182, + "hash %= bv_size": 6183, + "lhs[n + 4][i][j][k": 6184, + "])]": 6185, + " + 1;\n": 6186, + " = (i": 6187, + "text": 6188, + " = (n": 6189, + ";\n }\n else\n ": 6190, + "By": 6191, + "eli": 6192, + "mage[indx": 6193, + " = _mm256_": 6194, + "ped_": 6195, + " >> 2": 6196, + "));\n c0 = _mm_add_ps(c0": 6197, + "ray_": 6198, + "6_g": 6199, + "omp parallel for default(none) private(i": 6200, + "C[i]": 6201, + "for (int i = 0; i < size; i++)\n{\n ": 6202, + "for (int j = 0; j < N": 6203, + ")\n return 1;\n\n": 6204, + "for (int i = 1; i < ": 6205, + "sum += sqrt(i": 6206, + "[x + (y * ": 6207, + " - 1); i3": 6208, + "s[i], ": 6209, + "CK": 6210, + ") + (n": 6211, + "upper": 6212, + "labelpath": 6213, + ", y, z": 6214, + " - 1) * (": 6215, + "(double x": 6216, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + x;\n}\n\n\nint ": 6217, + "for (z = 0; z < ": 6218, + "2 * 1": 6219, + "mis": 6220, + "Stat": 6221, + ";\n }\n\n ": 6222, + " + 1;\n ": 6223, + "#pragma ce": 6224, + "#pragma cet": 6225, + "#pragma cetus": 6226, + "4 - ": 6227, + ")) - ((": 6228, + "] = input_array[x": 6229, + "ness": 6230, + "_comp": 6231, + "Ones": 6232, + "matB": 6233, + "dim_cpu": 6234, + "dim_cpu.": 6235, + "if (c1 == c2": 6236, + "grid_points[1]": 6237, + "grid_points[2]": 6238, + "*p": 6239, + " for ": 6240, + " = (i * ": 6241, + "];\n double ": 6242, + "for (i2 = 1; i": 6243, + "for (i2 = 1; i2": 6244, + "diameter": 6245, + "lone": 6246, + "atoi16[ARCH_INDEX(*": 6247, + "omp parallel for shared (": 6248, + "[i] = ((": 6249, + "Sor": 6250, + "_curr": 6251, + "), (": 6252, + "A[(i * 8192": 6253, + " = m": 6254, + "OMP_z": 6255, + "OMP_zMax": 6256, + "0.5)\n {\n ": 6257, + "5 + (": 6258, + " of the ": 6259, + "n_grid": 6260, + "num_particle": 6261, + "0.5) * step;\n ": 6262, + ", 1, (MPI_Datatype) 0x4c00040": 6263, + "L, ": 6264, + "); i++)\n {\n ": 6265, + "(int n": 6266, + "bv[hash": 6267, + "Matrix(": 6268, + "for (i = 1; i <= 10; i++)\n{\n ": 6269, + "parent": 6270, + "omp parallel for reduction(+:sum) schedule(static,": 6271, + "u[0]": 6272, + "0];\n ": 6273, + "finish": 6274, + "glob": 6275, + "rat": 6276, + "25 * (((": 6277, + "xyzInd + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 6278, + "private.point_no": 6279, + "][t": 6280, + "nang * ng": 6281, + "mom": 6282, + "_state": 6283, + ") + (j * size": 6284, + "tempU": 6285, + "[iel][3": 6286, + ")) : (": 6287, + "set_lock(&tlock[ig])": 6288, + "En": 6289, + "tt": 6290, + "; c3 <= ((((16 * c1) + 15) < (nk + (-1))) ? ((16 * c1) + 15) : (nk + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 6291, + "m_free(": 6292, + "zeta) * ": 6293, + "cent_": 6294, + "if (c1 == c2)\n {\n ": 6295, + "if (c1 == c2)\n {\n #pragma omp simd\n ": 6296, + ") + 0x": 6297, + "for (i = 0; i < 20; ++i)\n{\n dsum += ": 6298, + "for (i = 0; i < 20; ++i)\n{\n dsum += pow(dt, i);\n}\n": 6299, + "bot": 6300, + "for (int i = 0; i < 1024": 6301, + " >> (": 6302, + ";\n C": 6303, + "for (n = 0; n": 6304, + "r = 0; r": 6305, + "[i3 - 1][i2 - 1][i1]": 6306, + "/ho": 6307, + "/home": 6308, + "/home/": 6309, + "/home/ree": 6310, + "/home/reemh": 6311, + "/home/reemh/": 6312, + "/home/reemh/CL": 6313, + "/home/reemh/CLPP": 6314, + "/home/reemh/CLPP/": 6315, + "/home/reemh/CLPP/g": 6316, + "/home/reemh/CLPP/gith": 6317, + "/home/reemh/CLPP/github": 6318, + "/home/reemh/CLPP/github-c": 6319, + "/home/reemh/CLPP/github-clone": 6320, + "/home/reemh/CLPP/github-clone-": 6321, + "/home/reemh/CLPP/github-clone-all/": 6322, + "/home/reemh/CLPP/github-clone-all/re": 6323, + "/home/reemh/CLPP/github-clone-all/repos_": 6324, + "/home/reemh/CLPP/github-clone-all/repos_final": 6325, + "/home/reemh/CLPP/github-clone-all/repos_final/": 6326, + "j)\n {\n ": 6327, + "_O": 6328, + "size, ": 6329, + "break;\n }\n\n}\n": 6330, + "2.0 * (": 6331, + "y * (": 6332, + ") reduction(+: ": 6333, + "1.0 / ": 6334, + " %lf": 6335, + "[(i * NL": 6336, + "a[i];\n}\n": 6337, + " <= ((((((((": 6338, + "Local": 6339, + "; j--": 6340, + "isect": 6341, + ");\n if (": 6342, + "for (i = 1; i <= 10; i++)\n{\n product *= ": 6343, + "for (i = 1; i <= 10; i++)\n{\n product *= i;\n}\n": 6344, + "0) * ": 6345, + "_K": 6346, + "1 = (": 6347, + "_height": 6348, + ") == 0)\n ": 6349, + "; ++i)\n{\n diff = diff - i": 6350, + "; ++i)\n{\n diff = diff - i;\n}\n": 6351, + "chk": 6352, + "[0][i": 6353, + "world->": 6354, + " == 0)\n {\n ": 6355, + "k = 0; k": 6356, + "dcomplex ": 6357, + ") == 1": 6358, + ")))) + ((": 6359, + " = ((double) i": 6360, + "for (i = 0; i < 20; ++i)\n{\n ddiff -= ": 6361, + "for (i = 0; i < 20; ++i)\n{\n ddiff -= pow(dt, i);\n}\n": 6362, + "u[k][j][i": 6363, + "_squ": 6364, + "setup": 6365, + "gamma": 6366, + "330": 6367, + "_pool": 6368, + "(*((MD5_std_combined *) (((char *) MD5_std_all_p) + t))).": 6369, + "kern_cent_": 6370, + "4_r": 6371, + "vertices->out_degree": 6372, + "sorted_edges_array": 6373, + "used": 6374, + "x[i": 6375, + " <= (((((": 6376, + "for (int j = 0; j < n; j++)\n ": 6377, + "added": 6378, + "m; j++)\n{\n ": 6379, + "[i][j] = ((": 6380, + "flux[i][j][k": 6381, + "if ((((i": 6382, + "0) += (*((A + i) + k": 6383, + "(0": 6384, + "][i][j1][k]": 6385, + " - (lhs[n + 0": 6386, + "static,1": 6387, + "))\n ": 6388, + "r * ": 6389, + " + 1] - ": 6390, + "0)\n {\n ": 6391, + "Nodes[i].": 6392, + ") + j] = (((DATA_TYPE) i) * (j": 6393, + "sum = sum + i2": 6394, + ")) > (((": 6395, + "section": 6396, + "Me": 6397, + ") + offset": 6398, + " -1": 6399, + "for (j = 0; j < 5": 6400, + "matrix_size": 6401, + "crypt_out[index], ": 6402, + "->p": 6403, + "stats->vector": 6404, + "omp parallel for reduction(+:sum) schedule(static,7": 6405, + "some": 6406, + "][i][j][k] - (dssp * (((": 6407, + "tests": 6408, + "area": 6409, + "][i1][j][k]": 6410, + " / 2)": 6411, + ")) / ((": 6412, + "low) - 1;\n ": 6413, + ";\n else\n ": 6414, + "));\n *((C + i) + m": 6415, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < y; i++)\n ;\n\n": 6416, + "_src": 6417, + "sum = sum + (i + i": 6418, + "old_": 6419, + "maskMatrix": 6420, + " >> 13": 6421, + "256 * 256)) + ((": 6422, + "f, ": 6423, + "512 * 512)) + ((": 6424, + "512)) + (": 6425, + "oldDistance": 6426, + "n3": 6427, + "INT_TYPE": 6428, + ") + image->content": 6429, + "_b4": 6430, + "dsum)": 6431, + "for (i = 0; i < rows": 6432, + "*(p": 6433, + ") shared(n": 6434, + "omp parallel for reduction(+:sum) schedule(": 6435, + "6.0": 6436, + ")\n {\n if (": 6437, + "NUM_THREADS": 6438, + " = 0.5;\n double ": 6439, + ",y": 6440, + "5 - 5)": 6441, + ")] += ": 6442, + "7ffff": 6443, + "7fffffff": 6444, + "argc": 6445, + "send_": 6446, + "val1 - val2": 6447, + "/ ": 6448, + "pred": 6449, + " = 2": 6450, + ");\n double ": 6451, + "argv[i], \"": 6452, + ", n);\n ": 6453, + ";\n }\n\n }\n\n }\n\n ": 6454, + "stack": 6455, + "git": 6456, + ", i);\n ": 6457, + ": %f": 6458, + "break;\n\n ": 6459, + "_chunk.x": 6460, + "0) : (": 6461, + "salt_": 6462, + "key_array": 6463, + "2] * ": 6464, + "es_": 6465, + "_cnt": 6466, + ";\n vtype ": 6467, + "); c2 <=": 6468, + ") private(x)": 6469, + " + 2) * ": 6470, + "omp parallel for ordered ": 6471, + "DB": 6472, + "image->col": 6473, + "c[j]": 6474, + ") + 6": 6475, + ");\n }\n\n }\n\n}\n\n": 6476, + " + ((i": 6477, + "-2": 6478, + ";\n int y": 6479, + "8; j++)\n{\n ": 6480, + " = (((((((": 6481, + ";\n\n}\n\n\n": 6482, + "5.0 * ": 6483, + "hz[(i * 2048) + j]": 6484, + " = (2 * ": 6485, + "(S": 6486, + "*:product)": 6487, + ")\n continue": 6488, + "start[0]": 6489, + " = (-1.0": 6490, + ";\n register int ": 6491, + " = (char *) (&": 6492, + "memcnt": 6493, + "loop ": 6494, + ";\n }\n\n }\n\n }\n\n}\n\n": 6495, + "3.0 * ": 6496, + "] += u[(": 6497, + "OMP_xMax) + OMP_xMax] += u[": 6498, + "] += u[((((": 6499, + "[(n": 6500, + "queue(": 6501, + "[(((offset": 6502, + "[(((offset * size": 6503, + "-16": 6504, + "omp parallel for reduction(+:sum) private(i": 6505, + "5;\n x": 6506, + "channels": 6507, + "VF": 6508, + "face_a[itemp]": 6509, + "Name": 6510, + "for (c2 = 0; c2 <= ((((((n": 6511, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) < ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))) ?": 6512, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) < ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))) ? ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) :": 6513, + "; c3 <= ((((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni": 6514, + "axp": 6515, + "[i][1": 6516, + "s[th": 6517, + "s[thid]": 6518, + "_pool->": 6519, + "16 * c8": 6520, + "C;\n vtype x": 6521, + ";\n vtype x21": 6522, + ";\n vtype x30": 6523, + "31;\n x": 6524, + ";\n x30": 6525, + " = x30": 6526, + "3366": 6527, + "3CC3C": 6528, + "1A": 6529, + "0F0FF": 6530, + "0F0FF0F0": 6531, + "); c3 <= ((((16 * c1) + 15) < (n": 6532, + "; c4 <= ((16 * c2) + 15); c4++)\n {\n ": 6533, + ")) ? (((nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj": 6534, + ")) ? (((nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj + 16) - 1) / 16))) : (((": 6535, + " + (-1))) < (nj": 6536, + " + (-1))) < (nj + (-1))) ? ((((": 6537, + " + (-1))) < (nj + (-1))) ? ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni": 6538, + " + (-1))) < (nj + (-1))) ? ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni + (-1))) : (n": 6539, + " + (-1))) < (nj + (-1))) ? ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni + (-1))) : (nj": 6540, + ";\n pstr->": 6541, + "float) 32767": 6542, + "%d\\n\", ": 6543, + ")\n return": 6544, + "dynamic,": 6545, + ",n": 6546, + "s,": 6547, + "fscanf(fp": 6548, + " - 1; i": 6549, + "for (i = 0; i < 64; i++)\n{\n ": 6550, + "abs(": 6551, + ") * (sizeof(": 6552, + "]) * ": 6553, + "9;\n int ": 6554, + ";\n int pro": 6555, + "];\n }\n\n ": 6556, + ") schedule(dynamic)": 6557, + "argument": 6558, + " > 0) ? (": 6559, + "local_B->n_bar": 6560, + "struct tablo *": 6561, + " than": 6562, + "\\n\");\n exit(1);\n ": 6563, + "ly": 6564, + "[mu": 6565, + "for (j = 1; j <= n": 6566, + "for (iter": 6567, + "y[i] = (": 6568, + "strcmp(argv[i], \"": 6569, + "_sha256": 6570, + "ordered(": 6571, + "last_i": 6572, + " **": 6573, + "s[i]->": 6574, + "omp parallel for reduction(+:sum) schedule(static,7) private(i": 6575, + "scanf(\"%d": 6576, + "mann": 6577, + "-:diff)": 6578, + "NZ": 6579, + "++;\n }\n\n ": 6580, + "].x": 6581, + "AL": 6582, + ";\n}\n\n\ninline ": 6583, + "-:ddiff)": 6584, + "1024 + 1)) + j]": 6585, + "addres": 6586, + "score": 6587, + "split": 6588, + "La": 6589, + "compute_triple": 6590, + "Cols": 6591, + "swapped_": 6592, + ";\n va = va | tmp": 6593, + ";\n va = va | tmp;\n tmp = v": 6594, + ";\n vb = vb | tmp": 6595, + "3_b": 6596, + "rho_i": 6597, + "leader": 6598, + "graph->vertice": 6599, + "s[i]);\n}\n": 6600, + "b;\n ": 6601, + " = sqrt(": 6602, + "[j + ": 6603, + " * i) + j]": 6604, + "[i] = i;\n s = ": 6605, + "[i] = i;\n s = -": 6606, + "[i] = i;\n s = -s;\n}\n": 6607, + "FI": 6608, + "))) * (": 6609, + "max:": 6610, + "test_omp_parallel_reduction(": 6611, + ";\n int result": 6612, + "logic_or = 0;\n ": 6613, + "bit_or = 0;\n ": 6614, + "exclusiv_bit_or = 0;\n ": 6615, + " %d\\n\", sum, ": 6616, + "i;\n }\n\n ": 6617, + " = 36": 6618, + " == 0;\n}\n\n": 6619, + "volu": 6620, + "for (i = row": 6621, + " (((((": 6622, + " * ru1": 6623, + "uint8_t *) ": 6624, + "is_larger = ": 6625, + "is_larger = check_i_islarger": 6626, + "is_larger = check_i_islarger2(i": 6627, + " , ": 6628, + "])];\n": 6629, + "2) ": 6630, + "[1][": 6631, + "citi": 6632, + "q[j]": 6633, + "colidx": 6634, + "s[i].x": 6635, + " = ((((DATA_TYPE) i) * j": 6636, + "%d ": 6637, + "qb": 6638, + "_pos": 6639, + "histo": 6640, + "]) / ": 6641, + "stats->distances[": 6642, + "((char *) ": 6643, + "Arr": 6644, + "A + k": 6645, + "myid": 6646, + "nt1": 6647, + "C2": 6648, + "[ii].speeds[": 6649, + "7_r": 6650, + "_r5_r": 6651, + "7_b": 6652, + "6_b": 6653, + ") lastprivate (": 6654, + "2,i": 6655, + "*a": 6656, + "group": 6657, + "1] - ": 6658, + ":\n ": 6659, + " == 0) || (": 6660, + "region": 6661, + " - 1); i++)\n ": 6662, + "2_X86": 6663, + " = 1. / lhs[n + 2": 6664, + " + ((x": 6665, + ")\n{\n int sum;\n int known_sum": 6666, + ")\n{\n int sum;\n int known_sum;\n double ": 6667, + ")\n{\n int sum;\n int known_sum;\n double dsum": 6668, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double ": 6669, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum": 6670, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double ": 6671, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt": 6672, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double ": 6673, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error": 6674, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.": 6675, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-": 6676, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int ": 6677, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ": 6678, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff": 6679, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int pro": 6680, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product": 6681, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int ": 6682, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product": 6683, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int ": 6684, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and": 6685, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int ": 6686, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or": 6687, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int ": 6688, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and": 6689, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int ": 6690, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or": 6691, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int ": 6692, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or": 6693, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or;\n int ": 6694, + "];\n int i;\n double ": 6695, + "];\n int i;\n double dpt": 6696, + "];\n int i;\n double dpt;\n int result": 6697, + "];\n int i;\n double dpt;\n int result;\n sum = 0;\n ": 6698, + "];\n int i;\n double dpt;\n int result;\n sum = 0;\n dsum = 0;\n ": 6699, + "product = 1;\n ": 6700, + "product = 1;\n logic_and = 1;\n ": 6701, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n ": 6702, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n bit_and = 1;\n ": 6703, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n bit_and = 1;\n bit_or = 0;\n ": 6704, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n bit_and = 1;\n bit_or = 0;\n exclusiv_bit_or = 0;\n ": 6705, + "dt = 1. / ": 6706, + "dt = 1. / 3.": 6707, + "dt = 1. / 3.;\n ": 6708, + ";\n }\n\n if (known_sum": 6709, + ";\n }\n\n if (known_sum != ": 6710, + ";\n }\n\n if (known_sum != sum": 6711, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with ": 6712, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of": 6713, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, ": 6714, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum": 6715, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n ": 6716, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff": 6717, + "; ++i)\n {\n diff = diff - i": 6718, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (": 6719, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff": 6720, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0": 6721, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in ": 6722, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference": 6723, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with ": 6724, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of": 6725, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of ": 6726, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.": 6727, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", ": 6728, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff": 6729, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n ": 6730, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n ": 6731, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 6732, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum": 6733, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n ": 6734, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n ": 6735, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += ": 6736, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(": 6737, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum": 6738, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error": 6739, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with ": 6740, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was": 6741, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f": 6742, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of": 6743, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f": 6744, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (": 6745, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference": 6746, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %": 6747, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E": 6748, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", ": 6749, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum": 6750, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, ": 6751, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum": 6752, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, ": 6753, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum": 6754, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n ": 6755, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 6756, + "fprintf(stderr, \"\\n\");\n ": 6757, + "ddiff = (1 - dpt) / (1 - dt);\n ": 6758, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= ": 6759, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(": 6760, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff": 6761, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error": 6762, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in ": 6763, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference": 6764, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with ": 6765, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was": 6766, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %": 6767, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E": 6768, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of": 6769, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0": 6770, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ": 6771, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff": 6772, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n ": 6773, + ")\n for (i = 1; i <= 10": 6774, + ")\n for (i = 1; i <= 10; i++)\n {\n ": 6775, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= ": 6776, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n ": 6777, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product": 6778, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 36": 6779, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628": 6780, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800": 6781, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (": 6782, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_pro": 6783, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product ": 6784, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != ": 6785, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product": 6786, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in ": 6787, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Pro": 6788, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product ": 6789, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with ": 6790, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of": 6791, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d": 6792, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", ": 6793, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product": 6794, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, ": 6795, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product": 6796, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n ": 6797, + " logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 6798, + " logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n ": 6799, + " logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n ": 6800, + " logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 6801, + " logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par": 6802, + " logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n ": 6803, + " logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par": 6804, + " logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n ": 6805, + " logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 6806, + " logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n ": 6807, + " logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n ": 6808, + " logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 6809, + " logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par": 6810, + " logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n ": 6811, + " logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par": 6812, + " logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n ": 6813, + "t 2\\n\");\n }\n\n return result": 6814, + "t 2\\n\");\n }\n\n return result == 0;\n}\n\n": 6815, + "->next": 6816, + ") reduction(+ : ": 6817, + "3.1415926": 6818, + "[index] = ": 6819, + "omp parallel for schedule(static,1) private(i": 6820, + "fprintf(stderr, \" ": 6821, + "for (i = 0; i < 4096": 6822, + "; i++)\n a[i]": 6823, + "82": 6824, + "_step": 6825, + "B[(i * ": 6826, + "ict_": 6827, + "/src": 6828, + "/src/": 6829, + "num_bucke": 6830, + "Key": 6831, + "#0": 6832, + "[j][i] = ": 6833, + "Hel": 6834, + "_1": 6835, + "obj": 6836, + "}\n\n\n ": 6837, + "grid[(": 6838, + "f / ": 6839, + "omp_get_wtime();\n ": 6840, + "58": 6841, + "_R": 6842, + "for (nn": 6843, + "-1, ": 6844, + " = 0x0": 6845, + "data_size": 6846, + "3_g": 6847, + "omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)": 6848, + ")\n": 6849, + "[k][i]": 6850, + "c[i][j]": 6851, + "m1[k], ": 6852, + "m1[k], m2": 6853, + "m1[k], m2[k], ": 6854, + "m1[k], m2[k], m3": 6855, + "debug_": 6856, + "debug_vec": 6857, + "for (i = 1; i <= 1000; i++)\n{\n sum = sum + i;\n}\n": 6858, + "omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)": 6859, + "place": 6860, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or;\n int logics[1000": 6861, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or;\n int logics[1000];\n int i;\n double dpt;\n int result;\n sum = 0;\n dsum = 0;\n ": 6862, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:": 6863, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum": 6864, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i": 6865, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff": 6866, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n ": 6867, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6868, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff": 6869, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000": 6870, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n ": 6871, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:": 6872, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 6873, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ": 6874, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n ": 6875, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6876, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff": 6877, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n ": 6878, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6879, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product": 6880, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n ": 6881, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n ": 6882, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6883, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&": 6884, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n ": 6885, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6886, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&": 6887, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 6888, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6889, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||": 6890, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n ": 6891, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or": 6892, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6893, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||": 6894, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n ": 6895, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n ": 6896, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6897, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &": 6898, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n ": 6899, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6900, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &": 6901, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 6902, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6903, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |": 6904, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n ": 6905, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or": 6906, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6907, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |": 6908, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n ": 6909, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6910, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^": 6911, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (": 6912, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par": 6913, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n ": 6914, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or": 6915, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6916, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^": 6917, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (!": 6918, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (!exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par": 6919, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (!exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 2\\n\");\n }\n\n return result == 0;\n}\n\n": 6920, + ";\n }\n else\n {\n ": 6921, + ") - 1;\n ": 6922, + "ero": 6923, + "atoi(": 6924, + "535": 6925, + "omp parallel for private(i) if (": 6926, + "omp parallel for private(i) if (control": 6927, + "omp parallel for private(i) if (control==": 6928, + "for (i = 0; i <= 1000": 6929, + ");\n return (known_sum == sum": 6930, + "test_omp_parallel_for_p": 6931, + "test_omp_parallel_for_private": 6932, + "test_omp_parallel_for_private(": 6933, + "omp parallel for reduction(+:sum) schedule(static,1) private(i": 6934, + "omp parallel for reduction(+:sum) schedule(static,1) private(i) private(i": 6935, + "2)\n for (i = 1; i <= 1000; i++)\n {\n ": 6936, + "#pragma omp flush\n ": 6937, + "known_sum == sum;\n}\n\n": 6938, + "for (i = 0; i < 1000; ++i)\n{\n logics[i] = 1;\n}\n": 6939, + ");\n\n\n": 6940, + ");\n}\n\ndouble ": 6941, + "#pragma omp for\n for (i = 1; i <= (grid_points[0] - 2); i++)\n {\n ": 6942, + "changed": 6943, + "float x": 6944, + "max_num_": 6945, + "nuclide_grid": 6946, + "schedule (static, 4) linear(b:": 6947, + "s_larger": 6948, + "omp parallel for schedule(static,1) private(i) ordered": 6949, + "is_larger = check_i_islarger2(ii": 6950, + "is_larger = check_i_islarger2(ii) && is_larger": 6951, + " < (m": 6952, + ")));\n foo(&b, &i, &": 6953, + ")));\n foo(&b, &i, &j, ": 6954, + "omp parallel for schedule(dynamic,1) private(i) reduction(*:product)": 6955, + "for (i = 0; i < 1000; i++)\n{\n logics[i] = 1;\n}\n": 6956, + "omp parallel for reduction(+:sum) schedule(static,7) private(i) lastprivate(i": 6957, + "for (i = 1; i <= (grid_points[0] - 2); i++)\n{\n ": 6958, + "_set_": 6959, + "lename": 6960, + "])) + (6.0 * ": 6961, + ") + (dy": 6962, + "__func": 6963, + "__func__": 6964, + "for (i = 1; i <= 1000; ++i)\n{\n diff = diff - i;\n}\n": 6965, + "omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)": 6966, + "[i3 + 2": 6967, + "[i3 + 2][i2": 6968, + "[0];\n ": 6969, + "sprintf(": 6970, + "qbnew": 6971, + "inf": 6972, + ";\n j_temp = j": 6973, + "[i][ind];\n ": 6974, + "omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)": 6975, + "norm_temp11": 6976, + " * X": 6977, + ") ? (nk": 6978, + ") ? (nk) : (n": 6979, + "omp parallel for reduction(+:sum) private(i) firstprivate(i": 6980, + "_final": 6981, + ")) + iy": 6982, + "eassign[iel][": 6983, + "jel": 6984, + "c_mul(": 6985, + "':\n ": 6986, + "icient": 6987, + " < (5 - 1": 6988, + " < (5 - 1); ": 6989, + "1 * A[(((i": 6990, + "1 * A[(((i - 1) * (": 6991, + "3 * A[(((i": 6992, + "3 * A[(((i + 1) * (": 6993, + "newDistance": 6994, + "CB": 6995, + "fast": 6996, + "; c3 <= ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nk + (-1))) ? ((16 * c2) + 15) : (nk + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 6997, + ";\n }\n\n }\n\n }\n\n }\n\n if (": 6998, + "00;\n x": 6999, + "d_e": 7000, + " = 0.0;\n njac": 7001, + "\\n\");\n #pragma omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 7002, + ") < ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))) ? ((((((n": 7003, + "if (c1 == c2)\n {\n #pragma omp simd\n for (c4 = ": 7004, + " + (-1))); c4++)\n {\n ": 7005, + "idx)\n ": 7006, + "idx)\n pstr->": 7007, + "idx)\n pstr->datlen": 7008, + "SSE": 7009, + ",j,k)": 7010, + ") + (j + 1)]": 7011, + "mg": 7012, + "sorted": 7013, + "2 * i) + 1": 7014, + "for (j = 0; j < 32": 7015, + "for (i = 0; i < 100000; i++)\n ": 7016, + "; i++)\n{\n for (j = 0; j < M": 7017, + "->nx": 7018, + "displ": 7019, + "cla": 7020, + ");\n\n\n\n": 7021, + ",j,": 7022, + "nele": 7023, + "; i--": 7024, + ", (MPI_Datatype) 0x4c00080": 7025, + "for (x = 0; x < OMP_xMax; x": 7026, + "ray->": 7027, + "double)) * ": 7028, + "a1[i] = ": 7029, + "*x": 7030, + "1.0) * ": 7031, + " * i)": 7032, + "].y": 7033, + "et": 7034, + "d2": 7035, + " = (0": 7036, + "Leng": 7037, + "Length": 7038, + "if (input_array[x": 7039, + "varNum": 7040, + "t0": 7041, + "taule": 7042, + "fit": 7043, + "array_": 7044, + "][1][1": 7045, + "cri": 7046, + "yc": 7047, + "cd": 7048, + "plen": 7049, + "2_b": 7050, + "1_b": 7051, + " += 1)\n {\n #pragma omp parallel for private (": 7052, + "2 * (": 7053, + ");\n\n}\n\n": 7054, + "matrix ": 7055, + "uint64_t": 7056, + "repe": 7057, + " != 0)\n {\n ": 7058, + ", n1, n2, n3": 7059, + " += 2;\n}\n": 7060, + ");\n c": 7061, + " - start": 7062, + "fail++;\n }\n\n}\n\n": 7063, + "2, i": 7064, + ";\n for (": 7065, + "z.imag": 7066, + " - (((": 7067, + "][i][j - 1": 7068, + "1.0 + ": 7069, + "for (i = 0; i < NI": 7070, + "omp parallel for num_threads(16": 7071, + "Centroid": 7072, + "(g": 7073, + "A[i][k] * B[k][j]": 7074, + "steps; i++)\n{\n ": 7075, + "s[(i * ": 7076, + "guided)": 7077, + " << 5": 7078, + " * temp": 7079, + "3; j++)\n {\n ": 7080, + "sol": 7081, + "}\n else\n if ((": 7082, + "[k - 1": 7083, + "conv": 7084, + ") * k": 7085, + "dcomplex": 7086, + "word_": 7087, + "))))\n {\n ": 7088, + "7 * ": 7089, + "critic": 7090, + ") + (b": 7091, + "->edges_array_dest": 7092, + "coefficient": 7093, + "_ps(((": 7094, + "4.5": 7095, + "3_r2_r": 7096, + "3_r2_r1_r": 7097, + " += data[(i * (": 7098, + "uint32_t) ": 7099, + "for (i = 0; i < len; i++)\n ": 7100, + "OT": 7101, + "for (i = 0; i < N; i++)\n{\n for (j = 0; j < N": 7102, + " - 1); j++)\n {\n ": 7103, + " = C": 7104, + ", w": 7105, + "0.5 * ": 7106, + "num_cols": 7107, + "3.1415926535": 7108, + " == 1)\n {\n ": 7109, + "training": 7110, + "sample": 7111, + "epsilon)\n {\n ": 7112, + "grid_col": 7113, + "%lf": 7114, + "node **) ": 7115, + "z.real": 7116, + "]) ": 7117, + "macro_x": 7118, + "s)\n{\n ": 7119, + "icro_x": 7120, + "for (i = 0; i < NI; i++)\n{\n for (j = 0; j < N": 7121, + "[i][k] * b": 7122, + ";\n f": 7123, + "for (j = 1; j <= (grid_points[1] - 2); j++)\n {\n ": 7124, + "f[i][j]": 7125, + "[j];\n }\n\n ": 7126, + "->x": 7127, + "cells, ": 7128, + ")\n return ": 7129, + "saved": 7130, + "UT": 7131, + "det": 7132, + "GR": 7133, + "Queue": 7134, + "newValue": 7135, + "(ci": 7136, + "Position": 7137, + ") + 16) - 1) / 16))) : (((": 7138, + "cells_": 7139, + "wg": 7140, + "322": 7141, + "block_width + 2": 7142, + ", block": 7143, + "s->ve": 7144, + "1,i": 7145, + "y_data[i]": 7146, + "(struct ": 7147, + " != 1": 7148, + "][0];\n ": 7149, + "A[(j * ": 7150, + "for (i = 0; i < N; i++)\n p[i] = v1[i] * v2[i];\n": 7151, + "u_data": 7152, + " < k": 7153, + "SQ": 7154, + ")))\n ": 7155, + "))\n ": 7156, + "[0], ": 7157, + "u[m][i][j][k]": 7158, + "Sequen": 7159, + ";\n #pragma omp parallel for\n ": 7160, + "a2[i] = i;\n s = -s;\n}\n": 7161, + "vp": 7162, + "r1": 7163, + "_MAX": 7164, + "filename": 7165, + "(\"/home/reemh/CLPP/github-clone-all/repos_final/": 7166, + "t_id": 7167, + "io": 7168, + "Lc": 7169, + " * restri": 7170, + "for (int y = 0; y < ": 7171, + "y[i": 7172, + "][i][j][k];\n r": 7173, + "nj + (-1)) < (nk": 7174, + "nj + (-1)) < (nk + (-1))) ? (nj + (-1)) :": 7175, + "nj + (-1)) < (nk + (-1))) ? (nj + (-1)) : (nk": 7176, + "] *= boundryScale;\n ": 7177, + "OMP_xMax) + OMP_xMax] *= boundryScale;\n u[": 7178, + "fftz": 7179, + ", fftblock": 7180, + "; k++)\n {\n ": 7181, + "for (i = 0; i < 512; i++)\n{\n for (j = 0; j < 512; j++)\n {\n ": 7182, + "output->content[i][j] = i": 7183, + "output->content[i][j] = image->content[i][j]": 7184, + "_cum": 7185, + ") * nx": 7186, + "GRID": 7187, + "GRID_SIZE": 7188, + "dum": 7189, + "h_graph": 7190, + "_k": 7191, + "jtr_sha512": 7192, + "tMaskX": 7193, + "tMaskY": 7194, + "cessor_id": 7195, + "lg": 7196, + "af": 7197, + "to_visi": 7198, + " = 0.50": 7199, + " = 0.50 * ": 7200, + " = 2.0 * ": 7201, + "cin * ": 7202, + "for (j = 1; j <= ((lastcol - firstcol) + 1); j++)\n {\n ": 7203, + "intemp": 7204, + ";\n }\n\n }\n\n for (c3 = nm": 7205, + "NodeID": 7206, + "viou": 7207, + ") + j].": 7208, + ";\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 7209, + "vertex[i][j]": 7210, + "OMP_xMax] * nu;\n u[": 7211, + "3322": 7212, + ";\n vtype x10": 7213, + " ^ x0": 7214, + "11BB": 7215, + "00F0": 7216, + "4444": 7217, + "27FF": 7218, + "for (c2 = (((": 7219, + "color_type": 7220, + ") : ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))); c2++)\n {\n for (c3 = 16 * c1": 7221, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n #pragma omp simd\n for (c4": 7222, + "-2) * c0": 7223, + "total_vector": 7224, + "grid_current": 7225, + "[k - 1]": 7226, + ") > 0.05)\n {\n fail++;\n }\n\n }\n\n}\n\n": 7227, + " = 0;\n }\n\n}\n\n": 7228, + "rece": 7229, + "[lev": 7230, + "[i][0] = ": 7231, + "Failed": 7232, + " * tmp": 7233, + "; k++)\n ": 7234, + ", max": 7235, + "a[j] = ": 7236, + "[0][0]": 7237, + " the ": 7238, + "matrix->tab": 7239, + "double) i": 7240, + " = 0; iter": 7241, + "9) | (": 7242, + "static void p": 7243, + "K, int ": 7244, + " = 0;\n ": 7245, + "[j];\n ": 7246, + "vx": 7247, + ")) || ((": 7248, + "[i][k] + ": 7249, + "sums[i].": 7250, + "scanf(\"%d\", &": 7251, + " == 0x": 7252, + " - hz": 7253, + ".c\"": 7254, + "0);\n ": 7255, + "\");\n ": 7256, + "rez": 7257, + ")\n {\n ": 7258, + "y * k": 7259, + "nzv": 7260, + "))) - ((": 7261, + "coordinate": 7262, + "assword": 7263, + "rand48(": 7264, + ") + j] = (((DATA_TYPE) i) * j) / ": 7265, + "triple": 7266, + "][c]": 7267, + "_epi": 7268, + "merge": 7269, + "[jj": 7270, + ") & 0xffff": 7271, + "_u": 7272, + "23 * h": 7273, + "1->": 7274, + ";\n col": 7275, + "u[i][j][k - 1": 7276, + "2; j++)\n {\n ": 7277, + "xi * ": 7278, + "for (i3 = 1; i": 7279, + "for (i3 = 1; i3": 7280, + "++)\n{\n for (y = 0; y < ": 7281, + ") ^ ": 7282, + " + 1)) + j]": 7283, + " < (*": 7284, + "#pragma omp task": 7285, + "8)\n {\n ": 7286, + "lear": 7287, + "12435": 7288, + "12435 * ": 7289, + "#pragma omp ordered\n {\n ": 7290, + "(char *": 7291, + "++i": 7292, + "l2": 7293, + ",m)": 7294, + "4)\n ": 7295, + "[i] = 1": 7296, + "dataSize": 7297, + "[1], ": 7298, + "*((node **) ": 7299, + "*((node **) elem_at(&": 7300, + "RA": 7301, + "mas": 7302, + "6]": 7303, + "for (i = 0; i < M": 7304, + "OMP_zMax; z": 7305, + "s()": 7306, + "}\n ;\n ": 7307, + "a)": 7308, + "ct ": 7309, + ";\n }\n\n }\n\n ": 7310, + "; kk": 7311, + "[i + (n": 7312, + "[i + (nx": 7313, + " * (j + (n": 7314, + "y * k)))": 7315, + "s_index": 7316, + "dt) * ": 7317, + "[j] > ": 7318, + "cuf": 7319, + "[(k * 512": 7320, + "alive_": 7321, + "yycon": 7322, + "trace": 7323, + "mult": 7324, + "2);\n}\n": 7325, + "hold": 7326, + "critical": 7327, + "maskDimension": 7328, + "cov": 7329, + "KS": 7330, + "tmort": 7331, + "_fast": 7332, + ", unsigned int *": 7333, + ")) * tmp": 7334, + "nt1 == '": 7335, + "') && (n": 7336, + "') && (nt2": 7337, + "') && (nt2 == '": 7338, + "_cpu[n": 7339, + "_cpu[nh": 7340, + "fTmp": 7341, + "pstr->cptr[idx": 7342, + "cells->speed_": 7343, + "int) (": 7344, + "rate": 7345, + "#pragma omp parallel ": 7346, + ";\n\n\n ": 7347, + ", int b": 7348, + "s[v].": 7349, + "A[i] = ": 7350, + "[i3 + 1][i2][i1]": 7351, + "A->": 7352, + "error = error": 7353, + "}\n else\n if (i": 7354, + "X = ": 7355, + "j)) + ((": 7356, + " = 0;\n double ": 7357, + ",c": 7358, + "for (int i = 0; i < 10000": 7359, + "rand() % 100": 7360, + "omp_set_": 7361, + "for (int i = 0; i < size": 7362, + "ix * ": 7363, + " = (int) ((": 7364, + "Rows": 7365, + "Mul": 7366, + ");\n}\n\n\nvoid ": 7367, + " = 0.25 * (((": 7368, + ";\n }\n\n ": 7369, + "result ": 7370, + "] == filter_list[y": 7371, + " % 1": 7372, + " != 3": 7373, + "are_": 7374, + "5] = ": 7375, + "uy": 7376, + ";\n }\n\n }\n\n }\n\n ": 7377, + "_sub_ps(": 7378, + "SV": 7379, + " = m_": 7380, + " == 1)\n {\n numAliveNeighbors++": 7381, + "Cnt": 7382, + "3214": 7383, + "3214212": 7384, + "3214212.0": 7385, + "[i][j]);\n }\n\n printf(\"\\n\");\n}\n": 7386, + "w_": 7387, + "TYPE": 7388, + "v) shared(": 7389, + "dtemp[m]": 7390, + "[i] = (atoi16[ARCH_INDEX(*": 7391, + "p)]": 7392, + "[1])]": 7393, + "neighbors[j].": 7394, + "for (i = i": 7395, + "#pragma omp ordered de": 7396, + "#pragma omp ordered depend(": 7397, + "1, i": 7398, + "num_vector": 7399, + "(i, ": 7400, + "_pr": 7401, + "grid->comm": 7402, + "for (c1 = 0; c1": 7403, + ")) ? ((": 7404, + " + m": 7405, + "cur = ": 7406, + "x = (i + ": 7407, + ".tv_usec": 7408, + "for (int ii = 0; ii": 7409, + "));\n ": 7410, + " = (row": 7411, + "for (k = k": 7412, + "fprintf(stdout, \"[": 7413, + "] %s": 7414, + "] %s:%d": 7415, + "] %s:%d:%": 7416, + "] %s:%d:%s()": 7417, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/": 7418, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/a": 7419, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amann": 7420, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannou": 7421, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougra": 7422, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahi": 7423, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiy": 7424, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya": 7425, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/im": 7426, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop": 7427, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-": 7428, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-comp": 7429, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compile": 7430, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler": 7431, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/": 7432, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests": 7433, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/im": 7434, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsu": 7435, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsuite": 7436, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsuite/src/": 7437, + "i)\n{\n int ": 7438, + "d3": 7439, + "for (ii = 0; i": 7440, + "for (j = 1; j <= (grid_points[1] - 2); j++)\n {\n for (k = 1; k <= (grid_points[2] - 2); k++)\n {\n ": 7441, + " - x21": 7442, + " * 1024": 7443, + "Partition": 7444, + "private.d_in2_pad": 7445, + "pos_ori": 7446, + "private.d_in2_sub": 7447, + "_prob": 7448, + "_flu": 7449, + "norm_temp12": 7450, + "Index].": 7451, + "to_visit": 7452, + "CitiesX[city": 7453, + "CitiesY[city": 7454, + ")) + (k - 1)": 7455, + "c1 <= ((((((n": 7456, + ";\n }\n\n #pragma omp simd\n for (c4 = nk": 7457, + ";\n }\n\n }\n\n for (c3 = ni": 7458, + "; c3 <= ((((16 * c1) + 15) < (nm + (-1))) ? ((16 * c1) + 15) : (nm + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n }\n\n }\n\n }\n\n if ((c1 <=": 7459, + ";\n }\n\n }\n\n }\n\n }\n\n if (c1 <=": 7460, + "2D_": 7461, + ";\n }\n\n }\n\n for (c3 = nj": 7462, + "curr_path": 7463, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nk + (-1))) ? ((((": 7464, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nk + (-1))) ? ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj": 7465, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nk + (-1))) ? ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) : (nk": 7466, + ";\n }\n\n }\n\n for (c3 = nk": 7467, + "n + (2 * tsteps)) + (-3))": 7468, + "c1)) + ": 7469, + "r_vec": 7470, + ";\n }\n\n }\n\n for (c3": 7471, + ")) && (c1 >= (((": 7472, + "); c2 <= ((((((n": 7473, + "7_g": 7474, + "initial": 7475, + "vector_sum": 7476, + "for (i = 0; i < MatrixDim": 7477, + "[i] = (atoi16[ARCH_INDEX(*p)]": 7478, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p": 7479, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p[1])]": 7480, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p[1])];\n p": 7481, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p[1])];\n p += 2;\n}\n": 7482, + "[0][j]": 7483, + " = s": 7484, + ", out": 7485, + "3.14159265358": 7486, + ")\n printf(\"": 7487, + "oria.": 7488, + "m; j++)\n ": 7489, + "c1c5": 7490, + " = 0; (": 7491, + "for (k = 0; k < 1024": 7492, + ") + 1) / ": 7493, + " - 1] = ": 7494, + "_pre": 7495, + "u[ind": 7496, + "for (z = 0; z < OMP_zMax; z": 7497, + " = (int) (": 7498, + "Ini": 7499, + "count++": 7500, + " + (r": 7501, + "lhs[4": 7502, + "; p < (": 7503, + " == 3)\n {\n ": 7504, + "u[m][i][j][k": 7505, + "[j]]": 7506, + "->num_": 7507, + ";\n if (!": 7508, + "fore": 7509, + " * restrict ": 7510, + "root": 7511, + "RI": 7512, + "s[i].y": 7513, + "lk": 7514, + " - 1][": 7515, + "_plug": 7516, + "; col++)\n {\n ": 7517, + "][i][j][k])) + ": 7518, + "':\n ": 7519, + "++;\n\n ": 7520, + "For": 7521, + "j)": 7522, + "_msg": 7523, + "Array[": 7524, + "'))": 7525, + "11 = x": 7526, + " * 1000": 7527, + " = 255": 7528, + "[iel][1": 7529, + "][i][j][k];\n lhs[": 7530, + " + 10][i][j][k] = lhs[": 7531, + "THREADS": 7532, + "_squared": 7533, + "n - 1]": 7534, + "DL": 7535, + " = rho": 7536, + "forcing[m][i][j][k] = ": 7537, + "forcing[m][i][j][k] = forcing[m": 7538, + " + (2 * 1": 7539, + "_cpu[nh].": 7540, + "fjac[i][j][k": 7541, + "dim) + j": 7542, + "dz1": 7543, + "[((i + 1) * ": 7544, + "A[i] = (": 7545, + "[tid": 7546, + "measure": 7547, + "t = (": 7548, + "Len": 7549, + "omp parallel for reduction(+ : ": 7550, + "];\n }\n\n }\n\n}\n": 7551, + " -= 2": 7552, + "; j++)\n {\n tmp": 7553, + "truth": 7554, + "%ld": 7555, + "x = 1": 7556, + "w2": 7557, + "0x7fffffff": 7558, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + x;\n}\n\n": 7559, + "for (j = col": 7560, + "[i] != ": 7561, + "; j < n": 7562, + "exp(-": 7563, + "for (m = 0; m <= 4; m += 1)\n{\n ": 7564, + " / (sizeof(": 7565, + "_load": 7566, + "(K": 7567, + " + i)) + j": 7568, + "result)": 7569, + "999": 7570, + "world->bodie": 7571, + "; ++j)\n {\n ": 7572, + ");\n }\n\n ": 7573, + "len = ": 7574, + "for (j = 0; j < 10000000; j++)\n ": 7575, + "Point ": 7576, + "utation": 7577, + "tem": 7578, + " == 1)\n {\n ": 7579, + "f = ": 7580, + "52": 7581, + " = _mm_loadu_ps((": 7582, + "udo": 7583, + "for (int i = 0; i < 4": 7584, + "EC": 7585, + "3;\n x": 7586, + "hid": 7587, + "_update": 7588, + "0.7": 7589, + "tial_": 7590, + "s[threadNum": 7591, + "A_addres": 7592, + "[index + ": 7593, + "ty1": 7594, + "[bid": 7595, + "doubleWord": 7596, + "j = i": 7597, + "for (i = 1; i < (2048 + 1)": 7598, + "for (j = 0; j <= (": 7599, + "u[i][j][k + 1": 7600, + "2 * ((((": 7601, + "(x) ": 7602, + ", const int ": 7603, + "vl[id].": 7604, + "j;\n ": 7605, + " + (2 * i": 7606, + ")) / (": 7607, + "OCK": 7608, + "d.": 7609, + "; i++)\n{\n if (percentDiff(": 7610, + "for (x = 0; x < N": 7611, + "\\n\", i, a[i]": 7612, + "c;\n ": 7613, + "total += ": 7614, + " + 3]": 7615, + "for (i = 0; i < num": 7616, + "); x": 7617, + "] -= ": 7618, + "A[k][j]": 7619, + "search": 7620, + "; i++)\n{\n double ": 7621, + "0;\n ": 7622, + ", long ": 7623, + "ins": 7624, + "union ": 7625, + "} ": 7626, + "ray.": 7627, + "_key": 7628, + "for (j = i + 1": 7629, + "temp_mat": 7630, + "_omp": 7631, + ");\n }\n while (": 7632, + "t *": 7633, + "Multi": 7634, + "000000000": 7635, + "_S": 7636, + "house": 7637, + "[(16 * ": 7638, + "Or": 7639, + "public.in_mod_rows": 7640, + "u[0": 7641, + "Nodes": 7642, + "long *": 7643, + ", struct ": 7644, + "_force": 7645, + "break;\n\n case '": 7646, + "person": 7647, + "_e": 7648, + "IMG": 7649, + "_info": 7650, + "lave": 7651, + "s[i": 7652, + "51]": 7653, + "zzcon": 7654, + ") - (c2 * ": 7655, + ")));\n }\n\n }\n\n}\n": 7656, + "uint32_t *) ": 7657, + ")\n{\n int i;\n ": 7658, + "_input": 7659, + "process": 7660, + "processes[i].": 7661, + ");\n }\n\n return ": 7662, + " + (-1))); c2++)\n {\n A[c1][c2] = (((double) c1) * c2) / ni;\n ": 7663, + "[k], m1[k], m2[k], m3": 7664, + "MPI_Send(&": 7665, + "for (i = 0; i < 16; i++)\n{\n ": 7666, + "c = c + (b != (7 + (2 * i": 7667, + ")));\n b = b + 2": 7668, + "foo(3": 7669, + "omp parallel for shared (a, b": 7670, + "idx = ": 7671, + "2) reduction(+:c)": 7672, + "(input->x": 7673, + ", sup->": 7674, + ", sup->V": 7675, + "A[(i * 8192) + j]": 7676, + "a[i] - ": 7677, + "int)) * ": 7678, + "for (x = 0; x < Nparticles": 7679, + "x = 1; x": 7680, + "stride_y": 7681, + "++)\n {\n for (": 7682, + "OMP_SQ": 7683, + "OMP_SQR": 7684, + "float percentDiff(double val1, double val2)\n{\n double ": 7685, + "float percentDiff(double val1, double val2)\n{\n double val3": 7686, + "float percentDiff(double val1, double val2)\n{\n double val3 = (": 7687, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1": 7688, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= ": 7689, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2": 7690, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (": 7691, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2": 7692, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (": 7693, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2": 7694, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - ": 7695, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1": 7696, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (": 7697, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3": 7698, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3 < ": 7699, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3 < 0.5)\n {\n ": 7700, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3 < 0.5)\n {\n return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f));\n }\n\n}\n\n": 7701, + "; i += 4)\n{\n c = c + (b != (7": 7702, + "; i += 4)\n{\n c = c + (b != (7 + ((i": 7703, + "; i += 4)\n{\n c = c + (b != (7 + ((i / 4) * ": 7704, + "; i += 4)\n{\n c = c + (b != (7 + ((i / 4) * 3": 7705, + "value[col + 4": 7706, + "for (j = i": 7707, + "8; j++)\n{\n c = c + (b": 7708, + "8; j++)\n{\n c = c + (b != ((": 7709, + "8; j++)\n{\n c = c + (b != ((7": 7710, + "8; j++)\n{\n c = c + (b != ((7 + (2 * ": 7711, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((": 7712, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((2 * ": 7713, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((2 * 8) * ": 7714, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((2 * 8) * i": 7715, + ".at": 7716, + "for (int i = 0; i < 1000": 7717, + "5 + (c1c5": 7718, + "5 + (c1c5 * ru1": 7719, + ") < ((": 7720, + "float) (": 7721, + " %d, ": 7722, + "RAY": 7723, + "for (int x = 0; x < ": 7724, + "cur->data": 7725, + "matrix_": 7726, + " = (ni": 7727, + ", unsigned char *out": 7728, + "CDF": 7729, + "[k + 1": 7730, + "; p < (&buf[": 7731, + " / ((double) ": 7732, + "; i++)\n for (k = k": 7733, + "if (!memcmp(": 7734, + "15E": 7735, + "[(j * n) + i]": 7736, + "r = r": 7737, + "p = q;\n ": 7738, + "t1 = ": 7739, + " - 1)) ? (": 7740, + ";\n int i;\n ": 7741, + "for (m = 0; m < 5; m++)\n {\n ": 7742, + "5.2f": 7743, + "], (": 7744, + ") * s) * s": 7745, + "(xyzInd + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 7746, + "xxcon": 7747, + "_COL": 7748, + "[private.point_no": 7749, + " + 1][k]": 7750, + ";\n\n if (": 7751, + "[col] * ": 7752, + "douth": 7753, + "1, b": 7754, + "sizey": 7755, + "w = ": 7756, + "ni + (-1)) < (nj": 7757, + "ni + (-1)) < (nj + (-1))) ? (ni + (-1)) :": 7758, + "ni + (-1)) < (nj + (-1))) ? (ni + (-1)) : (nj": 7759, + "u.": 7760, + "diagn[iel][": 7761, + "2 * speed": 7762, + "_coefficient": 7763, + "[(i * 1000) + j]": 7764, + "file_name": 7765, + "jsr": 7766, + "for (nn = 1; ": 7767, + "for (nn = 1; nn": 7768, + "for (nn = 1; nn < (5 - 1); ": 7769, + "for (nn = 1; nn < (5 - 1); nn": 7770, + "mor_v[n": 7771, + "mor_v[nn - 1]": 7772, + "centroids, ": 7773, + ") < 0) ? (-((-": 7774, + " < 0) ? ((((-": 7775, + ")) - 1) / (-": 7776, + ") < 0) ? ((": 7777, + "node->children": 7778, + "il = idel[ie][iface": 7779, + ")) / 2": 7780, + "[(i * 128": 7781, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((": 7782, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl": 7783, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) : (n": 7784, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) : (nm + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 7785, + " + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni;\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 7786, + "*((MD5_std_combined *) (((char *) MD5_std_all_p) + t)))._pool->": 7787, + "id].": 7788, + "!rt": 7789, + "!rtIs": 7790, + ") - OMP_xMax] * nu;\n u[": 7791, + " = m_get(": 7792, + ");\n m_free(": 7793, + " - p2": 7794, + "n + (2 * tsteps)) + (-3": 7795, + " (-((((-((n + (2 * tsteps)) + (-3))": 7796, + "16 * c2) + ((-1) * n)) + ": 7797, + "-2) * c3) + c4": 7798, + "x[temp": 7799, + "x[temp] = ntemp": 7800, + "3333FFFF": 7801, + "6A": 7802, + ";\n vtype x20": 7803, + " ^ x00": 7804, + ";\n x10": 7805, + "1144": 7806, + "6A9": 7807, + "4F": 7808, + "4F4": 7809, + "EF4": 7810, + " = x3C": 7811, + "22DD": 7812, + " < iel": 7813, + "tmort[ig": 7814, + "vmag": 7815, + "[zoneset[i]": 7816, + "16 * c1) + 15) < (nk + (-1))) ? ((16 * c1) + 15) : (nk": 7817, + ", 0, 0, 0, 0": 7818, + " >> 25": 7819, + "d_12 * h": 7820, + "d_13 * h": 7821, + ")))) + (h": 7822, + ")) + (d_": 7823, + "3_g2_g": 7824, + "3_g2_g1_g": 7825, + "7_b6_b": 7826, + ")) + (bv": 7827, + ") default(shared": 7828, + " + n": 7829, + "rhs[i][j][k": 7830, + "1D": 7831, + "for (int j = 0; j < n; j++)\n {\n ": 7832, + "energy_": 7833, + "; y++)\n{\n ": 7834, + "sum;\n}\n": 7835, + "(new": 7836, + "a[i]);\n}\n": 7837, + "printf(\"Failed": 7838, + "sum = 0;\n ": 7839, + ");\n free": 7840, + "answ": 7841, + "answer": 7842, + "a[i][j] = ": 7843, + "strcp": 7844, + " thread": 7845, + "max(": 7846, + "memcpy(&": 7847, + " * (sizeof(float": 7848, + "for (i = 1; i < n": 7849, + "cv": 7850, + "_value": 7851, + "iso": 7852, + "S, int ": 7853, + "oc": 7854, + " = (int) ": 7855, + "binary, ": 7856, + " %d\\n\", i": 7857, + "rowptr[i + 1]": 7858, + "1);\n ": 7859, + "rhs[0": 7860, + "Tim": 7861, + "[16": 7862, + "for (k = 0; k < 512": 7863, + ") + 3)": 7864, + "cmom": 7865, + " * j)]": 7866, + "0, b": 7867, + "[(k": 7868, + "cells[(ii * params.nx) + jj].speeds[": 7869, + "lik": 7870, + "isi": 7871, + ";\n\n if (a": 7872, + "3(": 7873, + "this_": 7874, + "wgll": 7875, + "passed_verification++;\n\n ": 7876, + ") + (-2": 7877, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[1": 7878, + "ThreadLimit": 7879, + ";\n }\n\n}\n\nint ": 7880, + "]]": 7881, + "graph->vertices[v].": 7882, + " (nk + (-1)); c2++)\n {\n ": 7883, + "i = 0; i < n": 7884, + "48]": 7885, + ") < p": 7886, + "lat": 7887, + "for (j = 0; j < 8192": 7888, + "printf(\"\\t": 7889, + ", x, y": 7890, + "vy": 7891, + "e)": 7892, + "a[i];\n printf(\"": 7893, + "][i][j1][k] = ": 7894, + "x[i] = ": 7895, + "[(0 * ": 7896, + "for (i = 0; i < 10; i++)\n ": 7897, + ";\n\n }\n\n}\n\n": 7898, + "u_data = u": 7899, + "u_data = u->data": 7900, + "Elem": 7901, + "ossible": 7902, + ";\n c": 7903, + "omp parallel for default(none) private(": 7904, + "z.i": 7905, + "malloc(sizeof(": 7906, + ", hash": 7907, + "[i][k] * b[k][j]": 7908, + "two": 7909, + "ate_": 7910, + ");\n }\n else\n {\n ": 7911, + ":\n ": 7912, + ") / 1024": 7913, + "collapse (": 7914, + " - (0.5 * (": 7915, + "basename(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsuite/src/": 7916, + "s[m]": 7917, + "timer_": 7918, + "[%d] = ": 7919, + "many": 7920, + "for (j1": 7921, + "))\n {\n printf(\"": 7922, + "[j][k]": 7923, + "][i1]) + r": 7924, + "][i1 + 1]) + r": 7925, + "imz": 7926, + "tid = omp_get_thread_num(": 7927, + "; i++)\n {\n ": 7928, + "found": 7929, + ");\n b": 7930, + "rhs[2": 7931, + "rhs[4": 7932, + "s[t": 7933, + "mask_con": 7934, + "5d": 7935, + "cj": 7936, + "0)\n ": 7937, + "_pixel": 7938, + ")) / 1": 7939, + "unsigned int) ": 7940, + "z2": 7941, + ";\n }\n else": 7942, + "][i1][j][k] = ": 7943, + ".C": 7944, + "ue[m][k": 7945, + "jm1": 7946, + "][km1]": 7947, + "64 + (2 * 1": 7948, + "][jm1]": 7949, + "\n passed_verification": 7950, + "\n passed_verification++;\n\n ": 7951, + "_r5_r4_r": 7952, + "_r5_r4_r3_r2_r1_r": 7953, + "5_g": 7954, + "_g3_g2_g1_g": 7955, + "3_b2_b": 7956, + "3_b2_b1_b": 7957, + "for (int i = 0; i < n; i++)\n ": 7958, + "Points; i++)\n{\n ": 7959, + "if ((!": 7960, + "[i] / ": 7961, + " = n": 7962, + ") schedule(dynamic,": 7963, + "Mat": 7964, + "stats->pageRanks[v] / ": 7965, + "double) (((": 7966, + "[i1] + ": 7967, + "k)\n {\n ": 7968, + "if (i < ": 7969, + "))) / ": 7970, + "}\n\n\n\n\n}\n": 7971, + "over": 7972, + "4)\n {\n ": 7973, + ".jp": 7974, + "omp distribute parallel for simd linear": 7975, + ");\n float ": 7976, + "->width": 7977, + " = (((((": 7978, + "GB": 7979, + "3.14159265358979": 7980, + "3.1415926535897932": 7981, + "for (j = 1; j < ": 7982, + "mm": 7983, + "in.": 7984, + "union \n {\n ": 7985, + "y;\n ": 7986, + "; i--)\n{\n ": 7987, + "if ((*": 7988, + "ition": 7989, + "for (j = 0; j <= n": 7990, + "ig = ": 7991, + ";\n }\n\n }\n\n }\n\n }\n\n}\n": 7992, + ")\n{\n int i;\n int j;\n int k": 7993, + " private(j": 7994, + "printf(\"%f": 7995, + " += 16": 7996, + "World": 7997, + "ilt": 7998, + "784": 7999, + "parallel_for": 8000, + "none": 8001 + }, + "special_tokens": [ + "", + "", + "", + "" + ], + "vocab_size": 8002, + "target_vocab_size": 8000, + "bpe_ranks": { + " _ ": 0, + "\n_ ": 1, + " _(": 2, + ")_ ": 3, + "=_ ": 4, + "\n _ ": 5, + " _= ": 6, + ";_ ": 7, + "o_r": 8, + " _1": 9, + "f_or": 10, + "(_(": 11, + " _+": 12, + " _*": 13, + "i_n": 14, + " _<": 15, + "]_[": 16, + ";_\n ": 17, + "\n _ ": 18, + "+_+": 19, + "}_\n": 20, + "for_ (": 21, + ",_ ": 22, + ") _+": 23, + ")_)": 24, + "l_e": 25, + "; _i": 26, + " = _0": 27, + "[_i": 28, + "a_r": 29, + "m_p": 30, + " *_ ": 31, + "++_)": 32, + "in_t": 33, + "a_l": 34, + "t_e": 35, + " <_ ": 36, + " (_-": 37, + "0_0": 38, + ";_\n": 39, + "r_e": 40, + " 1_6": 41, + "s_t": 42, + " _p": 43, + " (_(": 44, + "o_mp": 45, + "int_ ": 46, + " = 0_; i": 47, + "\n _ ": 48, + " _-": 49, + "{_\n ": 50, + "for (_i": 51, + "\n_{\n ": 52, + ")_) ": 53, + "[i_]": 54, + " (-_1": 55, + ";_\n ": 56, + ") +_ ": 57, + "r_i": 58, + "c_o": 59, + " _=": 60, + "a_t": 61, + "l_o": 62, + "s_i": 63, + " +_ (-1": 64, + " (_((": 65, + "u_m": 66, + " p_ar": 67, + "i_f": 68, + "o_u": 69, + "al_le": 70, + "alle_l": 71, + " _for": 72, + "for (i_ = 0; i": 73, + "; _j": 74, + " par_allel": 75, + "; i_++)": 76, + "{_\n ": 77, + " parallel_ for": 78, + "\n _{\n ": 79, + "e_d": 80, + " +_ ": 81, + "d_e": 82, + "j_]": 83, + "}\n_\n": 84, + "i_c": 85, + "r_a": 86, + "omp_ parallel for": 87, + "m_a": 88, + ") _?": 89, + ")_;\n ": 90, + "-_>": 91, + ";_\n ": 92, + " + (-1_))": 93, + "1_6": 94, + "s_e": 95, + "b_le": 96, + ") _/": 97, + ") _*": 98, + " (_n": 99, + "a_te": 100, + "co_l": 101, + "}\n_\n ": 102, + "d_ou": 103, + "c_h": 104, + "dou_ble": 105, + "if_ (": 106, + "r_o": 107, + "t_i": 108, + ") +_ 1": 109, + "]_ = ": 110, + " +_ 1": 111, + "][_i": 112, + " -_ 1": 113, + "g_e": 114, + "t__": 115, + "e_l": 116, + "o_n": 117, + "(_i": 118, + "(_n": 119, + "s_[": 120, + "ri_v": 121, + "riv_ate": 122, + "; i++)_\n{\n ": 123, + "; _++": 124, + "s_um": 125, + "[i_][": 126, + "__p": 127, + ") _-": 128, + "i_)": 129, + "._0": 130, + "omp parallel for_ ": 131, + "n_d": 132, + "a_d": 133, + ";\n_}\n": 134, + "e_r": 135, + "c_2": 136, + "for (i = 0; i_ < ": 137, + "for (i = 0; i_ <": 138, + "z_e": 139, + ") _<": 140, + " -_ ": 141, + ") _:": 142, + ";_\n ": 143, + " +_= ": 144, + " = _1": 145, + "for (_int ": 146, + "f_(": 147, + "0_) ?": 148, + "c_4": 149, + "; ++_i)": 150, + "i_d": 151, + "d_i": 152, + "t_h": 153, + "u_c": 154, + "u_r": 155, + ") /_ 16": 156, + "((_((": 157, + ") *_ ": 158, + "n_t": 159, + "; j_++)": 160, + "16_ * ": 161, + "][_k": 162, + " =_ (": 163, + "c_1": 164, + "for (_j": 165, + "te_mp": 166, + "{_\n ": 167, + " = 0_; ": 168, + "\n _{\n ": 169, + "00_0": 170, + "si_ze": 171, + "m_e": 172, + "p_rivate": 173, + "c_3": 174, + " = 0_; j": 175, + "ti_on": 176, + "p_e": 177, + "][_j": 178, + "n_um": 179, + "c_e": 180, + "{_\n ": 181, + "t_y": 182, + "ro_w": 183, + ")) _:": 184, + "re_d": 185, + "__b": 186, + "u_l": 187, + ") +_ (": 188, + " +_ (": 189, + "g_ma": 190, + ")) _/": 191, + "ra_gma": 192, + "#_p": 193, + "#p_ragma": 194, + "#pragma_ ": 195, + "((((_-": 196, + ") -_ 1": 197, + " (-_((((-": 198, + "l_a": 199, + ")_\n{\n ": 200, + " _>": 201, + "lo_g": 202, + ") +_ 16": 203, + "double_ ": 204, + "M_P": 205, + ") + 1_5": 206, + ")_;\n ": 207, + "p_r": 208, + ")_\n {\n ": 209, + "n_e": 210, + " <_=": 211, + " =_= ": 212, + "log_ic": 213, + "u_n": 214, + "pr_int": 215, + " (-((((-_(n": 216, + "a_m": 217, + " + (-1))_) + 16": 218, + "print_f(": 219, + "1_]": 220, + "__x": 221, + "omp_ ": 222, + "}\n\n_}\n": 223, + "t_mp": 224, + "__m": 225, + "u_le": 226, + "s_h": 227, + "ch_ed": 228, + "lo_c": 229, + "s_ched": 230, + "sched_ule": 231, + "m_d": 232, + "b_u": 233, + "tion_(": 234, + "red_uc": 235, + "0_]": 236, + "si_md": 237, + "for (j_ = 0; j": 238, + "s_(": 239, + "de_x": 240, + "reduc_tion(": 241, + "for (int _i": 242, + ")) _*": 243, + "v_al": 244, + "\\_n": 245, + " *_ (": 246, + "t_ ": 247, + "M_a": 248, + "[i][_j]": 249, + ")_; ": 250, + "[_j]": 251, + "ty_pe": 252, + "s_[i]": 253, + "O_MP": 254, + "v_e": 255, + ") <_ ": 256, + " _x": 257, + ";\n_}\n\n": 258, + " (((_(": 259, + "; i++)_\n ": 260, + "re_ad": 261, + ";\n _int ": 262, + "s__": 263, + "t_a": 264, + "schedule_(": 265, + "re_t": 266, + "v_type": 267, + "Ma_x": 268, + "\\n_\"": 269, + "a_n": 270, + "ur_n": 271, + "ret_urn": 272, + "16 * _c2": 273, + ") _private": 274, + "n_o": 275, + "i_t_": 276, + "; ++i)_\n ": 277, + ")_\n ": 278, + "in_dex": 279, + " _/": 280, + "i_g": 281, + "2_]": 282, + "for (i = 0; i <_ 16": 283, + "u_e": 284, + "[_(i": 285, + ") < _0) ?": 286, + " < _0) ?": 287, + "di_st": 288, + "2_0": 289, + ") :_ (n": 290, + "el_se": 291, + ") / 16_))": 292, + "m_at": 293, + "*_((": 294, + "[_(": 295, + " ((_16": 296, + "le_n": 297, + " 16_) < 0) ?": 298, + " ((16_ < 0) ?": 299, + ") / 16_)) :": 300, + ") - 1_) / 16))": 301, + "&_&": 302, + "OMP__x": 303, + "OMP_x_Max": 304, + "te_r": 305, + "for (i = 0; i <_ 1": 306, + " + (-1))_) ?": 307, + "][j_][k": 308, + "for (j = 0; j_ < ": 309, + "for (int i_ = 0; i": 310, + "th_read": 311, + "f_lo": 312, + "for (i = 0; i < 16_; ++i)\n ": 313, + "f_a": 314, + "ul_t": 315, + "f_i": 316, + ";\n_\n": 317, + "for (i = 0; i < 16; ++i)\n _;\n": 318, + ", _int ": 319, + ") + _j]": 320, + "}\n_\n ": 321, + "ch_ar": 322, + ";\n _}\n\n ": 323, + "si_g": 324, + "f_f": 325, + " _%": 326, + "flo_at": 327, + "[_k": 328, + "2_ * ": 329, + "h_s[": 330, + " =_ (((": 331, + "n_j": 332, + ") <_ (n": 333, + "num__": 334, + "; j++)_\n {\n ": 335, + "k_e": 336, + "sig_n": 337, + "d_y": 338, + "at_a": 339, + ") private_(i": 340, + " <_= ": 341, + "double_) ": 342, + "n_k": 343, + "c_ur": 344, + "ou_t": 345, + "[i]_ = ": 346, + "st_at": 347, + "\n _{\n ": 348, + "16 * c2_) + 15": 349, + "3_2": 350, + "printf(_\"": 351, + "p_u": 352, + "d_ata": 353, + "++)_\n{\n ": 354, + "]_)": 355, + ") *_ (": 356, + " = 0_;\n ": 357, + "ri_x": 358, + "_m_m": 359, + "c_t": 360, + "re_s": 361, + "ig_h": 362, + "ri_d": 363, + "p_o": 364, + " p_rivate": 365, + "{\n _ ": 366, + ") _reduction(": 367, + "omp parallel for _schedule(": 368, + "t_o": 369, + "u_[": 370, + ";\n _ ": 371, + "a_nd": 372, + " *_) ": 373, + "e_x": 374, + ") - 1) / 16))_) :": 375, + "2_)": 376, + "]_ * ": 377, + "ic_,": 378, + "2_5": 379, + "))_)": 380, + ", _i": 381, + "ra_y": 382, + " _&": 383, + "16 * _c1": 384, + "ma_x": 385, + " *_)": 386, + "in_d": 387, + "][i_][j][k": 388, + "for (int i = 0; i_ < ": 389, + "r_r": 390, + "n_am": 391, + "[i][_j": 392, + "ed_ ": 393, + "dy_nam": 394, + " 16) < 0) ?_ ((16 < 0) ?": 395, + ") + 1_) / 16)) :": 396, + "; _k": 397, + ", _\"": 398, + " = 1_; i": 399, + "l_u": 400, + ")) /_ 16": 401, + ")) *_ 16) < 0) ? ((16 < 0) ?": 402, + "OMP_xMax_) + ": 403, + "t_(": 404, + "un_sign": 405, + "[(i_ * ": 406, + "g_rid": 407, + ") /_ ": 408, + " /_ ": 409, + ") - 1) / 16))) :_ ((": 410, + ")) * 16) < 0) ? ((16 < 0) ?_ (-((((-(n": 411, + ") + 1) / 16)) :_ (-((((-(n": 412, + " + (-1_)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 413, + " + (-1))) + 16_) + 1) / 16)) : (-((((-(n": 414, + " + (-1))) + 16_) - 1) / 16))) : ((": 415, + " + (-1_)) / 16": 416, + "unsign_ed ": 417, + "ar_ge": 418, + " + (-1))) ?_ ((": 419, + " =_ ((": 420, + ")) /_ ": 421, + "00_00": 422, + "co_n": 423, + " parallel for_ ": 424, + "&&_ (": 425, + "simd_ ": 426, + " _!": 427, + "omp parallel for_ private": 428, + "b_it_": 429, + "ke_y": 430, + "v_o": 431, + "ne_w": 432, + "logic__": 433, + "res_ult": 434, + "+_:": 435, + "p_h": 436, + "]_.": 437, + "__s": 438, + "ic,_1": 439, + "ar_ed": 440, + "e_s": 441, + ";\n _}\n\n}\n": 442, + "F_F": 443, + " *_ 1": 444, + "d__": 445, + "#pragma _omp ": 446, + "4_8": 447, + " <_ (": 448, + "for (i = 0; i < 1_000": 449, + ")_) + ": 450, + "st_r": 451, + "vtype_ x": 452, + "\n _{\n ": 453, + "0_][": 454, + "]_ = (((": 455, + "for (_k": 456, + "omp parallel for schedule(_dynam": 457, + "return_ ": 458, + "sh_ared": 459, + "; ++i)_\n{\n ": 460, + "D_E": 461, + " + _i": 462, + "a_c": 463, + ";\n _vtype x": 464, + "1_2": 465, + "++)_\n {\n ": 466, + "bu_f": 467, + "=_ (": 468, + ") +_ ((": 469, + "_p_s(": 470, + " _^": 471, + "ic,1_) private(i": 472, + "ar_ray": 473, + ", _&": 474, + "n_l": 475, + " <_ 1": 476, + " (((_(n": 477, + "16 * c1_) + 15": 478, + "l_hs[": 479, + ");\n _}\n\n ": 480, + "logic_s[i]": 481, + "}\n_\n ": 482, + "t_r": 483, + "] = (((_double) ": 484, + "n__": 485, + "if_f": 486, + ";\n _x": 487, + "n_g": 488, + " + (-1))_); ": 489, + "if_ ((": 490, + ")_\n {\n ": 491, + "}\n\n_}\n\n": 492, + "0_.": 493, + "for (i_ = 1; i": 494, + " = _x": 495, + " >_ ": 496, + " = 0_.0": 497, + "mat_rix": 498, + ";\n _}\n\n ": 499, + "omp parallel for schedule(dynam_ic,1) private(i": 500, + "omp parallel for schedule(dynamic,1) private(i_) reduction(": 501, + ";\n_\n ": 502, + "w_or": 503, + "; i++)_\n {\n ": 504, + " -_ (": 505, + "[_j": 506, + "ar_t": 507, + "st_private": 508, + "am_s": 509, + "vo_id": 510, + "o_l": 511, + "loc_k": 512, + "t_arge": 513, + "f_printf(": 514, + " (-1_6": 515, + "%_d": 516, + "i_t": 517, + " = _i": 518, + ")) _-": 519, + ")_;\n ": 520, + " = 0; _k": 521, + "in_g": 522, + "(_x": 523, + "1_0": 524, + "d_iff": 525, + "n_m": 526, + "b_or": 527, + " - 1_]": 528, + "6_4": 529, + " - 1_)": 530, + ")_;\n}\n": 531, + "ri_bu": 532, + "ribu_te": 533, + "(_&": 534, + ")_\n ": 535, + "dist_ribute": 536, + "p_se": 537, + "\n _ ": 538, + "OMP_xMax) + _OMP_xMax) + ": 539, + ") _&& (": 540, + "char_ *) ": 541, + "co_u": 542, + ") -_ ": 543, + "1_000": 544, + "la_pse": 545, + "a_s": 546, + "col_lapse": 547, + "or_ ": 548, + ">_ ": 549, + "]_, ": 550, + "ra_nd": 551, + "++)_\n {\n ": 552, + "stat_ic": 553, + " + _2": 554, + "_mm__": 555, + "for (int _j": 556, + "3_3": 557, + "omp _targe": 558, + "fi_r": 559, + ",_ (": 560, + "al__": 561, + "e_igh": 562, + "}_\n ": 563, + " *_ ((": 564, + "o_int": 565, + "\\n\"_, ": 566, + ") + _i": 567, + "((_(": 568, + "size_o": 569, + "0_x": 570, + "n_i": 571, + "[_c3": 572, + "no_de": 573, + "[c3_][": 574, + "[c3][_c4": 575, + " + 1_]": 576, + "[c3][c4_] = (((double) ": 577, + "[c3][c4] = (((double) _c3": 578, + "c_a": 579, + "st__": 580, + "cou_nt": 581, + "ma_ge": 582, + "DE_S": 583, + "[i][j_][k": 584, + "m_in": 585, + ";\n _u": 586, + "distribute_ parallel for ": 587, + ";\n _double ": 588, + "20_48": 589, + "ti_me": 590, + "collapse_(": 591, + "co_m": 592, + "sizeo_f(": 593, + " + (-1)) / 16_))": 594, + "no_w": 595, + "num__thread": 596, + "i_on": 597, + "float_ ": 598, + "re_e": 599, + "void_ ": 600, + "d_x": 601, + "3_]": 602, + "][_j]": 603, + " (_&": 604, + "c_lu": 605, + "el_l": 606, + "for (i = 0; i < _n": 607, + "shared_(": 608, + " <_<": 609, + "[i_el": 610, + "16 * c2) + 15_) < (n": 611, + " + (-1))) ? ((_16 * c2) + 15": 612, + " + (-1))) ? ((16 * c2) + 15_) : (n": 613, + "][_0]": 614, + "2_4": 615, + "fprintf(_st": 616, + " *_= ": 617, + "|_|": 618, + "DES__b": 619, + "DES_b_s_": 620, + "d_t": 621, + " <=_ ((((": 622, + " %_d": 623, + "25_6": 624, + "se_t": 625, + "s_k": 626, + "r_y": 627, + "k_now": 628, + " *)_ (((": 629, + "v_er": 630, + "omp__": 631, + "))_))": 632, + "de_rr": 633, + "s_, ": 634, + "1_1": 635, + "i_le": 636, + " _logics[i]": 637, + "derr_, \"": 638, + "fprintf(st_derr, \"": 639, + "o_p": 640, + "lo_ng": 641, + "0_.0": 642, + "__c": 643, + "j_ * ": 644, + "__g": 645, + "1_.0": 646, + "p_ar": 647, + "a_[i]": 648, + "t_->": 649, + "++)_\n {\n ": 650, + ")_]": 651, + ")_;\n}\n\n": 652, + ") + _k": 653, + "; j++)_\n{\n ": 654, + " <=_ (": 655, + "s_->": 656, + "i_m": 657, + "_p_oint": 658, + "[_0]": 659, + "}\n _else": 660, + "wor_d": 661, + "#pragma omp _simd": 662, + " = _j": 663, + "for (k_ = 0; k": 664, + ", _j": 665, + "ge_t_": 666, + "al_loc": 667, + "[_((": 668, + "e_nd": 669, + "at_ion": 670, + "[_index": 671, + "[_1": 672, + "-_-": 673, + "l_in": 674, + "y__": 675, + " + _3": 676, + " = 1_; j": 677, + ") * (_c4": 678, + "m_]": 679, + "i_ * ": 680, + "2 * _i": 681, + "[c3][c4] = (((double) c3_) * (c4": 682, + "; ++i)_\n {\n ": 683, + "++_;\n ": 684, + " * 1_00": 685, + " = __mm_": 686, + "++)_\n {\n ": 687, + "ou_nd": 688, + " !_= ": 689, + "cur_re": 690, + "st_art": 691, + "reduction(_+:": 692, + "lo_ad": 693, + "id_x": 694, + "n_x": 695, + ") -_ (": 696, + "__t ": 697, + "][_1]": 698, + "for (int j_ = 0; j": 699, + "][i][j][k_]": 700, + "for (_c4": 701, + "s_a": 702, + " == _0": 703, + "__i": 704, + "r_c": 705, + ")\n{\n _int ": 706, + "al_l": 707, + "ct_or": 708, + "2_.0": 709, + "v__b": 710, + "[_n": 711, + "*_*": 712, + "V_al": 713, + " *)_ (&": 714, + "v__": 715, + "c_i": 716, + "s_te": 717, + " + 1_)": 718, + "ed_ge": 719, + "an_ce": 720, + "er_r": 721, + "r_hs[": 722, + " < _n": 723, + "row_s": 724, + "clu_si": 725, + "n__sum": 726, + "[i]_.": 727, + ":_ ": 728, + "u_int": 729, + "know_n_sum": 730, + "1_ * 100": 731, + "ex_clusi": 732, + "exclusi_v_b": 733, + "exclusiv_b_it_": 734, + "logic__and": 735, + "bit__and": 736, + "b_in": 737, + "exclusiv_bit__or": 738, + "}\n\n _}\n\n ": 739, + "((_-": 740, + "][i_2": 741, + "5_12": 742, + "F__": 743, + "l_i": 744, + " + (-1))); _c4": 745, + "1_, ": 746, + "s_q": 747, + "][i_]": 748, + " <=_ (((": 749, + "; i++)\n{\n _for (j = 0; j < ": 750, + "#pragma omp simd_\n ": 751, + "; _c4": 752, + ")_;\n\n": 753, + ")_) + (": 754, + "#pragma omp simd\n _for (c4": 755, + "}\n_\n ": 756, + "p_ro": 757, + ")) -_ 1": 758, + "val_ue": 759, + "di_m": 760, + " >_= ": 761, + "[_col": 762, + "fir_stprivate": 763, + "))_;\n ": 764, + "E_rr": 765, + "o_m": 766, + "][_0][": 767, + "in_ ": 768, + "int_ *": 769, + "__y": 770, + "I_n": 771, + "eigh_t": 772, + "2_2": 773, + "omp parallel for _reduction(+:": 774, + "b_l": 775, + "1_ * ": 776, + "h_a": 777, + " = _a": 778, + "i_s": 779, + "ad_d": 780, + "if (_!": 781, + "__r": 782, + " ((((_-": 783, + ")) :_ (((": 784, + "c_ell": 785, + "for (j_ = 1; j": 786, + "Err_or ": 787, + ")\n {\n _result": 788, + ", _b": 789, + "s_p": 790, + "g_ra": 791, + "]_;\n ": 792, + " + (-1))); c4_++)\n {\n ": 793, + "o_f": 794, + "[i_3": 795, + "ct_x": 796, + "lin_e": 797, + "buf_[": 798, + "][_1": 799, + ") _schedule(": 800, + "5_5": 801, + "t_ic": 802, + "st_ ": 803, + "\"_, ": 804, + "e_le": 805, + "in_pu": 806, + ";\n_\n ": 807, + "16 * c1) + 15_) < (n": 808, + " + (-1))) ? ((_16 * c1) + 15": 809, + " + (-1))) ? ((16 * c1) + 15_) : (n": 810, + " += _1": 811, + "o_w": 812, + ", _0": 813, + "#pragma omp simd\n for (c4_ = ": 814, + "fprintf(stderr, \"_Error ": 815, + "B_F_": 816, + "))_;\n ": 817, + "_point_s[": 818, + "))_\n {\n ": 819, + "e_c": 820, + "for (i = 0; i < _N": 821, + ")\n {\n result_++;\n ": 822, + ")\n {\n result++;\n _fprintf(stderr, \"Error ": 823, + ")\n {\n result++;\n fprintf(stderr, \"Error _in ": 824, + "omp__get_": 825, + " < _5": 826, + "p_ = ": 827, + " &_ ": 828, + "#pragma _omp parallel for schedule(dynamic,1) private(i) reduction(": 829, + ") :_ (": 830, + "m_1": 831, + " +_ 16": 832, + "a_b": 833, + "[i_ + 1": 834, + "rand_(": 835, + ", _y": 836, + "grid__points[": 837, + ";\n _}\n\n ": 838, + "m_alloc": 839, + "omp parallel for private_(": 840, + " == _1": 841, + " (-_((-": 842, + ")) - 1_) /": 843, + "[_m": 844, + "at_rix": 845, + "]_;\n ": 846, + "lhs[_n": 847, + " + _4": 848, + "long_ ": 849, + " ^_ x": 850, + "s_pe": 851, + "__t": 852, + "b_lock": 853, + ") + _t": 854, + "de_l": 855, + "I_N": 856, + "ma_g": 857, + "u_p": 858, + "; j++)_\n ": 859, + "C_C": 860, + "2_] = ": 861, + ";\n}\n\n_\n": 862, + "omp targe_t": 863, + ") _%": 864, + "curre_nt": 865, + "distribute parallel for _simd ": 866, + ") +_ (-16": 867, + "1_ = ": 868, + "omp parallel for _simd ": 869, + " = 0_;\n ": 870, + ") _=": 871, + "][_4": 872, + "__f": 873, + "for (i = 1; i_ <= ": 874, + ")) *_ (": 875, + "ne_igh": 876, + "f_o": 877, + " 16) < 0) ?_ (-((-": 878, + " ((16 < 0) ?_ ((((-": 879, + ") + (-16_)) - 1) /": 880, + ") + (-16)) - 1) /_ (-16": 881, + ") + (-16)) - 1) / (-16_)) : (((": 882, + "[i][j]_ = ": 883, + "te_x": 884, + "ca_le": 885, + ") / 16)) :_ ((16 < 0) ? ((((-": 886, + "de_fa": 887, + "i_l": 888, + "sum_ += ": 889, + "MP_I": 890, + "ol_d": 891, + ")) _<": 892, + "(_int ": 893, + ";\n int _i": 894, + "(_*((": 895, + "d_uc": 896, + "ams_.": 897, + " *_ 16) < 0) ? (-((-": 898, + "[_1]": 899, + "MPI__": 900, + ")_\n ": 901, + "9_9": 902, + "][_2]": 903, + "; i_ < ": 904, + "s_rc": 905, + "c_0": 906, + "-_1": 907, + " _|": 908, + "__num": 909, + "p_s": 910, + "ve_ctor": 911, + "b_o": 912, + "defa_ult": 913, + "a_k": 914, + "logic__or": 915, + "bit__or": 916, + "te_ams": 917, + " _,": 918, + "com_bin": 919, + "combin_ed": 920, + "all__p": 921, + ") =_= ": 922, + "s[i]_.": 923, + " _ ": 924, + ";\n }\n\n _}\n\n}\n": 925, + "id_th": 926, + "bl_ic": 927, + "o_ff": 928, + "sh_a": 929, + " *) (((_char *) ": 930, + "combined_ *) (((char *) ": 931, + ")))_.": 932, + "all_p_) + t": 933, + "all_p) + t_))).": 934, + "0_24": 935, + "len_(": 936, + "num_thread_s(": 937, + "vtype_ *) (&": 938, + "or_de": 939, + "m_o": 940, + "blic_.": 941, + " + 1_)) / ": 942, + "ed__": 943, + "__col": 944, + "teams_ ": 945, + ",_ 1": 946, + "b_re": 947, + "2_ = ": 948, + "omp target_ parallel for ": 949, + "w_idth": 950, + "con_st ": 951, + " >_> ": 952, + " <= ((((_16 * c2) + 15) < (n": 953, + "}_\n ": 954, + "bre_ak": 955, + "if (_i": 956, + "0_] = ": 957, + "sum_ = ": 958, + "ar_r": 959, + "__size": 960, + "__sha": 961, + "p_tr": 962, + "for (i = 0; i < _20": 963, + "ha_sh": 964, + "i_x": 965, + "la_stprivate": 966, + "m_or": 967, + "err_or": 968, + "u_b": 969, + "double_ *": 970, + ") _^": 971, + "e_n": 972, + "dist_ance": 973, + "p_t": 974, + "d_o": 975, + "gra_ph": 976, + "static_ ": 977, + "i_st": 978, + "n_n": 979, + "b_er": 980, + "3_ * ": 981, + "In_dex": 982, + "[i]_ = (": 983, + "2_1": 984, + "te_st_": 985, + "3_0": 986, + " + _k": 987, + ") + _j": 988, + "0._5": 989, + "i_ze": 990, + "][_m]": 991, + "unsigned _char": 992, + ") _|": 993, + "; _m": 994, + "}\n else_\n {\n ": 995, + "ab_s": 996, + "on_e": 997, + "[_x": 998, + "e_ta": 999, + "5_1": 1000, + "4_0": 1001, + "sq_r": 1002, + "b_it": 1003, + "Val_(": 1004, + ", _n": 1005, + "B_[": 1006, + "_m_ul": 1007, + " = _v": 1008, + "w_h": 1009, + "M_atrix": 1010, + "ver_tic": 1011, + "r__": 1012, + " + 16_) - 1) / 16))": 1013, + "duc_t": 1014, + "ra_nk": 1015, + "ve_c": 1016, + "++)_\n ": 1017, + "for (i = 0; i < 1000_; ++i)\n{\n ": 1018, + "u_1": 1019, + "for (int j = 0; j_ < ": 1020, + "C_H": 1021, + "1_ - ": 1022, + "h_o": 1023, + ";\n _}\n\n ": 1024, + ",_j": 1025, + "ce_nt": 1026, + "*_(": 1027, + "))_);\n ": 1028, + " * _x": 1029, + "__T": 1030, + "neigh_bor": 1031, + " *_ (((": 1032, + "for (k = 0; k_ < ": 1033, + "omp parallel for _shared(": 1034, + " = 1_;\n ": 1035, + "t _teams ": 1036, + "loc_al_": 1037, + "re_al": 1038, + "omp targe_t teams ": 1039, + "->_n": 1040, + "for (i_ = ": 1041, + "out_pu": 1042, + "unsigned _char *) ": 1043, + "abs_Val(": 1044, + "for (i = 0; i < 1000_; ++i)\n {\n ": 1045, + "S_cale": 1046, + "spe_ed": 1047, + "[_2]": 1048, + "par_ams.": 1049, + "0_)": 1050, + " _a": 1051, + " !_= (": 1052, + " + (-1))_) < (n": 1053, + " + (-1))_) : (n": 1054, + " <= (_grid_points[": 1055, + "S_ize": 1056, + "7_7": 1057, + "; ++_j": 1058, + "wh_ile": 1059, + " logics[i]_;\n}\n": 1060, + "e_nt": 1061, + "s_ = ": 1062, + "; c4_ <= ((((16 * c2) + 15) < (n": 1063, + "s_c": 1064, + "del_ta": 1065, + "me_m": 1066, + ");\n _}\n\n}\n": 1067, + "_p_ar": 1068, + "[(i * _N": 1069, + "DES_bs__combined *) (((char *) ": 1070, + "DES_bs_combined *) (((char *) _DES_bs_": 1071, + ")) *_ ": 1072, + "][_3": 1073, + "DES_bs_combined *) (((char *) DES_bs__all_p) + t))).": 1074, + " +_ ((": 1075, + ";\n _}\n\n ": 1076, + "to_t": 1077, + " - _2": 1078, + "n_y": 1079, + "c_p": 1080, + " = 0_.": 1081, + "1_9": 1082, + "(*((_DES_bs_combined *) (((char *) DES_bs_all_p) + t))).": 1083, + "p_a": 1084, + "\\n\"_);\n }\n\n ": 1085, + "_s_al": 1086, + "omp _distribute parallel for simd ": 1087, + ") reduction(_+:": 1088, + " &_ (": 1089, + "c_ry": 1090, + "sum = _sum": 1091, + " += _2": 1092, + ") ?_ (": 1093, + "][j_][i": 1094, + "}\n _else": 1095, + "; j++)_\n {\n ": 1096, + "[k_]": 1097, + "str_uc": 1098, + ") _shared(": 1099, + ")_, ": 1100, + "for (_c3": 1101, + "ma_sk": 1102, + "for (_c2": 1103, + "[i_dx": 1104, + "][i_1]": 1105, + "uint_32": 1106, + "for (j = 0; j_ < 1": 1107, + "A_R": 1108, + "j_ + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1109, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n_j": 1110, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj_ + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1111, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(n_j": 1112, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj_ + (-1))) + 16) - 1) / 16))) : ((": 1113, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((_nj": 1114, + " logics[i]_;\n }\n\n ": 1115, + "a_bor": 1116, + "ff_er": 1117, + "[i_ - 1": 1118, + "m__": 1119, + "A_T": 1120, + "D_5": 1121, + "ter_ation": 1122, + "abor_t(": 1123, + "b_ound": 1124, + ")\n _for (i = 0; i < 1000; ++i)\n {\n ": 1125, + "len_g": 1126, + "9_6": 1127, + "*((_vtype *) (&": 1128, + "val_2": 1129, + "rhs[_m": 1130, + "k_ * ": 1131, + "po_int": 1132, + "leng_th": 1133, + "2_;\n ": 1134, + " = 0.0_;\n ": 1135, + " * (_1 * 100": 1136, + "y_ * ": 1137, + ") _> ": 1138, + "4_)": 1139, + "][i][j][k_] = ": 1140, + " = _mm__load": 1141, + "]_ += ": 1142, + "c_omp": 1143, + "omp parallel for private_(i": 1144, + "ar_g": 1145, + "c3_++)\n {\n ": 1146, + "c3++)\n {\n _#pragma omp simd\n for (c4 = ": 1147, + "c3++)\n {\n #pragma omp simd\n for (c4 = _16 * c2": 1148, + "._i": 1149, + "P_E": 1150, + "n_t_": 1151, + "ce_[": 1152, + "; _col": 1153, + "vertic_es": 1154, + "omp parallel for _default": 1155, + " >_>": 1156, + " -_= ": 1157, + "i_mage": 1158, + "schedule_ (": 1159, + ")) _?": 1160, + "se_t_": 1161, + "return_ 1": 1162, + "1_;\n ": 1163, + "off_set": 1164, + ") _||": 1165, + "or_e": 1166, + "g_r": 1167, + "2_.": 1168, + "n_si": 1169, + "[j]_ = ": 1170, + "for (_m": 1171, + "f_ree": 1172, + "a_me": 1173, + "col_s": 1174, + ") |_ (": 1175, + "bound_ry": 1176, + "boundry_Scale": 1177, + " = 0; _m": 1178, + " *= _boundryScale": 1179, + " + (-1))); _c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2": 1180, + ";\n _}\n\n}\n\n": 1181, + ";\n u_3": 1182, + "s_s": 1183, + "fa_b": 1184, + "abort(_);\n\n": 1185, + "d_pt": 1186, + "; i++)_\n {\n ": 1187, + "ta_ble": 1188, + ") %_ ": 1189, + " + (-1)) / 16))_) ?": 1190, + "[i] = _i": 1191, + "i_t(": 1192, + "pu_blic.": 1193, + "for (i = 0; i < _64": 1194, + "k_ + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1195, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n_k": 1196, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk_ + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1197, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(n_k": 1198, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk_ + (-1))) + 16) - 1) / 16))) : ((": 1199, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((_nk": 1200, + "y_z": 1201, + ")) _&& (": 1202, + "l_arge": 1203, + "T_R": 1204, + "M_D5": 1205, + ",_k": 1206, + "ne_x": 1207, + ")_\n {\n ": 1208, + "co_nt": 1209, + "um_n": 1210, + " <<_ ": 1211, + "v_i": 1212, + "re_c": 1213, + "cry_p": 1214, + "_mul__ps(": 1215, + "cur__sal": 1216, + "; _x": 1217, + "b_[i]": 1218, + "._x": 1219, + "O_R": 1220, + "__h": 1221, + "L_L": 1222, + "5_A": 1223, + "MD5__": 1224, + ";\n _if (": 1225, + "_p_ro": 1226, + "o_de": 1227, + "ge_t": 1228, + "po_s": 1229, + ") _>": 1230, + "j_e": 1231, + "%_f": 1232, + "(_p": 1233, + "; _c3": 1234, + "omp parallel for private_ (": 1235, + "Y_PE": 1236, + "][i_1": 1237, + ")_ (": 1238, + "me_nt": 1239, + "E_S": 1240, + " - _2)": 1241, + ", _k": 1242, + "4_4": 1243, + ".0_ * ": 1244, + "AR_CH": 1245, + "if_ (((": 1246, + " _of": 1247, + " *) _malloc": 1248, + "a_p": 1249, + "2_) * ": 1250, + ");\n _x": 1251, + "])_) + (": 1252, + " = 0_;\n}\n": 1253, + "orde_red": 1254, + "le_x": 1255, + " + 2_)) / ": 1256, + "i_th": 1257, + "ch_un": 1258, + "for (c3_ = ": 1259, + "; i++)\n _if (": 1260, + "u_s": 1261, + "de_st": 1262, + " + (-1))) ?_ ((((": 1263, + "j_ + (-1))) ? ((16 * c2) + 15) : (n": 1264, + "j + (-1))) ? ((16 * c2) + 15) : (n_j": 1265, + "3_)": 1266, + "thread__num": 1267, + "(x_, y": 1268, + " (n_j": 1269, + "][_c2": 1270, + ";\n }\n\n _}\n\n ": 1271, + "r_s": 1272, + "[_3": 1273, + "]_ + ": 1274, + ";\n _ ": 1275, + "I_nd": 1276, + "]_) + ": 1277, + "g_ree": 1278, + "for (_col": 1279, + "in_2": 1280, + "ec_k": 1281, + " + _OMP_xMax) + OMP_xMax) + ": 1282, + "cur_sal_t->": 1283, + "BF__current": 1284, + ") _firstprivate": 1285, + "BF_current_.": 1286, + "))_;\n ": 1287, + "c_b": 1288, + ";\n\n_}\n": 1289, + "}\n\n_\n": 1290, + " +_= (": 1291, + "__C": 1292, + "); _k": 1293, + ") && (_i": 1294, + "]_;\n ": 1295, + "add__ps(": 1296, + " + 2)) / _nk": 1297, + "d_sum": 1298, + "__idx": 1299, + "int_) ": 1300, + "num_thread_s": 1301, + "[i][_k": 1302, + "[iel_][": 1303, + "stat_s->": 1304, + "n_u": 1305, + "; _c2": 1306, + "d_diff": 1307, + "}\n else_\n ": 1308, + "i_p": 1309, + " + 3_)) / ": 1310, + "chun_k": 1311, + "_mm__mul_ps(": 1312, + ";\n\n_\n": 1313, + "f_e": 1314, + "for (int i = 0; i_ < 1": 1315, + "s[_j]": 1316, + "w_eight": 1317, + " < _N": 1318, + "lo_op": 1319, + " <_ (n": 1320, + "num_ber": 1321, + " = 0; _col": 1322, + "2_3": 1323, + "[(_j * ": 1324, + "thread_s": 1325, + "l_l": 1326, + "__row": 1327, + " *= boundryScale_;\n ": 1328, + "#pragma _omp": 1329, + " %d_ ": 1330, + "((_2 * i": 1331, + "]_ = (": 1332, + " %_ ": 1333, + "lo_w": 1334, + "omp_get__thread_num": 1335, + "C_ol": 1336, + ", _c": 1337, + "ro_m": 1338, + "2_8": 1339, + "b_e": 1340, + "0000_00": 1341, + " <= ((((_16 * c1) + 15) < (n": 1342, + "v_l": 1343, + "fa_ce": 1344, + "omp_get_thread_num_(": 1345, + "2.0_ * ": 1346, + "m_2": 1347, + "_T_YPE": 1348, + "N_um": 1349, + "fab_s(": 1350, + "_par_allel": 1351, + "t_x": 1352, + "q_ue": 1353, + " = _col": 1354, + " + 3)) / _nl": 1355, + "**_**": 1356, + "as_sign": 1357, + "._r": 1358, + ")_) + ((": 1359, + "ch_eck": 1360, + " + 1)) / _nj": 1361, + "la_st": 1362, + "return _0": 1363, + "if_ (n": 1364, + "yz_Ind": 1365, + "for (m_ = 0; m": 1366, + "struc_t ": 1367, + "\\n\"_, i": 1368, + "unsigned _int ": 1369, + "p_[": 1370, + "u_x": 1371, + " <=_ ((": 1372, + "l_d": 1373, + " ((((n_k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk": 1374, + "large_r": 1375, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj_ + (-1)) / 16": 1376, + "po_w": 1377, + "m_y": 1378, + "for (i = 0; i < n_; i++)\n{\n ": 1379, + ")_;\n": 1380, + "graph_->": 1381, + "ze_ta": 1382, + ")))_) + (": 1383, + "ri_me": 1384, + " = _mm__add_ps(": 1385, + "fo_o": 1386, + "l_ + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1387, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n_l": 1388, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl_ + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1389, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(n_l": 1390, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl_ + (-1))) + 16) - 1) / 16))) : ((": 1391, + "l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((_nl": 1392, + "ix_el": 1393, + "][i_][j": 1394, + ".__": 1395, + "I_T": 1396, + "i_ + ": 1397, + "while_ (": 1398, + "te_d": 1399, + "])_;\n ": 1400, + "}\n\n }\n\n _}\n\n ": 1401, + "_mm_256": 1402, + " ((((n_m": 1403, + "y_te": 1404, + "2_, ": 1405, + "s_ter": 1406, + " ((((nm_ + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 1407, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n_m": 1408, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm_ + (-1))) + 16) + 1) / 16)) : (-((((-(n": 1409, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(n_m": 1410, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm_ + (-1))) + 16) - 1) / 16))) : ((": 1411, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((_nm": 1412, + "2_9": 1413, + "0_F": 1414, + "7_6": 1415, + "__array": 1416, + "))_) ^": 1417, + " * (_sizeof(": 1418, + "5_00": 1419, + " <<_ (": 1420, + "ar_e": 1421, + " & (_~": 1422, + "j_ = ": 1423, + "[n_temp": 1424, + "params._nx": 1425, + "bit_._": 1426, + "l_h": 1427, + "S_I": 1428, + "i_ = 0; i": 1429, + "T_h": 1430, + "][_3]": 1431, + "r_ho": 1432, + "3_6": 1433, + "for (i = 1; i <= _1000": 1434, + ");\n _}\n\n ": 1435, + ") / _ni": 1436, + "or_d": 1437, + "k_er": 1438, + ", (_MPI_": 1439, + "pro_duct": 1440, + "[_l": 1441, + "for (i_ = j": 1442, + "))_) + ((": 1443, + "for (col_ = 0; col": 1444, + "c1_][c2": 1445, + "{\n _ ": 1446, + ")) + _j": 1447, + "speed_s[": 1448, + "for (int _k": 1449, + "\n _{\n ": 1450, + "[i]_ * ": 1451, + "for (i = 0; i <_ (": 1452, + "_parallel__": 1453, + "[i3_][i2": 1454, + "=_ ((": 1455, + "x_i": 1456, + "at_o": 1457, + "E_N": 1458, + "nj_ac": 1459, + "3_C": 1460, + "omp parallel for _collapse(": 1461, + "s_ph": 1462, + ") private_(": 1463, + "art_ic": 1464, + "3_F": 1465, + "_b_u": 1466, + "l_++": 1467, + "temp_ = ": 1468, + ") + _u": 1469, + "sa_v": 1470, + "static _void ": 1471, + "omp__parallel_": 1472, + "))_\n {\n ": 1473, + "R_ow": 1474, + "__in": 1475, + " *= boundryScale;\n _u[": 1476, + "p_re": 1477, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t)))._B[": 1478, + "__n": 1479, + "test__omp_parallel_": 1480, + "(n_one": 1481, + "uc_ke": 1482, + "((_(n": 1483, + "r_un": 1484, + "omp target parallel for _simd ": 1485, + "&_buf[": 1486, + "float_ *": 1487, + "; _y": 1488, + "e_re": 1489, + "ile_d": 1490, + "static_, ": 1491, + "for (int i = 0; i < _n": 1492, + "or_i": 1493, + "t_1": 1494, + "; i < _k": 1495, + "for (j_ = ": 1496, + "t_2": 1497, + "0_ * (1 * 100": 1498, + "; j++)_\n ": 1499, + ") _0x": 1500, + "ge_R": 1501, + ", _z": 1502, + "N_ode": 1503, + "artic_le": 1504, + " ^_= ": 1505, + " - 1)_; i": 1506, + "3_1": 1507, + " ((((n_l + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl": 1508, + ", __mm_mul_ps(": 1509, + "D_[c3][c4] = (((double) c3) * (c4": 1510, + "D[c3][c4] = (((double) c3) * (c4_ + 2)) / nk": 1511, + " << (_32": 1512, + "s_w": 1513, + "OMP__": 1514, + "g_->": 1515, + "6_6": 1516, + ");\n _if (": 1517, + "fir_st": 1518, + "2_[i]": 1519, + "ind_x": 1520, + "R_es": 1521, + "[_ARCH": 1522, + ") _&&": 1523, + "tmp_1 * ": 1524, + ";\n int _j": 1525, + " >>_ 1": 1526, + "absVal(_val": 1527, + "data_->": 1528, + "float_) ": 1529, + "[_0][": 1530, + "; _p": 1531, + "lex_ ": 1532, + "c1][c2_] = (((double) ": 1533, + "c1][c2] = (((double) _c1": 1534, + "] = _1": 1535, + "ste_p": 1536, + "]_ - ": 1537, + "max__": 1538, + "}\n else_\n {\n ": 1539, + ")) -_ (": 1540, + "n_z": 1541, + "free_(": 1542, + "ma_p": 1543, + "d_ate": 1544, + "._y": 1545, + "5_0": 1546, + "x_ = 0; ": 1547, + "A_A": 1548, + "uint32__t ": 1549, + " <_ 16": 1550, + "; i++)\n _for (j = 0; j < ": 1551, + "fi_le": 1552, + ";\n_\n ": 1553, + "m_y_": 1554, + "4_6": 1555, + " = _c": 1556, + "else_\n ": 1557, + "=_ (((": 1558, + "me_an": 1559, + "1_4": 1560, + "\n _abort();\n\n": 1561, + "_sha_1": 1562, + ")_) +": 1563, + "ato_i": 1564, + "])_) + ": 1565, + " - 1_) * ": 1566, + "b_el": 1567, + "n_el": 1568, + "bu_ffer": 1569, + "S_e": 1570, + "u_[i][j][k": 1571, + "u_re": 1572, + "#pragma omp_ for": 1573, + "8_19": 1574, + "x_[i]": 1575, + "cryp_t_": 1576, + "de_gree": 1577, + "ul_t ": 1578, + "[k_][j]": 1579, + "i_i": 1580, + "ca_se": 1581, + "si_tion": 1582, + " += 2_)\n ": 1583, + "la_bel": 1584, + "c_00": 1585, + "[_2": 1586, + "line_ar": 1587, + "for (_p = ": 1588, + ")_;\n\n ": 1589, + ") *_ ((": 1590, + "m_3": 1591, + "d_E": 1592, + ")\n{\n _return": 1593, + "][_5": 1594, + "x_ < ": 1595, + "->_data": 1596, + "][_2": 1597, + ") == _0": 1598, + "; ++_k": 1599, + " (n_k": 1600, + "sum = sum_ + i": 1601, + "s_al": 1602, + "col_umn": 1603, + "[_v": 1604, + "sum_)": 1605, + "U_M": 1606, + " _\", ": 1607, + "outpu_t": 1608, + "lo_b": 1609, + "u_t": 1610, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2_; c4 <= ((((16 * c2) + 15) < (n": 1611, + "C_omp": 1612, + " + (_N": 1613, + "for (col = 0; col_ < ": 1614, + "819_2": 1615, + "S_t": 1616, + "=_ (-1": 1617, + "BF__word": 1618, + "firstprivate_(": 1619, + " += 1_)\n{\n ": 1620, + "00_000": 1621, + "f_in": 1622, + "]_);\n ": 1623, + "__IN": 1624, + "32_76": 1625, + "->_ve": 1626, + "cur_r": 1627, + "y_(": 1628, + "_p_tr": 1629, + ") ||_ (": 1630, + "h_e": 1631, + "A_[": 1632, + " <= (((_(((": 1633, + "pow_(": 1634, + "s_; i++)\n{\n ": 1635, + ")\n{\n int _i": 1636, + "\n _ ": 1637, + "B_IT": 1638, + "ph_a": 1639, + "BF_current._S": 1640, + "buf_[i]": 1641, + "*_out": 1642, + "); _c2": 1643, + "3_))": 1644, + "gr_->": 1645, + "B_[c3][c4] = (((double) c3) * (c4": 1646, + "B[c3][c4] = (((double) c3) * (c4_ + 1)) / nj": 1647, + "C_[c3][c4] = (((double) c3) * (c4": 1648, + "C[c3][c4] = (((double) c3) * (c4_ + 3)) / nl": 1649, + " = 0.0_;\n ": 1650, + "; i++)\n if (_buf[i]": 1651, + " = _tmp": 1652, + "__id": 1653, + "sa_fe": 1654, + "sav_ed_": 1655, + "(x_)": 1656, + "][m]_ + (": 1657, + ";\n _u[": 1658, + "for (i = 0; i < 64_; i++)\n if (buf[i]": 1659, + "))))_\n abort();\n\n": 1660, + "ou_r": 1661, + "an_k": 1662, + "1_5": 1663, + "*((_BF_word": 1664, + "*((BF_word_ *) (((": 1665, + "*((BF_word *) (((_unsigned char *) ": 1666, + "*((BF_word *) (((unsigned char *) _BF_current.S": 1667, + "._bit._": 1668, + " = 1_.0": 1669, + "ci_ty": 1670, + "p_er": 1671, + "omp parallel for _num_threads(": 1672, + "logic_s[": 1673, + " _OR": 1674, + " OR_ par": 1675, + "D_AT": 1676, + "I_D": 1677, + "i_teration": 1678, + "w_ith": 1679, + "DAT_A": 1680, + "h_eight": 1681, + "if_f(": 1682, + "_IN_DE": 1683, + "_INDE_X": 1684, + "eigh_bor": 1685, + "a_ble": 1686, + "D_i": 1687, + "bo_x": 1688, + "x_yzInd": 1689, + "col_ = col": 1690, + "col = col_ + 4": 1691, + "logics[_1000": 1692, + "test_omp_parallel__for": 1693, + "DATA__TYPE": 1694, + "new__": 1695, + "ele_ment": 1696, + " + 1_) * ": 1697, + ", _a": 1698, + "[ARCH__INDEX": 1699, + "fa_iled": 1700, + "v_assign": 1701, + "}_\n ": 1702, + "for (i = 1; i_ < (": 1703, + "TR_I": 1704, + "; i++)\n{\n _if (": 1705, + "__a": 1706, + "n_or": 1707, + "[i]_);\n}\n": 1708, + "__EN": 1709, + "_p_s": 1710, + "i_s_": 1711, + ", _double ": 1712, + "(_*": 1713, + "i_ti": 1714, + " = _mm_load_1": 1715, + "; j_ < ": 1716, + "2_;\n ": 1717, + ") _collapse(": 1718, + "j_1": 1719, + "E_LL": 1720, + "in_ue": 1721, + "s_)": 1722, + "y_er": 1723, + "C_0": 1724, + "int_ p": 1725, + "f_p": 1726, + "_C_ELL": 1727, + "_CELL__EN": 1728, + "_CELL_EN_TRI": 1729, + "_CELL_ENTRI_ES": 1730, + ", _p": 1731, + "cont_inue": 1732, + ") - 1_][": 1733, + ",_i": 1734, + "e_p": 1735, + "omp target teams _distribute parallel for ": 1736, + "1_.": 1737, + "2_))": 1738, + "i_ + (-1))) ? ((16 * c1) + 15) : (n": 1739, + "i + (-1))) ? ((16 * c1) + 15) : (n_i": 1740, + "2_000": 1741, + "3_4": 1742, + "___": 1743, + "col_or": 1744, + " + (N__CELL_ENTRIES": 1745, + ")) * (_1 * 100": 1746, + ")\n{\n _double ": 1747, + "al_pha": 1748, + "t_, ": 1749, + "e_mp": 1750, + "for (i = 0; i < 1000_; i++)\n{\n ": 1751, + "s_je": 1752, + "printf(\"_%": 1753, + " + i_) + ": 1754, + "[_0": 1755, + "inpu_t_": 1756, + ")) * (1 * 100_))))": 1757, + "z_1": 1758, + ") + _y": 1759, + "ro_id": 1760, + ";\n _}\n else\n {\n ": 1761, + "D_ist": 1762, + "R_S": 1763, + "}\n\n }\n\n _}\n\n}\n": 1764, + ";\n }\n\n _}\n\n ": 1765, + "u__ps(": 1766, + " |_ ": 1767, + "Th_read": 1768, + "nsi_on": 1769, + "][j_][i]": 1770, + ", _x": 1771, + "me_nsion": 1772, + "case_ ": 1773, + ") + j]_ = ": 1774, + "__v": 1775, + "[i]_;\n}\n": 1776, + "[_4": 1777, + "char_ *": 1778, + "; c3_ <= ((((16 * c1) + 15) < (n": 1779, + ";\n }\n\n _#pragma omp simd\n for (c4 = ": 1780, + "le_f": 1781, + "ch_an": 1782, + ") * _c4": 1783, + "lh_s": 1784, + "][k_]": 1785, + " = 1_; k": 1786, + "lastprivate_(": 1787, + "l_ + (-1))) ? ((16 * c2) + 15) : (n": 1788, + "l + (-1))) ? ((16 * c2) + 15) : (n_l": 1789, + "size__t ": 1790, + "(_shared": 1791, + " + (N_CELL_ENTRIES_ * ((": 1792, + "[(i_ * (": 1793, + "cent_D": 1794, + "sqr_t(": 1795, + "private_.": 1796, + "geR_ank": 1797, + "] * _nu": 1798, + "centD_iff(": 1799, + "1_ + ": 1800, + "tmp__": 1801, + "C_ou": 1802, + "\\_t": 1803, + "u__": 1804, + "x_ = ": 1805, + "te_n": 1806, + "(&_ctx": 1807, + "}\n\n _}\n\n ": 1808, + "c_5": 1809, + " * (_ce[": 1810, + "A_[c3][c4] = (((double) c3": 1811, + "A[c3][c4] = (((double) c3_) * c4": 1812, + "A[c3][c4] = (((double) c3) * c4_) / ni": 1813, + "j_ac": 1814, + "16 * c2) + 15) < (n_j + (-1))) ? ((16 * c2) + 15) : (nj": 1815, + "ig_n": 1816, + " == 0_)\n {\n ": 1817, + "se_c": 1818, + "v_ar": 1819, + "B_u": 1820, + "ti_d": 1821, + "line_ ": 1822, + "nex_t": 1823, + "[_y": 1824, + "}\n _else": 1825, + "in_line ": 1826, + ".0_f": 1827, + "sum_ = 0;\n ": 1828, + "yte_s": 1829, + "f_jac": 1830, + "[i_ + 1]": 1831, + "))_\n ": 1832, + "x__": 1833, + "ver_tex": 1834, + "al_ign": 1835, + "for (p = _&buf[": 1836, + "FF_FF": 1837, + "10_24": 1838, + ") - 1][_((2 * i": 1839, + ") | (_temp": 1840, + "[(_k * ": 1841, + "te_st": 1842, + "4_, ": 1843, + "unsigned char_ *": 1844, + "with_ ": 1845, + "[(i_ * 1": 1846, + "3_5": 1847, + "m_ + (-1))); c4++)\n {\n ": 1848, + "8_0": 1849, + "ta_b": 1850, + "j_j * ": 1851, + "t_ra": 1852, + "OMP_xMax) + _OMP_xMax": 1853, + " + OMP_xMax) + OMP_xMax) + _OMP_xMax) + OMP_xMax) + ": 1854, + "for (k_ = 1; k": 1855, + "A_[(i * ": 1856, + "as_s": 1857, + " ((_double) ": 1858, + "st_d_": 1859, + "(_);\n ": 1860, + ", _int *": 1861, + "r_ound": 1862, + "_s_ub": 1863, + "la_g": 1864, + "[_3]": 1865, + "v_el": 1866, + " -_ p": 1867, + "safe_len(": 1868, + "]_;\n}\n": 1869, + "omp parallel for default_(none": 1870, + "a_ce": 1871, + "c_nt": 1872, + "0000_000": 1873, + "5_)": 1874, + "se_ed": 1875, + "; k_++)\n {\n ": 1876, + " += 2)\n _l++": 1877, + " += 2)\n l++_;\n\n\n": 1878, + "atoi_16": 1879, + "]_ *= boundryScale;\n u[": 1880, + "T_able": 1881, + "E_R": 1882, + "w_as": 1883, + " /_ (": 1884, + "DATA_TYPE_) ": 1885, + "ul_l": 1886, + "3276_7": 1887, + "Res_ult ": 1888, + ";\n }\n\n _}\n\n }\n\n }\n\n ": 1889, + "align_ed": 1890, + "atoi16_[ARCH_INDEX": 1891, + "in_ste": 1892, + "inste_ad": 1893, + "instead_ of": 1894, + "i_el": 1895, + ") + (_j": 1896, + "p_1": 1897, + ") * (_c2": 1898, + "A_[((": 1899, + "t_ 1": 1900, + "y_y": 1901, + "for (col = 0; col < _9": 1902, + "tot_al_": 1903, + "d_known_sum": 1904, + ": _Result ": 1905, + ": Result _was": 1906, + " logics[i];\n }\n\n _if (!": 1907, + " logics[i];\n }\n\n _if (": 1908, + " + (-1)) / 16))) ?_ ((((n": 1909, + ";\n _tmp": 1910, + ", _s": 1911, + "m_;\n ": 1912, + "_s_q": 1913, + "RS_Comp": 1914, + "run_time": 1915, + " + (_i * ": 1916, + ";\n }\n\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 1917, + "b_ucke": 1918, + "omp parallel for reduction(+:_ ": 1919, + "printf(\"_%d": 1920, + "dynam_ic": 1921, + ")) ?_ (": 1922, + "ste_ps": 1923, + "for (col = 0; col < 9_51": 1924, + "for (col = 0; col < 951_00": 1925, + "for (col = 0; col < 95100_; col": 1926, + "N_UM": 1927, + "v_1": 1928, + "logics[1000_ / ": 1929, + "test_omp_parallel_for__": 1930, + " &_= ": 1931, + "po_sition": 1932, + "stat_ic,": 1933, + " - _i": 1934, + "sc_an": 1935, + "simd_len(": 1936, + "[j_][i": 1937, + "RSComp_lex ": 1938, + "A_r": 1939, + "]_;\n ": 1940, + " =_ ((((": 1941, + "omp parallel for private(_j": 1942, + " * _i": 1943, + "di_a": 1944, + "i_ty": 1945, + "__to": 1946, + "inpu_t": 1947, + ");\n _}\n\n}\n\n": 1948, + ") _= ": 1949, + "A_ + i": 1950, + ", _i)": 1951, + "DATA_TYPE) _i": 1952, + "for (_x = 0; ": 1953, + "I_mage": 1954, + "id_mo": 1955, + "3_.": 1956, + "st_ri": 1957, + "0_1": 1958, + "wor_k": 1959, + ";\n _p": 1960, + "fi_l": 1961, + ")_;\n ": 1962, + " - (_2.0 * ": 1963, + "[i + 1_][": 1964, + "1_8": 1965, + "c_al": 1966, + "rand_om": 1967, + " < 5_; k": 1968, + "c1][c2] = (((double) c1_) * (c2": 1969, + "sph__sha1": 1970, + " != _0": 1971, + "A_[i]": 1972, + "ac_c": 1973, + "MD5__std_": 1974, + "OMP__Index": 1975, + "][0][_0]": 1976, + "mem_cp": 1977, + "omp parallel for shared(_col": 1978, + "y_ = ": 1979, + "saved__key": 1980, + "++_;\n }\n\n}\n\n": 1981, + "))) ^_ (": 1982, + "y_ < ": 1983, + "}\n else\n _if (": 1984, + "][_col": 1985, + "ing__": 1986, + "; i_ += ": 1987, + "\\n\"_);\n}\n": 1988, + "y_ = 0; ": 1989, + "for (k_ = ": 1990, + "A_D": 1991, + "sqr_t": 1992, + " _: ": 1993, + "omp parallel for _schedule (": 1994, + "l_f": 1995, + ");\n _}\n\n ": 1996, + "ze_ro": 1997, + "scan_f(": 1998, + "p_ixel": 1999, + "y_pe": 2000, + "x_x": 2001, + "cent_roid": 2002, + "G_rid": 2003, + "n_ce": 2004, + ") - _d": 2005, + "->_me": 2006, + ";\n }\n\n _}\n\n}\n\n": 2007, + "Ar_ray": 2008, + "a_ve": 2009, + "s_++": 2010, + "[i_i": 2011, + "25_5": 2012, + "for (int k_ = 0; k": 2013, + "for (c3 = _16 * c1": 2014, + "33_CC": 2015, + " & (~_x": 2016, + ", int _n": 2017, + "f_lu": 2018, + "o_me": 2019, + "[i]_]": 2020, + "tot_al": 2021, + "V_e": 2022, + "lhs[n_ + 3": 2023, + "for (i = 0; i < 1000_; i++)\n {\n ": 2024, + "re_g": 2025, + "A_N": 2026, + "t_s": 2027, + "n_temp": 2028, + "o_s": 2029, + " == _3": 2030, + "[_indx": 2031, + ";\n }\n\n _if (": 2032, + "__count": 2033, + "t_ = ": 2034, + "_p_er": 2035, + "n_ter": 2036, + " = _%d": 2037, + " %_f": 2038, + "j_2": 2039, + "str_->": 2040, + "i_2": 2041, + "num__vertices": 2042, + " + (-1))) < (n_m": 2043, + "p_rime": 2044, + "at_h": 2045, + "c_ing": 2046, + " &= _0x": 2047, + "loc_al": 2048, + "for (i = 0; i < 64; i++)\n if (buf[i]_ != (": 2049, + " &= 0x_3F": 2050, + " &= 0x3F_C": 2051, + "))) ^ (_*((vtype *) (&": 2052, + "))) ^ (*((vtype *) (&_k": 2053, + ")))_, (": 2054, + "vtype_ a": 2055, + "))_) + (": 2056, + ") * _j": 2057, + "0_ + (": 2058, + "!_= ": 2059, + "con_te": 2060, + "int _i": 2061, + "node_ *": 2062, + " = 0; _c2": 2063, + "f_lag": 2064, + "int_)": 2065, + "1_] = ": 2066, + "for (c2_ = 0; c2": 2067, + "k_ + (-1))) ? ((16 * c2) + 15) : (n": 2068, + "k + (-1))) ? ((16 * c2) + 15) : (n_k": 2069, + "__rows": 2070, + "--_--": 2071, + "for (i = 0; i <_= ": 2072, + "d_a": 2073, + ", _m": 2074, + "conte_nt": 2075, + "_b_ytes": 2076, + "[k_], ": 2077, + "[_%d": 2078, + "[i][_ind": 2079, + "[i + 1][_ind": 2080, + "co_ord": 2081, + " == _'": 2082, + "for_cing": 2083, + "SI_Z": 2084, + "SIZ_E": 2085, + "z_ * ": 2086, + "v_a": 2087, + "for (i = 0; i < n_; i++)\n ": 2088, + "our_ce": 2089, + "ve_ri": 2090, + "s[_v": 2091, + "up_date": 2092, + "D_F": 2093, + "][_(": 2094, + " + (_jj * ": 2095, + " = 0_;\n ": 2096, + "[i]_, ": 2097, + "c_8": 2098, + "sk_ip": 2099, + "R_0": 2100, + " _&&": 2101, + ")) * (1 * 100))))_) + i": 2102, + "j_tr": 2103, + "p_c": 2104, + "u_te": 2105, + "L_0": 2106, + "di_mension": 2107, + "jtr__sha": 2108, + "j_ + (-1))) ? ((16 * c1) + 15) : (n": 2109, + "j + (-1))) ? ((16 * c1) + 15) : (n_j": 2110, + ", _double *": 2111, + "u_2": 2112, + " <_ ((": 2113, + "iti_es": 2114, + "c_s": 2115, + "N_eighbor": 2116, + "++)\n {\n _for (c3 = 16 * c1": 2117, + "min__": 2118, + "[i]_;\n ": 2119, + "st_ar": 2120, + "com_m": 2121, + "if (i_ == ": 2122, + "lock_(&": 2123, + "._real": 2124, + "skip__bytes": 2125, + "ad_j": 2126, + "for (i = 0; i < 20_; ++i)\n{\n ": 2127, + "__M": 2128, + ";\n _#pragma ": 2129, + "st_ate": 2130, + "m_0": 2131, + "for (i = 0; i < _size": 2132, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm_ + (-1)) / 16))": 2133, + " - 1_][i2": 2134, + "a_2": 2135, + ") _&": 2136, + " < 5_; m": 2137, + " * _u": 2138, + " + _j": 2139, + ".i_mag": 2140, + "private._d_": 2141, + "ave_ra": 2142, + "v_[": 2143, + "s_in": 2144, + "omp parallel for reduction(+: _l": 2145, + "omp parallel for default_(shared": 2146, + "[col_]": 2147, + "[i_g": 2148, + "dia_g": 2149, + "C_L": 2150, + "or _|": 2151, + "g_h": 2152, + " +_ p": 2153, + ");\n}\n\n_void ": 2154, + "; _row": 2155, + "][_m": 2156, + "c_mp": 2157, + "[i3_ - 1][i2": 2158, + "))_;\n}\n": 2159, + "X_[": 2160, + " private_(": 2161, + " * _c": 2162, + "m_1]": 2163, + "gr->_vl": 2164, + "b_ = ": 2165, + "][4_]": 2166, + "foo_(": 2167, + "rand(_) %": 2168, + "la_yer": 2169, + "p_1]": 2170, + "for (_index": 2171, + "__temp": 2172, + "i_mag": 2173, + "2048_ + 1)": 2174, + ")_\n {\n ": 2175, + "a_ux": 2176, + "pow(_dt": 2177, + " = 0; _index": 2178, + "; _index": 2179, + "exclusiv_bit_or_ = ": 2180, + "dpt_ *= ": 2181, + "dpt *= _dt": 2182, + "C_ities": 2183, + "logic_and_ = ": 2184, + "logic_and = _logic_and": 2185, + "logic_and = logic_and_ &&": 2186, + "bit_and_ = ": 2187, + "bit_and = _bit_and": 2188, + "bit_and = bit_and_ &": 2189, + "logics[i]_ = 1": 2190, + "logic_or_ = ": 2191, + "logic_or = _logic_": 2192, + "logic_or = logic__or ": 2193, + "logic_or = logic_or _||": 2194, + "bit_or_ = ": 2195, + "bit_or = _bit_": 2196, + "bit_or = bit__or |": 2197, + " |_ x": 2198, + " * _r": 2199, + "[i_ - 1]": 2200, + "ex_p": 2201, + "c__": 2202, + "x_1": 2203, + ") *_ (((": 2204, + "))_\n {\n ": 2205, + "se_q": 2206, + "for (index_ = 0; index": 2207, + "^_:": 2208, + ";\n _if (": 2209, + "c_ore": 2210, + "curre_nt_": 2211, + " + (N_CELL_ENTRIES * ((_0 + (": 2212, + " + (N_CELL_ENTRIES * ((0 + (_0 * (1 * 100": 2213, + "orde_r": 2214, + " %d_\\n\", ": 2215, + "pa_geRank": 2216, + "|_:": 2217, + "ti_tion": 2218, + "][0]_))), (": 2219, + "_ps_((": 2220, + " *) malloc_(": 2221, + ",_b": 2222, + " _with ": 2223, + "fil_ter": 2224, + "__l": 2225, + "1_f": 2226, + "exclusiv_bit_or = _exclusiv_bit_or": 2227, + "exclusiv_bit_or = exclusiv_bit_or_ ^": 2228, + "^:_exclusiv_bit_or": 2229, + "ce_ss": 2230, + "&&_:": 2231, + "&&:_logic_and": 2232, + "; ++j_)\n {\n ": 2233, + "t_ + k": 2234, + "p_article": 2235, + "4_.0 * ": 2236, + "e_y": 2237, + "omp parallel for reduction(+:_sum": 2238, + "[i_1]": 2239, + "e_w": 2240, + "a_1": 2241, + "fa_c1": 2242, + "unsigned char_ ": 2243, + "for (int i_ = 1; i": 2244, + "T_emp": 2245, + "-_:": 2246, + "Cou_nt": 2247, + "th_e": 2248, + "16 * c1) + 15) < (n_i + (-1))) ? ((16 * c1) + 15) : (ni": 2249, + "for (j = 1; j_ < (": 2250, + "Dist_ance": 2251, + "to_ ": 2252, + "&_:": 2253, + "AN_D": 2254, + "[_b": 2255, + "lef_t": 2256, + "&:_bit_and": 2257, + "||_:": 2258, + "||:_logic_or": 2259, + "|:_bit_or": 2260, + " /_ 1": 2261, + "i_ve": 2262, + "li_st": 2263, + "n__pro": 2264, + " _AND": 2265, + "vi_si": 2266, + " _0x": 2267, + "y = 0; _y < ": 2268, + "un_c": 2269, + "[(i * _2048": 2270, + "; i++)\n{\n _if (!": 2271, + "know_n_pro": 2272, + "for (i = 0; i < 20_; ++i)\n {\n ": 2273, + ")\n {\n result++;\n fprintf(stderr, \"Error in _logic": 2274, + " AND_ par": 2275, + ")\n {\n result++;\n fprintf(stderr, \"Error in _BIT": 2276, + "ker_nel": 2277, + "4_.0": 2278, + "s_se": 2279, + " + (-1_)) <": 2280, + " + (-1_)) :": 2281, + "[_row": 2282, + "_t_ *": 2283, + ") + k_] * ": 2284, + "U_L": 2285, + "for (int i = 0; i < _N": 2286, + "3_7": 2287, + " + (jj * _params.nx": 2288, + "10_10": 2289, + "a_[i] = ": 2290, + "#pragma omp _ordered": 2291, + "clu_ster": 2292, + "u[_m": 2293, + "1000_ * (": 2294, + "1000 * (_1000": 2295, + "1000 * (1000_ + 1)) / ": 2296, + "j_, ": 2297, + ") + _2": 2298, + "2_7": 2299, + "A_, ": 2300, + " < _count": 2301, + "A + i_) + k": 2302, + "[i][k_] * ": 2303, + "for (_c1": 2304, + "for (_size_t ": 2305, + "; j_j": 2306, + ") + 1_)": 2307, + "1_3": 2308, + "lob_al": 2309, + "runtime_)": 2310, + "ex_it(": 2311, + "for (i = 0; i < 1_0": 2312, + "s[j]_.": 2313, + "(x, y_, z": 2314, + "d_s": 2315, + "= (_*((": 2316, + "*((_C": 2317, + "][i][j][k] = _lhs[": 2318, + "ge_st": 2319, + ") +_ p": 2320, + "4_7": 2321, + " = 1_.": 2322, + "_c_ell": 2323, + "Val_ue": 2324, + "p_ng": 2325, + "di_gest": 2326, + " /_= ": 2327, + "j_ + ": 2328, + "id_ed": 2329, + "((_sizeof(": 2330, + " * _z": 2331, + "c_9": 2332, + ") -_ ((": 2333, + " + _2]": 2334, + ") /_ (": 2335, + "m_j": 2336, + " = ((_double) ": 2337, + ") + _n": 2338, + "word_0": 2339, + ");\n }\n\n _}\n\n}\n": 2340, + "ou_t_": 2341, + "[index_]": 2342, + "8_4": 2343, + "la_m": 2344, + ")\n _p[": 2345, + "grid_->": 2346, + "if ((_i": 2347, + "de_r": 2348, + ")) _||": 2349, + "s_ub": 2350, + ", i_, j": 2351, + " < _4": 2352, + ") + _x": 2353, + ");\n _b": 2354, + " = 1_; ": 2355, + " <= (grid_points[_1]": 2356, + "u_blic.": 2357, + "if_ace": 2358, + " (&_buf[": 2359, + "c1_ <=": 2360, + "in__": 2361, + "in_fo": 2362, + "[index_], ": 2363, + "] * nu_;\n u[": 2364, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16_)) <": 2365, + " + (-1)) / 16))) ? ((((n_j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16": 2366, + " + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16_)) :": 2367, + " (n_i": 2368, + "at_ure": 2369, + " <= (grid_points[_2]": 2370, + "h_z": 2371, + "s_or": 2372, + "][0][_0][": 2373, + "c_[iel": 2374, + "[_(((": 2375, + ", _)": 2376, + "inpu_t->": 2377, + "j_o": 2378, + "O_L": 2379, + "] += _u[": 2380, + "v_b": 2381, + " = 1_;\n ": 2382, + "se_nd": 2383, + "N_Y": 2384, + "i_, int ": 2385, + "[i_e": 2386, + "2_D": 2387, + "P_oint": 2388, + "de_v": 2389, + "[(_int) ": 2390, + "; c2_++)\n {\n ": 2391, + "x_ * ": 2392, + "5_]": 2393, + "][i][j][k]_ - (": 2394, + " == 1_)\n {\n ": 2395, + "; j++)\n {\n _if (": 2396, + "._z": 2397, + "for (m = 0; m_ < 5; m": 2398, + "C_om": 2399, + "2_6": 2400, + "p_ass": 2401, + " + _r": 2402, + "][j][k_]": 2403, + "st_ore": 2404, + "t_z": 2405, + "__SIZE": 2406, + "ter_ ": 2407, + "_bu_ff": 2408, + "0.0_1": 2409, + "value_[col": 2410, + " <= _n": 2411, + "R_E": 2412, + "for (i = 0; i < 1_024": 2413, + ") +_= (*((": 2414, + "double _x": 2415, + "n_er": 2416, + ")_\n ": 2417, + "a_se": 2418, + " = ((_-": 2419, + "ac_k": 2420, + "4_ = ": 2421, + "dE_o": 2422, + " <= (((_(((n": 2423, + " + (-1))); c4++)\n {\n _A[c3][c4] = (((double) c3) * c4) / ni": 2424, + ") _num_threads(": 2425, + "t_3": 2426, + ") + k_]": 2427, + "Com_m": 2428, + "di_r": 2429, + "se_r": 2430, + "veri_f": 2431, + ") +_ (((": 2432, + "))_)\n {\n ": 2433, + "._t": 2434, + "((((_(": 2435, + "]_ + (": 2436, + "rhs[_k": 2437, + "key__": 2438, + "for_ce": 2439, + "*_b": 2440, + ", _mm_mul_ps(_a": 2441, + "); c2_++)\n {\n for (c3 = 16 * c1": 2442, + ";\n }\n\n }\n\n _for (c3 = ": 2443, + "fa_il": 2444, + "for (int i = 0; i < n_; i++)\n{\n ": 2445, + "E_T": 2446, + "q_u": 2447, + "Ma_sk": 2448, + "g__": 2449, + "double_) (": 2450, + "\n_\n": 2451, + ";\n}\n\n\n_int ": 2452, + "ma_c": 2453, + " | _tmp": 2454, + " * _j": 2455, + "er_tex": 2456, + "for (j = 0; j < _n": 2457, + "00_; i++)\n{\n ": 2458, + ") += (*((_A + i) + k": 2459, + "i_ = ": 2460, + "}\n else_\n {\n ": 2461, + "5_ - 1": 2462, + " <= _4": 2463, + "++;\n }\n\n}\n\n_int ": 2464, + "he_ad": 2465, + "_mm256__": 2466, + "tmp_1": 2467, + "de_nsi": 2468, + " * 16) < 0) ? (-((-_nj": 2469, + " * 16) < 0) ? (-((-nj_) / 16)) : ((16 < 0) ? ((((-": 2470, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-_nj": 2471, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj_) + (-16)) - 1) / (-16)) : (((": 2472, + " * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((_nj": 2473, + ");\n _if (": 2474, + ";\n _}\n\n ": 2475, + "o_t": 2476, + "; k_++)\n {\n ": 2477, + ";\n _printf(\"": 2478, + ") / _8": 2479, + "for (index = 0; index_ < count": 2480, + ") + j]_ += ": 2481, + "h_i": 2482, + "++)\n{\n _for (": 2483, + "sw_ap": 2484, + "*((C_ + i) + ": 2485, + "_b_ar": 2486, + "h_igh": 2487, + "._.": 2488, + "array_[x": 2489, + "comp_ute": 2490, + "densi_ty": 2491, + "++)_\n ": 2492, + "co_un": 2493, + ", 0_, 0": 2494, + ") + _z": 2495, + "n_a": 2496, + "Grid_[(": 2497, + "s_ource": 2498, + "1 - _val2": 2499, + "[(int) _fi": 2500, + "}\n else_\n ": 2501, + ", \"_%": 2502, + " ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk_ + (-1)) / 16))": 2503, + ") - (_tmp1 * ": 2504, + ") - (tmp1 * _njac": 2505, + "ue_[m": 2506, + "_p_ad": 2507, + "for (index = 0; index < count_; index": 2508, + "__of": 2509, + "cmp_(": 2510, + "][i][j][k]_;\n ": 2511, + "for (i = 0; i < _len": 2512, + "=_%f": 2513, + "edge_s_": 2514, + "1_)": 2515, + "is__larger": 2516, + "ar_d": 2517, + "p_str->": 2518, + "ic_e": 2519, + ") * _n": 2520, + "at_om": 2521, + "crypt__out": 2522, + "ar_y": 2523, + "; k_++)\n{\n ": 2524, + " * _d": 2525, + "m + (-1))); c4++)\n {\n _C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 2526, + "00_F": 2527, + "si_d": 2528, + "for (j = 0; j < _4": 2529, + "))\n {\n _num_": 2530, + "))\n {\n num__failed": 2531, + "))\n {\n num_failed_++;\n }\n\n}\n\nint ": 2532, + "D_at": 2533, + "Dat_at": 2534, + "Datat_ype": 2535, + "c_k": 2536, + ") +_ (-1": 2537, + "else_\n ": 2538, + "u_[(": 2539, + "for (i = 0; i < 20_; i++)\n{\n if (!": 2540, + " = (_1000 * (1000 + 1)) / ": 2541, + " = (1000 * (1000 + 1)) / _2;\n ": 2542, + ")\n _for (i = 1; i <= 1000": 2543, + "S_core": 2544, + "test__rank": 2545, + "****_****": 2546, + "\"_, &": 2547, + "o_b": 2548, + "4_c": 2549, + "A__": 2550, + "(int _x": 2551, + "omp target teams _distribute parallel for simd ": 2552, + "P_ro": 2553, + "reg_is": 2554, + " = _f": 2555, + "; i++)_\n ": 2556, + "ic_ation": 2557, + " (n_m": 2558, + "][1_] = ": 2559, + "[i]_ - ": 2560, + "j_, int ": 2561, + ".0f_ * ": 2562, + ";\n _float ": 2563, + "A_[i][j]": 2564, + "a_[i] = i": 2565, + "a_nt": 2566, + "->n__bar": 2567, + ", _sizeof(": 2568, + "d_f": 2569, + "_x_x": 2570, + "; ++k_)\n {\n ": 2571, + "][_0] = ": 2572, + "regis_ter ": 2573, + "[_0] = ": 2574, + "Datatype_) 0x": 2575, + "Datatype) 0x_4c": 2576, + "Datatype) 0x4c_000": 2577, + ",j_,k": 2578, + "for (x = 0; _x < ": 2579, + "; j++)\n _for (i = j": 2580, + "omp parallel for reduction(+: l_) collapse(": 2581, + "8_6": 2582, + "er_ature": 2583, + " +_ (n": 2584, + " + (-1)) / 16_)) <": 2585, + " + (-1)) / 16_)) :": 2586, + "B_B": 2587, + "7_B": 2588, + "0) ?_ (": 2589, + "k_ + 1": 2590, + ", (MPI__Datatype) 0x4c000": 2591, + "public._in2": 2592, + "co_nd": 2593, + "graph->_num_vertices": 2594, + ");\n}\n\n_\n": 2595, + " = 0._5": 2596, + "; ++_i": 2597, + "nex_t_": 2598, + " &_ x": 2599, + "id_]": 2600, + "_c_pu": 2601, + "++_;\n": 2602, + "L_o": 2603, + "int_e": 2604, + "ere_nce": 2605, + "sum = sum_ + (": 2606, + " < _3": 2607, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl_ + (-1)) / 16))": 2608, + "g_o": 2609, + ", _d": 2610, + "1__": 2611, + "ff_ff": 2612, + "R_e": 2613, + "k_ + ": 2614, + "l + (-1))) ? ((16 * c2) + 15) : (nl_ + (-1))); c4++)\n {\n ": 2615, + " + (-1))); c4++)\n {\n _B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 2616, + "][0]))), (_*((vtype *) (&": 2617, + "#pragma _omp parallel for private (": 2618, + " = _-1": 2619, + ");\n }\n\n _if (": 2620, + "1_00": 2621, + "x_2": 2622, + "y_m": 2623, + "v_ < ": 2624, + "star_t_": 2625, + "a_[i][j]": 2626, + "vassign_[iel][": 2627, + "Comm_) 0x": 2628, + "Comm) 0x_44": 2629, + "Comm) 0x44_000000": 2630, + "_mm__load": 2631, + "__X": 2632, + "OMP__y": 2633, + "OMP_y_Max": 2634, + ") + j]_ = (((": 2635, + "; c4_ <= ((((((": 2636, + "const _int ": 2637, + ") < _0.01": 2638, + "b_[i][j]": 2639, + "b_k": 2640, + "p_x": 2641, + "for (int j = 0; j_ < n": 2642, + ");\n _return ": 2643, + "omp parallel for schedule(_static": 2644, + "O_ff": 2645, + "int_er": 2646, + "m_s": 2647, + "tmp_2) * ": 2648, + "d_z": 2649, + "512__": 2650, + ")) _= ": 2651, + "ra_di": 2652, + " * ((_i": 2653, + "float_ p": 2654, + " + 1_][k": 2655, + " <= (grid_points[_0]": 2656, + "sum_a": 2657, + "[i]_;\n": 2658, + "n_ = ": 2659, + "uint_64": 2660, + ";\n _}\n\n ": 2661, + "set__lock(&": 2662, + ", (MPI__Comm) 0x44000000": 2663, + "c_ = ": 2664, + " & _3": 2665, + "-_7": 2666, + "][i_] = ": 2667, + "at_(&": 2668, + "c_7": 2669, + "logics[i]_ = 0;\n}\n": 2670, + " > _0": 2671, + " _:": 2672, + "N_X": 2673, + "'_:": 2674, + "row_ptr": 2675, + "[k_] = ": 2676, + "printf(\"_\\n\");\n}\n": 2677, + "v_ = 0; ": 2678, + " - 2_); k": 2679, + " =_ (-": 2680, + ") /_ 1": 2681, + "__con": 2682, + "i_ + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n": 2683, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(n_i": 2684, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni_ + (-1))) + 16) + 1) / 16)) : (-((((-(n": 2685, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(n_i": 2686, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni_ + (-1))) + 16) - 1) / 16))) : ((": 2687, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((_ni": 2688, + "ac_ti": 2689, + "malloc_(": 2690, + "ind_ + ": 2691, + "ta_il": 2692, + "l + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n _D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 2693, + " << (32_ - 1": 2694, + "s[i]_ = ": 2695, + "; _v": 2696, + "um__": 2697, + " + (_b": 2698, + " - _first": 2699, + "an_g": 2700, + "\\n\"_);\n ": 2701, + "B_o": 2702, + "s[_(": 2703, + "i_;\n ": 2704, + "cur_r_": 2705, + "stri_de": 2706, + "uint32__t": 2707, + "lhs[n_ + 2": 2708, + " - (_lhs[n": 2709, + ")) && (_i": 2710, + "1_);\n ": 2711, + "ds_sp": 2712, + ") == _2": 2713, + "(&ctx_, ": 2714, + "case _'": 2715, + "ri_te": 2716, + "ele_m_": 2717, + "IN_T": 2718, + "[_c1][c2] = (((double) c1) * (c2": 2719, + "))) ^ (*((vtype *) (&k_[": 2720, + "vtype_ ": 2721, + " = 0; _row": 2722, + " - _x": 2723, + "omp parallel for private(_c2": 2724, + "_m_atrix": 2725, + "ex_t": 2726, + " * (_*((": 2727, + " ((_temp": 2728, + "for (j = 1; j_ <= ((": 2729, + "elem__at(&": 2730, + " + _2)": 2731, + "j_ = 0; j": 2732, + " = i_ + 1": 2733, + " >= _0": 2734, + "[%d_]": 2735, + "\\n\"_);\n ": 2736, + "_m_o": 2737, + "[k_][j][i": 2738, + "s_na": 2739, + "sna_ke": 2740, + "][i1_ - 1]": 2741, + ", int _y": 2742, + "ce_nter": 2743, + " + 1_][i2": 2744, + "i_ < ": 2745, + "));\n _*((C + i) + ": 2746, + "for (i = 1; i_ <= (grid_points[0]": 2747, + "for (i = 1; i <= (grid_points[0]_ - 2)": 2748, + "; _c1": 2749, + "char_ ": 2750, + "); _c4": 2751, + "][i_i": 2752, + ") + ((_-1": 2753, + "0_FF": 2754, + " - 1)_; i++)\n{\n ": 2755, + "for (i_1": 2756, + "Bu_f": 2757, + "rec_tion": 2758, + ")) + _i": 2759, + ")_;\n ": 2760, + ";\n _if (": 2761, + " *_out": 2762, + "src_Grid[(": 2763, + "li_ve": 2764, + "[_], ": 2765, + " +_ (((": 2766, + "[i3][i2_][i1]": 2767, + ", i_, ": 2768, + "\\n\", i_, ": 2769, + ")\n{\n int _sum": 2770, + ") - 1) / 16))) :_ (((": 2771, + "[i]_ += ": 2772, + "v = 0; _v < ": 2773, + "m_er": 2774, + "[v_]": 2775, + " (n_l": 2776, + "me_nt_": 2777, + "s_o": 2778, + "rand() %_ 1": 2779, + " <= (grid_points[1]_ - 2)": 2780, + "m_ + (-1))) ? ((16 * c2) + 15) : (n": 2781, + "coun_ter": 2782, + "][_x": 2783, + "f_ra": 2784, + "t_steps": 2785, + "long _long ": 2786, + "row_ = 0; row": 2787, + ") == 2_) && (i": 2788, + " <= (grid_points[2]_ - 2); k": 2789, + ";\n _sum = 0;\n ": 2790, + "2] = _1;\n ": 2791, + "9_7": 2792, + "; _l": 2793, + "6_9": 2794, + "omp _distribute parallel for ": 2795, + "com_z": 2796, + "}\n_\n ": 2797, + "[ie_][": 2798, + ";\n u_2 = ": 2799, + "F_4": 2800, + "))_;\n}\n\n": 2801, + ") + _3": 2802, + "for (i = 0; i < N_; i++)\n ": 2803, + "v_2[i]": 2804, + "to_t_": 2805, + ") *_ 1": 2806, + " + (_2 * ": 2807, + "[i + 1_][j]": 2808, + "que_ue": 2809, + "tmp__vec": 2810, + "33_33": 2811, + ")\n p[_2] = ": 2812, + ")\n{\n _if ((": 2813, + " =_= (": 2814, + "ge_rs": 2815, + "(i_ & 3": 2816, + "(i & 3_) == 2) && (i": 2817, + "(i & 3) == 2) && (i_ >= ": 2818, + "(i & 3) == 2) && (i >= _18": 2819, + "(i & 3) == 2) && (i >= 18_)) && (i": 2820, + ")) ?_ (((": 2821, + "for (j = 1; j_ <= (grid_points[1] - 2)": 2822, + "[i][j_ - 1]": 2823, + "test_rank__array": 2824, + "nj_ * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj": 2825, + ";\n u_1 = ": 2826, + ";\n u3_ = ": 2827, + ";\n u3_ += ": 2828, + "vtype_ *out": 2829, + " = (_*out": 2830, + ") ^_ x": 2831, + "diff_ = ": 2832, + " !_= (-1": 2833, + "round_ing_": 2834, + "rounding__error": 2835, + "known_pro_duct": 2836, + "inte_gers": 2837, + "integers_: Result was": 2838, + "integers: Result was_ %d ": 2839, + "integers: Result was %d _instead of": 2840, + "t 1_.": 2841, + "t 1._\\n\");\n }\n\n ": 2842, + "t _2.": 2843, + "t 2._\\n\");\n }\n\n ": 2844, + "logics[i]_ = 0": 2845, + "y_1": 2846, + "i_j": 2847, + "edges__array": 2848, + "for (k = 1; k_ <= (grid_points[2] - 2); k": 2849, + ";\n _double ": 2850, + "co_e": 2851, + "; i_ <= ": 2852, + "d_d": 2853, + "te_d_": 2854, + " ^_ ": 2855, + " & _0x": 2856, + ";\n int _known_sum": 2857, + "logics[i] = 0_;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2858, + "2] = 1;\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2859, + "x_ * x": 2860, + "an_s": 2861, + ")) + _8": 2862, + "lhs[_j": 2863, + "A_live": 2864, + " =_= (-1": 2865, + "for (i = 0; i < 1000; i++)\n{\n _logics[i] = 0;\n}\n": 2866, + "[_m]": 2867, + "buf_[1": 2868, + " +_= (((": 2869, + "for (i = 0; i < 1000; i++)\n {\n _logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2870, + " = 0;\n _logics[1000 / ": 2871, + " = 0;\n logics[1000 / _2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 2872, + "j__temp": 2873, + "bk_df": 2874, + ";\n _D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 2875, + " >_= (((": 2876, + ":_ %": 2877, + ";\n\n_}\n\n": 2878, + "x_ = (": 2879, + "A_[(i * N": 2880, + "omp parallel for collapse(_2)": 2881, + "D_iff": 2882, + "s[_k": 2883, + "S_->": 2884, + "[i]_;\n ": 2885, + "return_ (": 2886, + "uint_8": 2887, + ") schedule(_static,": 2888, + " of_ ": 2889, + "bkdf_2": 2890, + "p_->": 2891, + "n_ame": 2892, + "t_Mask": 2893, + "sje_[ntemp": 2894, + "[ie][_iface": 2895, + "_mm__store": 2896, + "k_ = ": 2897, + "__sum": 2898, + ") &_ 0x": 2899, + "i_ + 1": 2900, + ";\n _else\n ": 2901, + "5_6": 2902, + " + (-1))) < (nm_ + (-1))) ? ((((": 2903, + "nm_ * 16) < 0) ? (-((-": 2904, + "nm * 16) < 0) ? (-((-_nm": 2905, + "nm * 16) < 0) ? (-((-nm_) / 16)) : ((16 < 0) ? ((((-": 2906, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-_nm": 2907, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm_) + (-16)) - 1) / (-16)) : (((": 2908, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm) + (-16)) - 1) / (-16)) : (((_nm": 2909, + "nm * 16) < 0) ? (-((-nm) / 16)) : ((16 < 0) ? ((((-nm) + (-16)) - 1) / (-16)) : (((nm_ + 16) - 1) / 16))": 2910, + " = x_00": 2911, + ";\n _*out": 2912, + "A_9": 2913, + "r_2": 2914, + "rs_d": 2915, + "1.0_ - (": 2916, + "__new": 2917, + "node_->": 2918, + "2000_ - 1": 2919, + "2_3 * ": 2920, + "data_[(i * (": 2921, + "element_s": 2922, + "n_2": 2923, + "ci_ph": 2924, + "; i_i": 2925, + "inline _static void ": 2926, + "cb_c": 2927, + "avera_ge": 2928, + "[((_i": 2929, + "[i_d": 2930, + "[i3_ + 1][i2": 2931, + "or_ig": 2932, + "]_;\n": 2933, + "grid_[": 2934, + "di_rection": 2935, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100_))) + ((": 2936, + ") _num_threads": 2937, + "y_load": 2938, + " + (-1))_; c2++)\n {\n ": 2939, + "3_, ": 2940, + "omp parallel for default(shared_) private(i": 2941, + "for (i = 0; i < N_; i++)\n{\n ": 2942, + "[i][_0]": 2943, + ";_ (": 2944, + "k_1": 2945, + "u_ = ": 2946, + "[i - 1_][j]": 2947, + "->_content": 2948, + "}\n\n }\n\n _}\n\n}\n\n": 2949, + "G_->": 2950, + "c_and": 2951, + "8_ * ((": 2952, + "8 * ((_2000 - 1": 2953, + "8 * ((2000 - 1_) / 8": 2954, + "8 * ((2000 - 1) / 8_)) + 8": 2955, + " * 16) < 0) ? (-((-_nk": 2956, + " * 16) < 0) ? (-((-nk_) / 16)) : ((16 < 0) ? ((((-": 2957, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-_nk": 2958, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk_) + (-16)) - 1) / (-16)) : (((": 2959, + " * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((_nk": 2960, + "pa_yload": 2961, + "ele_m": 2962, + "s_ym": 2963, + "*((_vtype": 2964, + "i_v": 2965, + "_p_o": 2966, + " !_= ((": 2967, + "for (k = 0; k_ < 5; k": 2968, + "[(i * 2048_) + j]": 2969, + "str_len(": 2970, + " * (_j": 2971, + "C_5": 2972, + "verif_ication": 2973, + "lo_se": 2974, + "for (j = 1; j <= ((_last": 2975, + "__re": 2976, + "for (_v = 0; v < ": 2977, + "column_s": 2978, + "++)_\n {\n ": 2979, + "j_3": 2980, + " *_ 16": 2981, + "; i++)\n{\n for (j = 0; j < _N": 2982, + "lhs[n_ + 4": 2983, + ";\n vtype x_00": 2984, + " << (32_ - ": 2985, + "[i_ + ": 2986, + "; v_++)\n{\n ": 2987, + "re_sid": 2988, + "._c": 2989, + "g_b": 2990, + "rand(_) % ": 2991, + ") firstprivate_ (": 2992, + "E_D": 2993, + "fin_al": 2994, + "outpu_t_": 2995, + "acti_ve": 2996, + "ge_n": 2997, + "][_c": 2998, + "dt_ * ": 2999, + "h_al": 3000, + "b_v": 3001, + "pc_mor": 3002, + "0.0_f": 3003, + "j_ < ": 3004, + "di_sp": 3005, + "p_[i] = ": 3006, + "omp parallel for_\n ": 3007, + "jo_h": 3008, + "._5": 3009, + "c1_ >= (((": 3010, + "L_2": 3011, + "));\n _}\n\n}\n\n": 3012, + ") + _r": 3013, + " + (-1))) < (n_k": 3014, + " + (-1))) : (n_k": 3015, + ")) _^": 3016, + ";\n }\n\n }\n\n }\n\n }\n\n _if ((": 3017, + "; j_2": 3018, + "[i_1": 3019, + "3_.0": 3020, + "b_ase": 3021, + "h_h": 3022, + "1024_ + 1)": 3023, + " = (_int": 3024, + "float p_er": 3025, + "double _val": 3026, + "sh_if": 3027, + "(_int *": 3028, + "for (i = 1; i <= 1000_; i++)\n{\n ": 3029, + "fac1_ * ": 3030, + ") + j] = (((_DATA_TYPE) i": 3031, + "max_ = ": 3032, + "]_ = ((": 3033, + "Alive_Neighbor": 3034, + "St_art": 3035, + "ri_gh": 3036, + "1, _double ": 3037, + "0_ = ": 3038, + "x_[": 3039, + "c_)": 3040, + ".t_v_": 3041, + "_col_s": 3042, + "3_ = ": 3043, + "i_r": 3044, + "float per_centDiff(": 3045, + "float percentDiff(_double val": 3046, + "float percentDiff(double val_1, double ": 3047, + "float percentDiff(double val1, double _val2": 3048, + "lhs_[i][j][k": 3049, + "s_up": 3050, + ");\n _double ": 3051, + "te_am": 3052, + " = 0.0_;\n ": 3053, + "m_id": 3054, + "t_mor": 3055, + " + 1_)) + j": 3056, + " & _m": 3057, + "; i++)\n{\n _for (int j = 0; j < ": 3058, + "ta_g": 3059, + ")) -_ ": 3060, + "in_al": 3061, + "s[_(i": 3062, + "num_AliveNeighbor": 3063, + ";\n\n _}\n\n}\n": 3064, + "per_centDiff(": 3065, + ")))_;\n}\n": 3066, + "po_s_": 3067, + " = _mm_load1__ps(": 3068, + "][i][j_1": 3069, + "Y_[": 3070, + ") + j]_;\n }\n\n }\n\n}\n": 3071, + ") *_ p": 3072, + "Num_ber": 3073, + "a_x": 3074, + "temp__": 3075, + "memcp_y(": 3076, + ")_; i++)\n{\n ": 3077, + "; _n": 3078, + " + _u": 3079, + "m__temp": 3080, + ")\n{\n _if (": 3081, + " + _i)": 3082, + ") _!= ": 3083, + " * (sizeof(_int": 3084, + "n_s": 3085, + "la_st_": 3086, + "joh_n_": 3087, + "_m_in": 3088, + "nk_ * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((nk": 3089, + "a_ = ": 3090, + "z_z": 3091, + "time_(": 3092, + "p_la": 3093, + "7_29": 3094, + "op_ad": 3095, + "][k_][j][i]": 3096, + "[(i * _512": 3097, + ";\n _ ": 3098, + " <<_ 1": 3099, + "s_[i][j][k": 3100, + "2_) + 1": 3101, + "al_ive": 3102, + "2_) + (": 3103, + "O_f": 3104, + "f_rom": 3105, + "sc_al": 3106, + "for (i = 0; i < _num_": 3107, + "0_, ": 3108, + "i_;\n}\n": 3109, + "c_ = c": 3110, + "])_;\n}\n": 3111, + "Se_t": 3112, + "for (i = 0; i < 1_0000": 3113, + "nor_m": 3114, + "v1_[i] * ": 3115, + "v1[i] * _v2[i]": 3116, + "}_\n ": 3117, + " == 0_)\n {\n ": 3118, + "row_str": 3119, + " = i_;\n ": 3120, + "_g_lobal": 3121, + "de_n": 3122, + "F_B": 3123, + "4_) ": 3124, + ";_ (&buf[": 3125, + " _\\n\", ": 3126, + "7_F": 3127, + ")_) + 1": 3128, + "mage_->content": 3129, + "arg_v": 3130, + ") - (_*": 3131, + "B_3": 3132, + "u[_((2 * i": 3133, + "u[((2 * i_3": 3134, + ") - 1][((2 * i_2": 3135, + ") - 1][((2 * i_1": 3136, + ",_ 16": 3137, + "k_ + (-1))) ? ((16 * c1) + 15) : (n": 3138, + "k + (-1))) ? ((16 * c1) + 15) : (n_k": 3139, + "m + (-1))) ? ((16 * c2) + 15) : (n_m + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 3140, + "2 * i_3": 3141, + "][_2 * i": 3142, + "][(_2 * i": 3143, + ")) +_ (-": 3144, + ";\n tmp_ = v": 3145, + "))_) - (": 3146, + "\\_t ": 3147, + ", int y_, int ": 3148, + ") + j_j]": 3149, + ")) ||_ (": 3150, + "c00_ = _mm_add_ps(": 3151, + "c00 = _mm_add_ps(_c00": 3152, + "40_96": 3153, + "Temp_erature": 3154, + "omp_get__num_threads(": 3155, + "acc_um": 3156, + "sa_ge": 3157, + "p_le": 3158, + " - first_col": 3159, + "RE_AD": 3160, + "j_j": 3161, + "se_t(": 3162, + "the_ ": 3163, + ", _cur_salt->": 3164, + "H_READ": 3165, + "[1_] = ": 3166, + "0_'": 3167, + "51_2)": 3168, + "__table": 3169, + "D_im": 3170, + "s_cale": 3171, + " _is": 3172, + "[i][j_ + 1]": 3173, + "n_uc": 3174, + "9_4": 3175, + "j + (-1))) ? ((16 * c2) + 15) : (nj_ + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 3176, + "vassign_[iel": 3177, + ", i)_;\n}\n": 3178, + "__data": 3179, + "ph_i": 3180, + "for (int i_ = ": 3181, + " = _&": 3182, + "r_ = ": 3183, + "bucke_t_": 3184, + "me_s": 3185, + "rhs[k_][j][i": 3186, + "cell_s->": 3187, + "][1]_ * ": 3188, + ") * _c2": 3189, + "F_rom": 3190, + "payload_ *": 3191, + "en_er": 3192, + "i = 0; i_ < ": 3193, + "s_ + k": 3194, + "d_st": 3195, + ")\n{\n int i_;\n int j": 3196, + " < _0": 3197, + " = 0_;\n int ": 3198, + "ip_ad": 3199, + "temp_2": 3200, + ") + ((-1_) * n": 3201, + "return 1_00": 3202, + " = 0; i_1": 3203, + "A_X": 3204, + " = 0.0_;\n}\n": 3205, + "distribute_ parallel for": 3206, + "((((_((": 3207, + ") + (_j * ": 3208, + "e_[iel": 3209, + " + _z": 3210, + ", \"_%d": 3211, + ") _lastprivate": 3212, + "16_]": 3213, + "c = c_ + (b": 3214, + "))_\n ": 3215, + "for (j = 0; j < 4_; j++)\n for (i = j": 3216, + "; i++)\n _for (k = 0; k < 5; k": 3217, + "; i++)\n for (k = 0; k < 5; k_ += 2)\n l++;\n\n\n": 3218, + "2.0_) * ": 3219, + "))_\n {\n ": 3220, + "[i]_);\n ": 3221, + "5_, ": 3222, + "key__buff": 3223, + "0 * (1 * 100_)) * (1 * 100))))) + i": 3224, + "A[((_(i": 3225, + "2 * _c0": 3226, + " * 16) < 0) ? (-((-_nl": 3227, + " * 16) < 0) ? (-((-nl_) / 16)) : ((16 < 0) ? ((((-": 3228, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-_nl": 3229, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl_) + (-16)) - 1) / (-16)) : (((": 3230, + " * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((_nl": 3231, + "3_CC": 3232, + "5A_5A": 3233, + "return _0.0f": 3234, + " - 1); i_1": 3235, + "; i++)\n{\n _for (j = 0; j < 1": 3236, + "4_00": 3237, + "f_ind": 3238, + ") schedule(_static": 3239, + "0_ * ": 3240, + "e_ps": 3241, + " <= (_m": 3242, + "g->_N": 3243, + "(int x_, int y, int ": 3244, + "+_ : ": 3245, + "4_5": 3246, + "1.0_ + (": 3247, + "sym_mat": 3248, + "mean_[j]": 3249, + " += 1_)\n {\n ": 3250, + " +_= ((": 3251, + ") ?_ (nj": 3252, + ") ? (nj_) : (n": 3253, + "[i_ * ": 3254, + "[i]_ + (": 3255, + "L_ist": 3256, + "5_) * ": 3257, + "out_len": 3258, + "[j_][i]": 3259, + " - _3": 3260, + "[idx_[i]]": 3261, + "]_ == ": 3262, + "0._0000000": 3263, + "][j_ - 1]": 3264, + "nor_m_temp": 3265, + "sum_2": 3266, + "for (i = 0; i < _2048": 3267, + ")\n{\n return_ (((": 3268, + "wor_ld": 3269, + "if (_table": 3270, + "-_2) * ": 3271, + "vtype *) (&_(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 3272, + "return 0.0f_;\n }\n else\n {\n ": 3273, + "return 0.0f;\n }\n else\n {\n _return 100": 3274, + "return 0.0f;\n }\n else\n {\n return 100_.0f * ": 3275, + "return 0.0f;\n }\n else\n {\n return 100.0f * _absVal(": 3276, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(_absVal(val": 3277, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val_1 - val2": 3278, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2_) / ": 3279, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / _absVal(val": 3280, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val_1 + ": 3281, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + _0.0000000": 3282, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.0000000_1f": 3283, + "return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f_));\n }\n\n}\n\n": 3284, + ") + _c": 3285, + "(_double *": 3286, + " + (-1))) ?_ (((": 3287, + "matrix_->": 3288, + "m_ul": 3289, + "[i][j_ - 1": 3290, + ";\n _int ": 3291, + "for (col = 0; col < 95100; col_++)\n{\n ": 3292, + "col = col + 4_;\n}\n": 3293, + "IN_G": 3294, + "c_6": 3295, + "}\n\n_\n ": 3296, + "(int x, int y, int _z": 3297, + "known_sum_ = (1000 * (1000 + 1)) / 2;\n ": 3298, + ")\n for (i = 1; i <= 1000_; i++)\n {\n ": 3299, + "for (i = 0; i < 20; i++)\n{\n if (!_test_omp_parallel_for_": 3300, + "))\n {\n num_failed++;\n }\n\n}\n\nint _test_omp_parallel_for_": 3301, + "known_sum_ == ": 3302, + "known_sum == _sum": 3303, + "->n_b": 3304, + "p_i": 3305, + "mor__": 3306, + "P_o": 3307, + ")))) + (_0.0": 3308, + "new_e[iel": 3309, + " >> _6": 3310, + "for (col = 0; col < 95100; col_++)\n {\n ": 3311, + "col = col + 4_;\n }\n\n ": 3312, + "(x, y_)": 3313, + "; ++j_)\n{\n ": 3314, + "col_ - firstcol": 3315, + "col - firstcol_) + 1)": 3316, + ") + i_]": 3317, + "][i_ + 1": 3318, + "numAliveNeighbor_s++": 3319, + "g_a": 3320, + " ((((n_j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj": 3321, + "linear_(": 3322, + "for (i = 0; i < _5": 3323, + "to__": 3324, + "5_4": 3325, + "alloc_(": 3326, + ") >_ (((": 3327, + " + (-1))) < (n_l": 3328, + " + (-1))) : (n_l": 3329, + ";\n x_00": 3330, + "_of__": 3331, + ";\n\n _if (": 3332, + "u_ps(_s + k": 3333, + ";\n\n _if (": 3334, + "ciph_ertex": 3335, + " = a_1": 3336, + ") _shared": 3337, + "._2": 3338, + "omp parallel for _shared": 3339, + " = _y": 3340, + "de_p": 3341, + "cell_s": 3342, + "v_ = ": 3343, + "Matrix_Dim": 3344, + "fprintf(_f": 3345, + "reduc_tion": 3346, + " *) malloc_((sizeof(": 3347, + "*_:": 3348, + ") :_ ((": 3349, + "[_c": 3350, + "Ve_ctor": 3351, + "ch_ro": 3352, + ") schedule(_static, ": 3353, + ") _default": 3354, + "scal_ar": 3355, + "4_3": 3356, + "omp parallel for shared(col_)": 3357, + "ener_g": 3358, + "; k_ < ": 3359, + "ne_to": 3360, + "s_ ": 3361, + "ti_al": 3362, + "break_;\n\n ": 3363, + "v_.": 3364, + "params._ny": 3365, + "nl_ * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((nl": 3366, + "long_ *) (&": 3367, + "for (v = 0; v < _graph->num_vertices": 3368, + "for (v = 0; v < graph->num_vertices_; v++)\n{\n ": 3369, + "dynamic_, ": 3370, + "[i3 - 1][i2_ - 1": 3371, + "f_scanf(": 3372, + "[i]_ = 0;\n}\n": 3373, + " == _2": 3374, + "}\n _else": 3375, + ") + (_2 * ": 3376, + "Bo_x": 3377, + "john__MD5_": 3378, + "input__array[x": 3379, + "s[_((": 3380, + "H_e": 3381, + "ce_[m": 3382, + "B_, ": 3383, + "] = _a": 3384, + "reduction_ (": 3385, + "HREAD_S": 3386, + "N_ext": 3387, + "len__p": 3388, + " + (-1))) : (n_m": 3389, + "atoi16[ARCH_INDEX_(p": 3390, + ")) + _k": 3391, + "schedule (_static, ": 3392, + " = _mm_load1_ps(_t + k": 3393, + ");\n _int ": 3394, + ")_] = ": 3395, + ";\n _}\n\n }\n\n ": 3396, + "R_ec": 3397, + "4_) * ": 3398, + "ciphertex_t": 3399, + "3_;\n ": 3400, + "cur__": 3401, + " * _N": 3402, + "__last": 3403, + ";\n _}\n\n }\n\n }\n\n}\n": 3404, + " > _max": 3405, + "le_vel": 3406, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100))) + ((_0 * (1 * 100)) * (1 * 100))))) + i": 3407, + "nk * 16) < 0) ? (-((-nk) / 16)) : ((16 < 0) ? ((((-nk) + (-16)) - 1) / (-16)) : (((nk_ + 16) - 1) / 16))": 3408, + "16 * c1) + 15) < (n_j + (-1))) ? ((16 * c1) + 15) : (nj": 3409, + "B_0": 3410, + "im_it": 3411, + "U_LL": 3412, + "\n_void ": 3413, + "_f_rom": 3414, + ", _2": 3415, + "im_g": 3416, + "x_c": 3417, + "][_y": 3418, + "][5_ - 1": 3419, + "A_0": 3420, + "node_s": 3421, + " *_ ((((": 3422, + "for (j_2": 3423, + ";\n }\n\n _}\n\n ": 3424, + "][_n": 3425, + ", _u": 3426, + "__NUM": 3427, + "))_);\n ": 3428, + "T_x": 3429, + "for (j = 1; j <= ((last_col - firstcol) + 1)": 3430, + "MD5_std__combined *) (((char *) ": 3431, + "MD5_std_combined *) (((char *) _MD5_std_": 3432, + "MD5_std_combined *) (((char *) MD5_std__all_p) + t))).": 3433, + "77_77": 3434, + "omp parallel for shared(col_)\n ": 3435, + "omp parallel for shared(col)\n _for (col = 0; col < 95100; col++)\n {\n ": 3436, + "size_; i++)\n{\n ": 3437, + "S_end": 3438, + "omp parallel for _reduction(": 3439, + " ,_u": 3440, + " = _u": 3441, + "x_0": 3442, + "{\n _ ": 3443, + "_point_er": 3444, + "w_rite": 3445, + "tmp__cell": 3446, + ";\n\n _}\n\n ": 3447, + " + (_j * ": 3448, + ";\n _for (j = 0; j < ": 3449, + "it(_&": 3450, + ";\n}\n\n\n_void ": 3451, + "flu_sh": 3452, + "__A": 3453, + "neigh_b": 3454, + "sal_t": 3455, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm_ + (-1)) / 16))) ?": 3456, + "for (int i = 0; i < 1_0": 3457, + "__output": 3458, + "str_cmp(": 3459, + "P_ar": 3460, + "[i]_ = 0;\n ": 3461, + ") ||_ ((": 3462, + "D_ata": 3463, + "[col_] = ": 3464, + "row_, ": 3465, + " = _mm_load1__ps((": 3466, + "ne_are": 3467, + " _4)": 3468, + "v_(": 3469, + "ma_in": 3470, + " * _p": 3471, + "result_ = ": 3472, + ") * _s": 3473, + "#pragma omp for_ ": 3474, + "filter__": 3475, + "s_[idx": 3476, + " +_ (-": 3477, + "9_E": 3478, + "1__ps(": 3479, + "2_(": 3480, + "so_lu": 3481, + ")\n _for (int i": 3482, + "m_->": 3483, + "; j++)\n {\n _C": 3484, + ")\n {\n _printf(\"": 3485, + "co_p": 3486, + "num__p": 3487, + "h_f": 3488, + "C_E": 3489, + ";\n _lhs[": 3490, + "l_c": 3491, + "9_0": 3492, + "in_it_": 3493, + "omp parallel for reduction(+: l) collapse(_3": 3494, + ") &&_ ": 3495, + "a_v": 3496, + "symmat_[(": 3497, + "cbc_[ntemp": 3498, + "16 * c2) + 15) < (n_k + (-1))) ? ((16 * c2) + 15) : (nk": 3499, + "nl * 16) < 0) ? (-((-nl) / 16)) : ((16 < 0) ? ((((-nl) + (-16)) - 1) / (-16)) : (((nl_ + 16) - 1) / 16))": 3500, + " + (-1))) < (nk_ + (-1))) ? ((((": 3501, + "local__density": 3502, + " >> _22": 3503, + "6_F": 3504, + "#pragma _omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 3505, + "*((vtype_ *) (((": 3506, + "*((vtype *) (((_long *) (&": 3507, + "(_u": 3508, + "F_P": 3509, + "s_;\n ": 3510, + "V_er": 3511, + ", i_);\n ": 3512, + "c_ul": 3513, + "d_ = ": 3514, + "s_);\n ": 3515, + "U_p": 3516, + "i + _j": 3517, + ", _v": 3518, + "D__": 3519, + "vo_l": 3520, + ", _mm_mul_ps(__mm_load": 3521, + "loop_s": 3522, + "b_i": 3523, + "n_b": 3524, + "mes_sage": 3525, + "R_23": 3526, + "R_46": 3527, + "Ver_tic": 3528, + "elem_at(&_g->": 3529, + "elem_at(&g->_vertices": 3530, + "v__data->": 3531, + ") <_<": 3532, + ")\n{\n _return ": 3533, + "ce_sse": 3534, + " == 1_)\n {\n ": 3535, + " % _2": 3536, + "; i++)\n{\n _printf(\"": 3537, + ".2_f": 3538, + ")) * (_*((": 3539, + "6_1": 3540, + "d_at": 3541, + "for (k = 0; k_ < 1": 3542, + "fprintf(_fp": 3543, + "chan_ge": 3544, + " ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))_); c2++)\n {\n for (c3 = 16 * c1": 3545, + "BF_current._P": 3546, + "12_8": 3547, + ",_m": 3548, + "b_eta": 3549, + "g_in": 3550, + ", (_unsigned char *) ": 3551, + "#pragma omp _flush": 3552, + " / _2": 3553, + "for (j = 0; j < 1_000": 3554, + "ri_ple": 3555, + "diff = _diff": 3556, + "while_ ((": 3557, + "Di_v": 3558, + "; _t": 3559, + "x_; i++)\n ": 3560, + "a_0": 3561, + "ne_s": 3562, + "(_const ": 3563, + "pageRank_s[v": 3564, + ") * _x": 3565, + "se_cond": 3566, + "for (i = 0; i < _8192": 3567, + ", _h": 3568, + "; _c": 3569, + " + 1_] = ": 3570, + ") + y_) * ": 3571, + "f_r": 3572, + "re_al_": 3573, + "p_l": 3574, + "g_u": 3575, + "si_on": 3576, + "j_ - 1) * ": 3577, + "(p_ng": 3578, + "sq_u": 3579, + "return 1_;\n\n": 3580, + " << _4": 3581, + "_i_mage": 3582, + "y_(&": 3583, + "4_)\n{\n ": 3584, + "ro_l": 3585, + "1_ <<": 3586, + "e_i": 3587, + " * _size": 3588, + "in__mo": 3589, + "[_o": 3590, + "6_;\n x": 3591, + "k + (-1))) ? ((16 * c2) + 15) : (nk_ + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 3592, + " = a_5": 3593, + "buf_s[idx": 3594, + "tmp_ = ": 3595, + "[(j * _n": 3596, + "O_D": 3597, + "lo_n": 3598, + "stats->_pageRanks[v": 3599, + " < 16_; ++i": 3600, + "OMP_Index_(int x, int y, int z": 3601, + "OMP_Index(int x, int y, int z_)\n{\n return (((": 3602, + "OMP_Index(int x, int y, int z)\n{\n return (((_z * ": 3603, + "OMP_Index(int x, int y, int z)\n{\n return (((z * _OMP_yMax": 3604, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax_) + y) * ": 3605, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * _OMP_xMax) + ": 3606, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + _x": 3607, + "si_de": 3608, + "0_7": 3609, + "ele_ment_": 3610, + "temp_ + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 3611, + "[i]_);\n": 3612, + "pow(dt_, i);\n}\n": 3613, + "S_CH": 3614, + "out__degree": 3615, + "d_temp": 3616, + "go_to ": 3617, + "for (i = 0; i < 20; ++i)\n{\n _dpt *= dt": 3618, + "for (i = 0; i < 20; ++i)\n{\n dpt *= dt_;\n}\n": 3619, + "logic_and = logic_and &&_ logics[i];\n}\n": 3620, + "a_ct": 3621, + "bit_and = bit_and &_ logics[i];\n}\n": 3622, + "logic_or = logic_or ||_ logics[i];\n}\n": 3623, + "logics[i] = 1_;\n}\n": 3624, + "bit_or = bit_or |_ logics[i];\n}\n": 3625, + "[l_]": 3626, + "__width": 3627, + "8_)": 3628, + "for (j = 1; j_ <= ": 3629, + " = 0;\n _#pragma ": 3630, + "e_+": 3631, + "2_; i": 3632, + "_X_86": 3633, + "; j++)_\n {\n ": 3634, + "__type": 3635, + "y_2": 3636, + " -_ ((": 3637, + "bo_ard": 3638, + "u[_4": 3639, + "aligned_(": 3640, + "SCH_ED": 3641, + ") >_= ": 3642, + "mat_ri": 3643, + ", _r": 3644, + "1_,": 3645, + " &_ 1": 3646, + "][i][j][k] = _fac1 * ": 3647, + " - (lhs[n_ + 1": 3648, + "][k_] * ": 3649, + ") * _d": 3650, + ")) _>": 3651, + "8_ * ": 3652, + "private.d__in2": 3653, + "M_AT": 3654, + "tmp1 * _2.0) * ": 3655, + "; c3_ <= ((((((": 3656, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2_; c4 <= ((((((": 3657, + " + (-1))) < (nl_ + (-1))) ? ((((": 3658, + " par_ams.": 3659, + " + 16_) - 1) / 16))) : (((": 3660, + "n_ = 0; ": 3661, + "++)\n{\n _if (": 3662, + "i)_\n{\n ": 3663, + "[j_ + 1]": 3664, + "re_f": 3665, + "1_;\n ": 3666, + "co_de": 3667, + "2_ * ((": 3668, + "shif_t": 3669, + "u_se": 3670, + "for (i = 1; i <= _10": 3671, + "E_X": 3672, + "i_te": 3673, + "jtr_sha_256": 3674, + "rhs[m_][i][j][k": 3675, + "gu_ided": 3676, + "2_;\n ": 3677, + "n_temp = ": 3678, + "ep_i": 3679, + "y__data": 3680, + "99_99": 3681, + "dt_);\n ": 3682, + ";\n_\n ": 3683, + ", int _i, int ": 3684, + "a_ge": 3685, + "#pragma omp for_\n ": 3686, + "z_one": 3687, + "se_ct": 3688, + "k_p": 3689, + "d_sum += ": 3690, + "map_(": 3691, + "nn_z": 3692, + "exclusiv_bit_or = exclusiv_bit_or ^_ logics[i];\n}\n": 3693, + "^:exclusiv_bit_or_)": 3694, + "stat_us": 3695, + ";\n _if ((": 3696, + "ta_sk": 3697, + "&&:logic_and_)": 3698, + "m_u": 3699, + "diff = diff_ - i": 3700, + "ddiff_ -= ": 3701, + "product_ *= ": 3702, + "] = _temp": 3703, + "5_ * ": 3704, + "for (_l": 3705, + " <= (((_((((": 3706, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) <_ ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk": 3707, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk_ + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) :": 3708, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) :_ ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16))": 3709, + ";\n vtype x_0": 3710, + " & _m;\n ": 3711, + " + 1_][i1]": 3712, + "do_\n {\n ": 3713, + "(x, y, z_)": 3714, + "));\n *((C + i) + _mj": 3715, + "Diff_erence": 3716, + "str_ing": 3717, + ", (MPI_Datatype) 0x4c000_40": 3718, + "n_c": 3719, + "__G": 3720, + "D_D": 3721, + " + (jj * params.nx_)]": 3722, + "png__": 3723, + "a_i": 3724, + "J_TR": 3725, + "] = _i": 3726, + " + (-1))); _c1": 3727, + "&:bit_and_)": 3728, + "omp parallel for _simd": 3729, + "printf(\"_\\n": 3730, + "8_00": 3731, + "s_ += ": 3732, + "||:logic_or_)": 3733, + ") &&_ (n": 3734, + "|:bit_or_)": 3735, + "ff_t": 3736, + "fft_block": 3737, + "m_4": 3738, + "a_, b": 3739, + ";\n }\n\n _return ": 3740, + ";\n }\n\n _for (c2": 3741, + "B_ER": 3742, + ", _const ": 3743, + "omp parallel for _firstprivate(": 3744, + " = 1._ / ": 3745, + "2]_ = 0;\n ": 3746, + "__j": 3747, + ")) _> ": 3748, + "++_;\n ": 3749, + "dep_th": 3750, + "d_comp": 3751, + "fra_me": 3752, + "for (int i = 0; i < _g->N": 3753, + ")_ ((": 3754, + "le_v": 3755, + "]_ = 0": 3756, + "((((_((((": 3757, + " _instead of": 3758, + "*:_product": 3759, + "t _2": 3760, + "cont_rol": 3761, + "[(i * N_) + j]": 3762, + "c_in": 3763, + "u_al": 3764, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk_;\n }\n\n #pragma omp simd\n for (c4 = ": 3765, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n #pragma omp simd\n for (c4 = _nl": 3766, + ") private(i_, j": 3767, + "for (i = 0; i <_= (": 3768, + "++)\n{\n _for (c2 = 0; c2": 3769, + "eta_ * (ce[": 3770, + "zeta_ * (ce[": 3771, + "omp parallel for simd _collapse(": 3772, + " * (_*": 3773, + ") / (_1 - ": 3774, + "e_-": 3775, + "[(i * _size": 3776, + "-:_diff": 3777, + " = (_1 - ": 3778, + "double_s": 3779, + "-:_ddiff": 3780, + "N_G": 3781, + "1]_ * ": 3782, + ") :_ (((": 3783, + " - _u": 3784, + "----_----": 3785, + "tmp_ = v": 3786, + "S_S": 3787, + "(i_mage": 3788, + "][2]_ * ": 3789, + "omp parallel for schedule(dynamic,1) private(i) reduction(_^:exclusiv_bit_or)": 3790, + "1_))": 3791, + ") /_ ((double) ": 3792, + "omp parallel for schedule(dynamic,1) private(i) reduction(_&&:logic_and)": 3793, + " * _h": 3794, + "dsum_ = 0;\n ": 3795, + "logic_and_ = 1;\n ": 3796, + "bit_and_ = 1;\n ": 3797, + ")\n {\n result++;\n fprintf(stderr, \"Error in _sum": 3798, + ")\n {\n result++;\n fprintf(stderr, \"Error in sum_ with ": 3799, + "dpt_ = 1;\n ": 3800, + "dpt = 1;\n _for (i = 0; i < 20; ++i)\n {\n ": 3801, + "dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n _dpt *= dt": 3802, + "dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt_;\n }\n\n ": 3803, + " = (1 - _dpt": 3804, + " = (1 - dpt_) / (1 - ": 3805, + " = (1 - dpt) / (1 - _dt);\n ": 3806, + ")\n _for (i = 0; i < 20; ++i)\n {\n ": 3807, + "pow(dt_, i": 3808, + "pow(dt, i_);\n }\n\n if (": 3809, + "pow(dt, i);\n }\n\n if (_fabs(": 3810, + "dsum_ - ": 3811, + "dsum - _dknown_sum": 3812, + ") > _rounding_error": 3813, + "doubles_: Result was": 3814, + "duc_t ": 3815, + "logic_and_)\n {\n result++;\n fprintf(stderr, \"Error in logic": 3816, + "logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic_ AND par": 3817, + "logic_or_)\n {\n result++;\n fprintf(stderr, \"Error in logic": 3818, + "logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic_ OR par": 3819, + "bit_and_)\n {\n result++;\n fprintf(stderr, \"Error in BIT": 3820, + "bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT_ AND par": 3821, + "bit_or_)\n {\n result++;\n fprintf(stderr, \"Error in BIT": 3822, + "bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT_ OR par": 3823, + "t 1_\\n\");\n }\n\n ": 3824, + "t 2_\\n\");\n }\n\n ": 3825, + "exclusiv_bit_or_)\n {\n result++;\n fprintf(stderr, \"Error in ": 3826, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in _EX": 3827, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EX_CL": 3828, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCL_U": 3829, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLU_SI": 3830, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSI_V": 3831, + " _BIT": 3832, + " BIT_ OR par": 3833, + "omp__un": 3834, + ", 0_, ": 3835, + ") - 1_] = ": 3836, + "[k_] * ": 3837, + "i_me": 3838, + "mor__s_": 3839, + "C_A": 3840, + ";\n _out": 3841, + "le_c": 3842, + "ind_ow": 3843, + "F_E": 3844, + "bin_ary": 3845, + "4_))": 3846, + "i_ - 1": 3847, + "logics[i] = 1_;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3848, + "2] = 0;\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3849, + " - 1_); ": 3850, + "i_, j": 3851, + "0._1": 3852, + "stat_ic,1) private(i": 3853, + "*_) ": 3854, + "d_(": 3855, + "cul_ate": 3856, + "[j]_.": 3857, + "lu_g": 3858, + "lam_b": 3859, + "omp parallel for schedule(dynamic,1) private(i) reduction(_+:": 3860, + "=_ (n": 3861, + "4_,": 3862, + " = 1.0_;\n ": 3863, + "for (i = 0; i < 1000; ++i)\n{\n _exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n}\n": 3864, + "for (i = 0; i < 1000; ++i)\n{\n _logic_and = logic_and && logics[i];\n}\n": 3865, + "for (i = 0; i < 1000; ++i)\n{\n _bit_and = bit_and & logics[i];\n}\n": 3866, + "omp parallel for schedule(dynamic,1) private(i) reduction(_&:bit_and)": 3867, + "#pragma omp parallel for schedule(dynamic,1) private(i) reduction(_+:": 3868, + "&&:logic_and_)\n for (i = 0; i < 1000; ++i)\n {\n ": 3869, + "&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n _logic_and = logic_and &&": 3870, + "logics[1000 / _2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3871, + "t 2.\\n\");\n }\n\n _for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 3872, + "||:logic_or_)\n for (i = 0; i < 1000; ++i)\n {\n ": 3873, + "||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n _logic_or = logic_or ||": 3874, + "&:bit_and_)\n for (i = 0; i < 1000; ++i)\n {\n ": 3875, + "&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n _bit_and = bit_and &": 3876, + "|:bit_or_)\n for (i = 0; i < 1000; ++i)\n {\n ": 3877, + "|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n _bit_or = bit_or |": 3878, + "^:exclusiv_bit_or_)\n for (i = 0; i < 1000; ++i)\n {\n ": 3879, + "^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n _exclusiv_bit_or = exclusiv_bit_or ^": 3880, + "exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV_ BIT OR par": 3881, + "[i + 1][ind_] = ": 3882, + "}\n else_\n {\n ": 3883, + "_in_it(&": 3884, + ")\n{\n int sum_;\n int i": 3885, + " = 1_;\n ": 3886, + "for (i = 0; i < 1000; ++i)\n{\n _logic_or = logic_or || logics[i];\n}\n": 3887, + "omp parallel for schedule(dynamic,1) private(i) reduction(_||:logic_or)": 3888, + "for (i = 0; i < 1000; ++i)\n{\n _bit_or = bit_or | logics[i];\n}\n": 3889, + "omp parallel for schedule(dynamic,1) private(i) reduction(_|:bit_or)": 3890, + "out_o": 3891, + " * (*((_(*((": 3892, + "p1]_ - (2.0 * ": 3893, + "] = _1.0": 3894, + "new_c[iel": 3895, + "nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj_ + 16) - 1) / 16))": 3896, + "00_FF": 3897, + ";\n _*((vtype *) (((long *) (&": 3898, + ";\n _C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 3899, + "_xx__xx": 3900, + "O_n": 3901, + ") private(_j": 3902, + "C_la": 3903, + "; y_++)\n {\n ": 3904, + "crypt__key": 3905, + "for (_row = 0; row": 3906, + "[i][k_]": 3907, + "6_.0 * ": 3908, + "o_d": 3909, + "in_mo_d_": 3910, + " params._nx": 3911, + "i_ter": 3912, + "r_h": 3913, + "Up_date": 3914, + "node_s[": 3915, + "[j]_, ": 3916, + "; i_1": 3917, + "tmp_ = tmp": 3918, + ";\n}\n\n\n_double ": 3919, + " = _omp_get_thread_num(": 3920, + "'_0'": 3921, + "ublic._in2": 3922, + "S->_P": 3923, + "4_0]": 3924, + "pu_t": 3925, + ") - 1_)": 3926, + "++)_\n ": 3927, + "mag_ic": 3928, + "Temperature__last": 3929, + "0._25": 3930, + ", 1_, ": 3931, + "y_ ": 3932, + "_b_lock": 3933, + "1_ << ": 3934, + "->_label": 3935, + "ou_rs": 3936, + "forcing_[m": 3937, + "; i_ += 1)\n{\n ": 3938, + ")_ (((": 3939, + "; j_ < (": 3940, + "ING__M": 3941, + "__no": 3942, + "r_m": 3943, + "flu_x": 3944, + "++_;\n ": 3945, + " + _5": 3946, + "m_ + (-1))) ? ((16 * c1) + 15) : (n": 3947, + "m + (-1))) ? ((16 * c1) + 15) : (n_m": 3948, + "fa_ctor": 3949, + "++)\n{\n _for (int ": 3950, + "; i++)\n{\n _int ": 3951, + "ing_ ": 3952, + "])_\n {\n ": 3953, + "lhs[n + 3_][i][j][k": 3954, + "ra_ph": 3955, + "M_in": 3956, + "[y_][x": 3957, + "ntemp = _sje": 3958, + "i_1": 3959, + " += 1_)\n {\n ": 3960, + "omp parallel for schedule(_SCHED": 3961, + "omp parallel for schedule(SCHED_UL": 3962, + "x_, ": 3963, + "x_ + (": 3964, + "rand(_)) / ": 3965, + "_NUM_BER": 3966, + ", _mm_mul_ps(_mm_load_u_ps(s + k": 3967, + ")) * (_*(": 3968, + "ep_si": 3969, + ")) _&&": 3970, + "_s_ome": 3971, + "pageRank_s": 3972, + "][i_ - 1": 3973, + "s[_0]": 3974, + "7_ * (((": 3975, + "or_m": 3976, + "m1_ - 1); i1": 3977, + "neare_st_": 3978, + "omp parallel for private(i_, j": 3979, + "omp parallel for schedule(SCHEDUL_ING_M": 3980, + "omp parallel for schedule(SCHEDULING_M_ET": 3981, + "omp parallel for schedule(SCHEDULING_MET_H": 3982, + "omp parallel for schedule(SCHEDULING_METH_OD": 3983, + "a_der": 3984, + "P_R": 3985, + "; j_ += ": 3986, + "for (int k = 0; k_ < ": 3987, + "double_ p": 3988, + "ro__x": 3989, + ":_ %d": 3990, + "if_e": 3991, + ";\n int _k": 3992, + "static _int ": 3993, + "pass_ed_": 3994, + "passed__verification": 3995, + "[b_id]": 3996, + ") + ((-1) * n_)) + ": 3997, + "0.0_5": 3998, + "fail_++": 3999, + "ra_n": 4000, + "7_8": 4001, + ")\n {\n _if (": 4002, + "rand(_)) /": 4003, + "f_y": 4004, + " + 1_) * (": 4005, + "__max": 4006, + "T_o": 4007, + " = 0; _l": 4008, + "8_) * ": 4009, + "be_st": 4010, + ";\n _*": 4011, + "u_[i][j]": 4012, + "[i - 1_][j][k": 4013, + ")\n {\n _int ": 4014, + "}\n else\n _if (": 4015, + "A[_c1][c2] = (((double) c1": 4016, + "A[c1][c2] = (((double) c1_) * c2": 4017, + "A[c1][c2] = (((double) c1) * c2_) / ni": 4018, + "I_s": 4019, + "st_d": 4020, + "bl_ue": 4021, + "sizeof(_float": 4022, + "[i][j - 1_][k": 4023, + "->ve_[k]": 4024, + " != (_test_rank_array": 4025, + " (((_(((n": 4026, + "va_ = v": 4027, + "vb_ = v": 4028, + "vassign[iel][_0] = ": 4029, + "in_.bit._": 4030, + "pe_nd": 4031, + "[i][j_ + 1][k": 4032, + "val_ = ": 4033, + "FP__NUMBER": 4034, + "8_]": 4035, + "epsi_lon": 4036, + "Vertic_es": 4037, + "bucke_t": 4038, + "matrix_ + i) + ": 4039, + " = _mm_load1_ps((_t": 4040, + ")) * (*((_t": 4041, + "chan_nel": 4042, + " + _0": 4043, + "][3_] * ": 4044, + "n_) + j]": 4045, + "; i++)\n{\n for (j = 0; j < _n": 4046, + "for (_long ": 4047, + "for (i = 0; i < 1_00000": 4048, + ")) + (_k": 4049, + "[(i * 1_024": 4050, + "; i++)_\n {\n ": 4051, + "S_T": 4052, + "[i][_1]": 4053, + "._E": 4054, + "[i + 1_][j][k": 4055, + ";\n _tmp = v": 4056, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t)))._E": 4057, + "set_1_ps(": 4058, + "me_as": 4059, + "for (_y = 0; y < ": 4060, + "));\n _c00 = _mm_add_ps(c00": 4061, + "image_->": 4062, + " %_= ": 4063, + "++_] = ": 4064, + "co_d": 4065, + "5_ - 1)": 4066, + "0][_0]": 4067, + "edge__": 4068, + "pcmor__n": 4069, + "matrix_Size": 4070, + "T_46": 4071, + ") && (_c1 >= (((": 4072, + "[], _float ": 4073, + " = (_float": 4074, + "c2_ * ": 4075, + "C_F": 4076, + "O_ut": 4077, + "n = 0; _n": 4078, + "vertic_e": 4079, + "for (i1_ = 0; i1": 4080, + "--_)\n{\n ": 4081, + "][3_] = ": 4082, + ";\n _}\n else\n {\n ": 4083, + "-_1.0": 4084, + "v1[i] * v2[i]_;\n": 4085, + "__work": 4086, + "a[i]_ + ": 4087, + "[j]_ * ": 4088, + "cess_or": 4089, + "ang_ * ": 4090, + ";\n }\n\n }\n\n }\n\n }\n\n if ((_c1 <=": 4091, + "_mm_512_": 4092, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).E_.E": 4093, + "re_ate": 4094, + "omp parallel for _firstprivate": 4095, + "el_a": 4096, + "for (i_2": 4097, + ",j_)": 4098, + "h__": 4099, + "pe_n": 4100, + "pro_b": 4101, + "val_1": 4102, + "int)_ ((": 4103, + "(_\"": 4104, + "\n _{\n ": 4105, + ", 0_);\n ": 4106, + "neighbor_s": 4107, + "w_indow": 4108, + "po_st": 4109, + "r_gb": 4110, + ") +_ (-": 4111, + "40_8": 4112, + "c3_) + ": 4113, + ") + (_y * ": 4114, + "n_on": 4115, + " != (_7": 4116, + "e_st": 4117, + " + 1_, ": 4118, + "val_3": 4119, + "omp parallel for reduction(+:_sum)": 4120, + "[_5": 4121, + "c_alloc(": 4122, + ";\n _b": 4123, + "w_l": 4124, + " >_ (": 4125, + "mo_ve": 4126, + "][i1_ + 1]": 4127, + "(_void": 4128, + "u_old": 4129, + "nearest__city": 4130, + "un_i": 4131, + ");\n }\n\n _printf(\"\\n\");\n}\n": 4132, + "omp target parallel for _collapse(": 4133, + " is_ ": 4134, + " > _nm": 4135, + " = 0;\n _}\n\n}\n": 4136, + "L_E": 4137, + "b_ar": 4138, + ") &&_ ((": 4139, + "mat_ch": 4140, + " < _8": 4141, + "uint64__t ": 4142, + "7_3": 4143, + "st_op": 4144, + "]._real": 4145, + "]._imag": 4146, + "_mul_(": 4147, + "])_, (": 4148, + " & m_;\n tmp": 4149, + " & m;\n tmp_ = tmp": 4150, + "va = v_a": 4151, + "va = va_ | tmp": 4152, + "vb = v_b": 4153, + "vb = vb_ | tmp": 4154, + "lhs[_k": 4155, + "6_3": 4156, + " ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj_ + (-1)) / 16))": 4157, + "][m_] = ": 4158, + "0.5_ * (": 4159, + "reduction (_+:": 4160, + ")_;\n\n ": 4161, + "]_) + (": 4162, + "dim_Z": 4163, + "mat__col": 4164, + "[_t": 4165, + "))_;\n }\n\n}\n": 4166, + "num__pro": 4167, + "#pragma _omp parallel for\n ": 4168, + "/_im": 4169, + "[(_j": 4170, + "I_M": 4171, + "51_2 * ": 4172, + "for (i = 0; i < _512": 4173, + "pre_v_": 4174, + "C_8": 4175, + "2_A": 4176, + ") *_ params.nx": 4177, + "for (index = 0; index < count; index_++)\n ": 4178, + "omp parallel for _ordered": 4179, + ":_%d": 4180, + "for (i = 0; i < _8": 4181, + "sup_->": 4182, + "low_er": 4183, + "(x_ :": 4184, + "; k_++)\n ": 4185, + " - _j": 4186, + "omp target teams _distribute parallel for": 4187, + "i_0": 4188, + "di_e": 4189, + "h_ist": 4190, + "le_r": 4191, + "params.ny_) * params.nx": 4192, + "params.ny) * params.nx_) + (": 4193, + "a_, ": 4194, + "private_[i].": 4195, + "for (int j_ = 1; j": 4196, + "_f_unc": 4197, + "ac_le": 4198, + "total__len": 4199, + "mat__row": 4200, + "][i][j][k] - (_dssp": 4201, + "zone_set": 4202, + "void_ p": 4203, + ");\n }\n\n _}\n\n ": 4204, + "visi_ted": 4205, + " - _v": 4206, + "omp_get__w": 4207, + "for (int i = 0; i < _x; i++)\n ": 4208, + "mor__v": 4209, + "row_val": 4210, + "][j_ + 1]": 4211, + "data_set": 4212, + "s_2": 4213, + "tmp2) * _fjac": 4214, + "tmp1 * 2.0) * _njac": 4215, + "tmp_2 * ": 4216, + "tmp2 * _fjac": 4217, + "u__x": 4218, + "[col]_);\n ": 4219, + "radi_us": 4220, + "el_t": 4221, + "[((_(x": 4222, + " =_ (nj": 4223, + "[id_].": 4224, + ") + _u1": 4225, + "de_bu": 4226, + "lo_t": 4227, + "++_) = ": 4228, + "return _result": 4229, + ") <_= ": 4230, + "c_[i]": 4231, + "] *= boundryScale;\n u[_ind + ": 4232, + "mem_set(": 4233, + "sp_l": 4234, + "cou_t": 4235, + "]_, int ": 4236, + "st_acle": 4237, + "2] = _6": 4238, + "3._14": 4239, + "for (_z": 4240, + "b_[i][j] = ": 4241, + "arr_[i]": 4242, + "0.5_) * ": 4243, + ");\n _printf(\"": 4244, + "fir_st_": 4245, + "ing_(": 4246, + "xyzInd_ + ": 4247, + " + 1)) + j_2]": 4248, + "s_r": 4249, + "n_ + (2 * ": 4250, + "n + (2 * _tsteps": 4251, + "n + (2 * tsteps_)) + (-": 4252, + ";\n out_.bit._": 4253, + "absVal(val_1": 4254, + "absVal(_val2": 4255, + " = 0; j_2": 4256, + "ob_stacle": 4257, + "omp parallel for _num_threads": 4258, + "ma_ss": 4259, + "a_[j]": 4260, + "Cities_X[": 4261, + "Cities_Y[": 4262, + "ou_se": 4263, + "1__layer": 4264, + "._speeds[": 4265, + "c1_34": 4266, + "20_408": 4267, + ";\n *((vtype *) (((long *) (&_(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 4268, + "grid_points[_0]": 4269, + " ^_ (": 4270, + "for (j2_ = 0; j2": 4271, + "for (k_2": 4272, + "matri_z": 4273, + " * 1_.0": 4274, + ") schedule(_runtime)": 4275, + "O_N": 4276, + ") / _N": 4277, + "active_Vertices": 4278, + "atom_s->": 4279, + "lu_ster": 4280, + "ge_t(": 4281, + "snake_s[j].": 4282, + "}\n else_\n ": 4283, + "][0]))), (*((vtype *) (&_(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 4284, + " = a_2": 4285, + "l_t": 4286, + "targe_t": 4287, + "t_z1": 4288, + "sqrt_((": 4289, + "[_10": 4290, + " _de": 4291, + "e+_00": 4292, + "spe_c": 4293, + ")) * (*(_t + k": 4294, + "omp parallel for simd _simdlen(": 4295, + "m_ = ": 4296, + "_m_at": 4297, + "for (i = 0; i < _m": 4298, + "ind_ice": 4299, + "++)_\n ": 4300, + "[i_Off": 4301, + "li_de": 4302, + ", _N": 4303, + "l_ife": 4304, + " = (_*": 4305, + "1_ * ((": 4306, + "2 * _h": 4307, + "li_ent": 4308, + "->_edges_array": 4309, + "E_v": 4310, + "_____": 4311, + "ull_; i < k": 4312, + "ull; i < k_ull": 4313, + "; i++)\n _l++": 4314, + "; i++)\n l++_;\n": 4315, + "for (j2 = 0; j2_ < 4": 4316, + "for (j2 = 0; j2 < 4_; j2": 4317, + "for (j2 = 0; j2 < 4; j2_++)\n ": 4318, + "for (j2 = 0; j2 < 4; j2++)\n _for (i = j": 4319, + "ll_; i < k": 4320, + "ll; i < k_ll": 4321, + "; i++)\n _for (k2": 4322, + "; i++)\n for (k2_ = 0; k": 4323, + "; i++)\n for (k2 = 0; k_2": 4324, + "; i++)\n for (k2 = 0; k2_ < 5; k": 4325, + "; i++)\n for (k2 = 0; k2 < 5; k_2": 4326, + "; i++)\n for (k2 = 0; k2 < 5; k2_ += 2)\n l++;\n\n\n": 4327, + "C_ell": 4328, + "(i_, j": 4329, + ") == 0_)\n {\n ": 4330, + "omp parallel for simd _safelen(": 4331, + "nj_ + (-1)) <": 4332, + " + (-1))) ?_ (nj": 4333, + " + (-1))) ? (nj_ + (-1)) :": 4334, + "m_h": 4335, + "c = c + (b_ != (7": 4336, + "i_; i < k": 4337, + "i; i < k_i": 4338, + "p_ath": 4339, + "p[i] = _v1[i] * v2[i];\n": 4340, + "][k_] = ": 4341, + "u_; i < k": 4342, + "u; i < k_u": 4343, + "[_((((": 4344, + "u__data->": 4345, + ", _unsigned char *": 4346, + "std_dev": 4347, + "[i][j]_ += ": 4348, + "for (k = 0; k < _N": 4349, + "ne_th": 4350, + ");\n _tmp": 4351, + ", &_i": 4352, + "c_or": 4353, + "3_84": 4354, + ") + j] = (((DATA_TYPE) i_) * j": 4355, + "comz_4": 4356, + "C_[c1][c2] = (((double) c1) * (c2": 4357, + "C[c1][c2] = (((double) c1) * (c2_ + 3)) / nl": 4358, + "ma_ster": 4359, + "4_1": 4360, + "[_u": 4361, + "[i_temp": 4362, + "16 * c2) + 15) < (n_l + (-1))) ? ((16 * c2) + 15) : (nl": 4363, + "4_E": 4364, + " = a_4": 4365, + " = a_3": 4366, + "d__1": 4367, + "printf(\"%d_ \", ": 4368, + "L_e": 4369, + ") && (i_ <= ": 4370, + "for (int i = 0; i_ < (": 4371, + "MPI__Send": 4372, + "omp target teams distribute parallel for _collapse(": 4373, + " ,_i": 4374, + "rsd_[i][j][k": 4375, + " - 1_))": 4376, + "0_3": 4377, + "random__": 4378, + "m_ar": 4379, + "\\n\");\n _exit(": 4380, + "y_, ": 4381, + "omp distribute parallel for _simd": 4382, + "r_int": 4383, + ") : (_0": 4384, + "lamb_da": 4385, + "]_ + 1": 4386, + " /_ ((": 4387, + "][m]_ - (": 4388, + " - _2]": 4389, + "num__elements": 4390, + " + 1)_; i++)\n{\n ": 4391, + "sum = sum + i_;\n}\n": 4392, + ");\n _free(": 4393, + "if_(": 4394, + ";\n _while (": 4395, + "do__some": 4396, + "a_sh": 4397, + " >_ 1": 4398, + "__grid": 4399, + "argv_[i]": 4400, + "gree_n": 4401, + "mor_s__v": 4402, + "u_f": 4403, + "T_y": 4404, + "C_D": 4405, + "t_lock": 4406, + "new_Index": 4407, + "righ_t": 4408, + "di_v": 4409, + " = 0.0_f": 4410, + "1_;\n double ": 4411, + "); _p": 4412, + " _)\n ": 4413, + "dynamic, _3)": 4414, + "12_4": 4415, + "3.14_15": 4416, + "[((_(i": 4417, + ") ?_ ((": 4418, + "in_it": 4419, + ") * (_1 * 100": 4420, + "_n_ame": 4421, + ")))) + (0.0_20408": 4422, + "squ_are": 4423, + "omp parallel for private (_i": 4424, + "ti_mer": 4425, + "4_ * ": 4426, + "Y_) + j]": 4427, + ",_ *": 4428, + "y_0": 4429, + "[_pos": 4430, + ");\n _int ": 4431, + ", _S": 4432, + " * (_x": 4433, + "point_er": 4434, + " - _4": 4435, + "temp_1": 4436, + "], _tmp_vec": 4437, + "ex_[(i * (": 4438, + ") - d_1": 4439, + "cells->_speeds[": 4440, + "][i1_][j][k": 4441, + "set_lock(&_tlock": 4442, + "set_lock(&tlock_[ig": 4443, + "ni_ * 16) < 0) ? (-((-": 4444, + "ni * 16) < 0) ? (-((-_ni": 4445, + "ni * 16) < 0) ? (-((-ni_) / 16)) : ((16 < 0) ? ((((-": 4446, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-_ni": 4447, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-ni_) + (-16)) - 1) / (-16)) : (((": 4448, + "ni * 16) < 0) ? (-((-ni) / 16)) : ((16 < 0) ? ((((-ni) + (-16)) - 1) / (-16)) : (((_ni": 4449, + "float percentDiff(double val1, double val2_)\n{\n if ((": 4450, + "float percentDiff(double val1, double val2)\n{\n if ((_absVal(val1": 4451, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1_) < 0.01": 4452, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01_) && (": 4453, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (_absVal(val2": 4454, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2_) < 0.01": 4455, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2) < 0.01_))\n {\n ": 4456, + "float percentDiff(double val1, double val2)\n{\n if ((absVal(val1) < 0.01) && (absVal(val2) < 0.01))\n {\n _return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f));\n }\n\n}\n\n": 4457, + "en_ter": 4458, + ") <<_ ": 4459, + "}\n _while (": 4460, + "u_s_": 4461, + "x_)\n{\n ": 4462, + "in_c": 4463, + "for (i = 0; i < 1_00": 4464, + "][_2] = ": 4465, + "i_ + i": 4466, + "omp_get_thread_num(_), ": 4467, + "4.0_ / (": 4468, + "[_2] = ": 4469, + " < 1_0": 4470, + "[i_size": 4471, + "S_um": 4472, + "[j]_;\n ": 4473, + "d_1": 4474, + "ori__row": 4475, + "ori__col": 4476, + "coe_ff": 4477, + "ma_n": 4478, + "T_3": 4479, + "ind_ + 1": 4480, + "A_[i][j] = ": 4481, + "B[_c1][c2] = (((double) c1) * (c2": 4482, + "B[c1][c2] = (((double) c1) * (c2_ + 1)) / nj": 4483, + "struct _time": 4484, + "[col_]);\n ": 4485, + "u_[i": 4486, + "D_A": 4487, + "3.1415_9": 4488, + "tr_ue": 4489, + "saved_key_[index], ": 4490, + "do_some__work": 4491, + "++_;\n }\n\n}\n": 4492, + "ri_es": 4493, + "[j_ - 1": 4494, + "in_ner": 4495, + "C_luster": 4496, + ", k_, ": 4497, + " * (sizeof(_double": 4498, + "_bu_ffer": 4499, + ";\n _return ": 4500, + "si_gma": 4501, + "u__ps((": 4502, + " (-((((-_((": 4503, + "lh_sp": 4504, + "lhs_m": 4505, + "se_lec": 4506, + "_per_m": 4507, + "temp_3": 4508, + "ti_le": 4509, + ") private_ (": 4510, + "omp parallel for private(i_)": 4511, + " < 1_00": 4512, + " + (-1))) < (nm_ + (-1))) ? (((": 4513, + ") |_ ": 4514, + "or_al": 4515, + "))_;\n }\n\n }\n\n}\n": 4516, + "_b_ound": 4517, + ";\n u_2": 4518, + ") + _col": 4519, + ";\n _int p": 4520, + "for (i = 0; i < n_; i++)\n for (j = 0; j < ": 4521, + " _\"": 4522, + ";\n _register ": 4523, + "public._in_mod_": 4524, + "P_U": 4525, + ";\n _}\n else\n if (": 4526, + "._p": 4527, + " ^= _u": 4528, + "->me_[i][j]": 4529, + "[j_j]": 4530, + "omp target_ parallel for": 4531, + "for (_unsigned int ": 4532, + " > _nk": 4533, + "; j_ <= ": 4534, + "i_an": 4535, + "num__b": 4536, + "re_n": 4537, + "for (i = 0; i < _4": 4538, + "; c3 <= ((((16 * c1) + 15) < (n_m + (-1))) ? ((16 * c1) + 15) : (nm": 4539, + "z_.r": 4540, + " < (n_ - 1)": 4541, + "_g_raph": 4542, + "2_);\n ": 4543, + "= _2": 4544, + ") * _size": 4545, + " + p_ublic.in2": 4546, + "1_layer_[o": 4547, + "D__3": 4548, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl_ + (-1)) / 16))) ?": 4549, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (n_l + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 4550, + "chro_ma": 4551, + "]._speeds[": 4552, + " ^= _BF_current.P": 4553, + ";\n u_4 = ": 4554, + " & (~_a": 4555, + " |_ a": 4556, + "0F_0": 4557, + "pstr->_bufs[idx": 4558, + "omp distribute parallel for simd _collapse(": 4559, + "p = _p": 4560, + "for (j = 0; j_ < (": 4561, + "Div_ided": 4562, + ") + _2]": 4563, + "s_ing": 4564, + "L_1": 4565, + "for (int i_i = 0; i": 4566, + " * _n": 4567, + "omp target parallel for _simd": 4568, + "omp target parallel for simd _collapse(": 4569, + ";\n\n_\n ": 4570, + "temp_ + ": 4571, + " == _2)": 4572, + "] = _{": 4573, + " = (_double": 4574, + "m_5": 4575, + ") + j]_ = 0;\n ": 4576, + "9_3": 4577, + "2_(i": 4578, + "6_3]": 4579, + "._data": 4580, + "_init(&_ctx": 4581, + "; _z": 4582, + "(((_16 * c1": 4583, + "k_;\n ": 4584, + "s->_atoms->": 4585, + "cal_culate": 4586, + "((_unsigned char *) ": 4587, + "3_][i][j][k]": 4588, + "][i_][0]": 4589, + "s_1": 4590, + " + OMP_xMax) + OMP_xMax) + _OMP_xMax": 4591, + " + OMP_xMax) + OMP_xMax) + _OMP_xMax) + OMP_xMax": 4592, + "OMP_xMax) + OMP_xMax) + _OMP_xMax": 4593, + "min_ = ": 4594, + "s(_&": 4595, + "4_96": 4596, + "F_iel": 4597, + "face__a": 4598, + "key__rank": 4599, + "if (_c1": 4600, + "map(_to": 4601, + " 1_)": 4602, + "(_r": 4603, + "par_ams": 4604, + ")\n{\n return_ (": 4605, + ") schedule(static_)": 4606, + "outpu_t->": 4607, + "F_inal": 4608, + "5_;\n": 4609, + ", &_a": 4610, + "for (i = 0; i < _3": 4611, + "][0][_0": 4612, + "post_Scale": 4613, + "u1_;\n ": 4614, + "params.ny) * params.nx) + (_ii": 4615, + " + (jj * params.nx_))": 4616, + "edge__idx": 4617, + "; i++)\n{\n _x": 4618, + "for (c1_ = 0; ": 4619, + "non_temp": 4620, + "nontemp_oral": 4621, + "M_AX": 4622, + "b_[j]": 4623, + "c_(": 4624, + "r_t": 4625, + "tex_t ": 4626, + "max_ + r": 4627, + "max + r_u1": 4628, + " _to ": 4629, + "[(k * _N": 4630, + ") + _4": 4631, + ", &_ctx": 4632, + "is_larger": 4633, + "atoi16[ARCH_INDEX_(": 4634, + " < 3_; m": 4635, + " *= _postScale": 4636, + "idmo_[ie][iface": 4637, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk;\n }\n\n #pragma omp simd\n for (c4 = nl_; c4 <= ((((16 * c2) + 15) < (n": 4638, + " ^= _u2": 4639, + " ^= u2_;\n ": 4640, + " ^= u_3;\n ": 4641, + ";\n }\n\n _#pragma omp simd\n for (c4": 4642, + "to_m": 4643, + "7_;\n": 4644, + "omp parallel for schedule (_static, ": 4645, + "))_;\n }\n\n ": 4646, + ") > _0.05": 4647, + "ame_ter": 4648, + ", a_, b": 4649, + " < 1_000": 4650, + ")\n _goto ": 4651, + "lin_es": 4652, + "m_ - 1)": 4653, + " = 0; _z": 4654, + "P_a": 4655, + "exp_(": 4656, + "grid__": 4657, + "_i_s": 4658, + "*_p = ": 4659, + "break_;\n\n ": 4660, + "; i++)\n {\n _for (j = 0; j < ": 4661, + "neighb_ours": 4662, + "local__A": 4663, + "__chunk": 4664, + "i * _params.nx": 4665, + "th_id": 4666, + "c1_) + ": 4667, + "omp parallel for schedule (_runtime)": 4668, + "From_G": 4669, + "FromG_pu": 4670, + "vertices_->": 4671, + "L_)]": 4672, + "for (i = 1; i_ < ": 4673, + "_col_or": 4674, + "__start": 4675, + "output->_content": 4676, + "X_, ": 4677, + "pageRanks_Next": 4678, + "(int _i, int ": 4679, + "[i] = (_int": 4680, + "); _c3": 4681, + " = _p": 4682, + ");\n _}\n else\n {\n ": 4683, + "check__i": 4684, + "check_i__is": 4685, + "check_i_is_larger": 4686, + "t_w": 4687, + " p_rime": 4688, + "off_set_": 4689, + "ei__new": 4690, + "hal_f": 4691, + "1_][i": 4692, + " = (_a": 4693, + "nn_1": 4694, + "h_v": 4695, + "h_Table": 4696, + ";\n u_4": 4697, + "vassign[iel_][1] = ": 4698, + "}\n_}\n": 4699, + "public.in2__pad": 4700, + ") * (_j": 4701, + " = i_;\n ": 4702, + "a_it": 4703, + ";\n int i_;\n int j": 4704, + " == 0_)\n ": 4705, + "ve_loc": 4706, + "i_ + 1) * ": 4707, + " = 0; _t": 4708, + "1_0000": 4709, + ", &_ipad": 4710, + ", &_opad": 4711, + " = ((_float) ": 4712, + "8_5": 4713, + "][j_j": 4714, + "se_l": 4715, + "s_s_": 4716, + ") + jj]_.speeds[": 4717, + ") * ((_8 * ((2000 - 1) / 8)) + 8": 4718, + "Fiel_d": 4719, + "sh_or": 4720, + " << _3": 4721, + "for (p = &buf[_16]": 4722, + "ULL_)\n p[2] = ": 4723, + "ULL)\n p[2] = _-7": 4724, + "ULL)\n p[2] = -7_;\n": 4725, + ")\n p[2] = _7;\n": 4726, + "omp parallel for schedule (static, _3)": 4727, + "for (i = 0; i < 64; i++)\n if (buf[i] != (_5": 4728, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5_ * ((i": 4729, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i_ >= ": 4730, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= _10": 4731, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10_) && (i": 4732, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i_ < 5": 4733, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i < 5_4": 4734, + "for (i = 0; i < 64; i++)\n if (buf[i] != (5 * ((i >= 10) && (i < 54_))))\n abort();\n\n": 4735, + "printf(\"_\\t ": 4736, + ") firstprivate_(i": 4737, + " + (-1))); _c2": 4738, + " + (-1))); c2_++)\n {\n ": 4739, + "1, _n2": 4740, + "1, n2_, n": 4741, + "}\n\n\n_\n\n": 4742, + "; p_ >": 4743, + "omp parallel for schedule (_dynamic, 3)": 4744, + "-_2] = 6": 4745, + "-2] = 6_;\n": 4746, + "];\n _}\n\n ": 4747, + ", _mm_mul_ps(_mm_loadu_ps(s + k_m": 4748, + "for (i = 0; i < 64; i++)\n if (buf[i] != (_6": 4749, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6_ * ((i": 4750, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i_ & 1": 4751, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1_) && (i <= ": 4752, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1) && (i <= _61": 4753, + "for (i = 0; i < 64; i++)\n if (buf[i] != (6 * ((i & 1) && (i <= 61_))))\n abort();\n\n": 4754, + "for (i = 0; i <_ (n": 4755, + "for (i = 0; i < 64; i++)\n if (buf[i]_ != ((": 4756, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((_-7": 4757, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7_) * (((": 4758, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * (((_(i & 3) == 2) && (i >= 18)) && (i": 4759, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i_ <= 4": 4760, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i <= 4_2": 4761, + "for (i = 0; i < 64; i++)\n if (buf[i] != ((-7) * ((((i & 3) == 2) && (i >= 18)) && (i <= 42_))))\n abort();\n\n": 4762, + "__index": 4763, + "7_]": 4764, + "for (i = 0; i < 64; i++)\n if (buf[i] != (_7 * (((": 4765, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * (((_(i & 3) == 2) && (i >= 18)) && (i": 4766, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i_ < 5": 4767, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i < 5_3": 4768, + "for (i = 0; i < 64; i++)\n if (buf[i] != (7 * ((((i & 3) == 2) && (i >= 18)) && (i < 53_))))\n abort();\n\n": 4769, + ") && _is_larger": 4770, + "col_ * ": 4771, + "*p = _5;\n": 4772, + "5_ = ": 4773, + "filter__list": 4774, + ") / _D_3": 4775, + "T_23": 4776, + "T_23 * ": 4777, + "[itemp_]": 4778, + " & 0x_FF": 4779, + " & 0xFF_;\n u": 4780, + " & 0xFF;\n u_1 <<": 4781, + " & 0xFF;\n u1 <<_= 2": 4782, + " & 0xFF;\n u1 <<= 2_;\n u2 = ": 4783, + " >> 6_;\n u2": 4784, + " >> 6;\n u2_ &= 0x3FC": 4785, + " >> 6;\n u2 &= 0x3FC_;\n u3 = ": 4786, + " >> 1_4": 4787, + " >> 14_;\n u3": 4788, + " >> 14;\n u3_ &= 0x3FC": 4789, + " >> 14;\n u3 &= 0x3FC_;\n u4 = ": 4790, + " >> 22_;\n u4": 4791, + " >> 22;\n u4_ &= 0x3FC": 4792, + " >> 22;\n u4 &= 0x3FC_;\n u1 = ": 4793, + " >> 22;\n u4 &= 0x3FC;\n u1 = _*((BF_word *) (((unsigned char *) BF_current.S": 4794, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S_[3]": 4795, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]_) + u1": 4796, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1_))": 4797, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1))_;\n u2 = ": 4798, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = _*((BF_word *) (((unsigned char *) BF_current.S": 4799, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S_[2]": 4800, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]_) + u": 4801, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u_2))": 4802, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2))_;\n u3 = ": 4803, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = _*((BF_word *) (((unsigned char *) BF_current.S": 4804, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S_[1]": 4805, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]_) + u": 4806, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u_3))": 4807, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3))_;\n u3 += ": 4808, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += _*((BF_word *) (((unsigned char *) BF_current.S": 4809, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S_[0]": 4810, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]_) + u": 4811, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u_4))": 4812, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u4))_;\n u3": 4813, + " >> 22;\n u4 &= 0x3FC;\n u1 = *((BF_word *) (((unsigned char *) BF_current.S[3]) + u1));\n u2 = *((BF_word *) (((unsigned char *) BF_current.S[2]) + u2));\n u3 = *((BF_word *) (((unsigned char *) BF_current.S[1]) + u3));\n u3 += *((BF_word *) (((unsigned char *) BF_current.S[0]) + u4));\n u3_ ^= u2;\n ": 4814, + " + 1]_;\n u3 += ": 4815, + " + 1];\n u3 += _u1;\n ": 4816, + "66_66": 4817, + "22_22": 4818, + "55_55": 4819, + "5_F": 4820, + "9_A": 4821, + "newc[iel_] = ": 4822, + ")) = _zero": 4823, + " + 16) - 1) / 16))_) > (((": 4824, + "))) ^_ ((temp": 4825, + ")) ^_ ((temp": 4826, + "_mm512__set1_ps(": 4827, + "#pragma omp_ parallel": 4828, + ")\n {\n _fail++": 4829, + ", \"_%f": 4830, + "_T_HREADS": 4831, + "0_;\n ": 4832, + "co_s(": 4833, + "x_)": 4834, + "ou_th": 4835, + "4.0 / (_1.0 + (": 4836, + "in_v": 4837, + " < _min": 4838, + "dist_ = ": 4839, + "))_) + (((": 4840, + "u_z": 4841, + "params.ny) * params.nx) + (ii_ + (jj * params.nx))": 4842, + "i * _N": 4843, + "par_allel": 4844, + "(_float *": 4845, + "val_id": 4846, + "]_ / ": 4847, + "; c2_ <=": 4848, + "for (i = 0; i < n_; i++)\n{\n for (j = 0; j < n": 4849, + "omp distribute parallel for simd _safelen(": 4850, + "rows_; i++)\n{\n ": 4851, + "__mask": 4852, + "omp distribute parallel for simd _simdlen(": 4853, + ")\n for (i = 1; i <= 1000; i++)\n {\n _sum = sum + i": 4854, + "ten_[i][ind": 4855, + "j_temp_ = j": 4856, + "[i][ind_] = ": 4857, + "[i][ind] = _j_temp": 4858, + "for (_t": 4859, + ";\n }\n\n _known_sum = (1000 * (1000 + 1)) / 2;\n ": 4860, + "return (_known_sum == sum": 4861, + ";\n int known_sum_;\n sum = 0;\n ": 4862, + "E_le": 4863, + " = _3": 4864, + ") private(i_)": 4865, + "sal_t, ": 4866, + "end_ = ": 4867, + ";\n _y": 4868, + ") + ((_*": 4869, + "])_;\n ": 4870, + "][k_][j][i": 4871, + ")) - (_4.0 * ": 4872, + ") - d_3": 4873, + "ca_st": 4874, + "bucket__ptr": 4875, + "d_ge": 4876, + ")) &&_ ((": 4877, + "__vector": 4878, + "[%d]_=%f": 4879, + "hash_Num": 4880, + "[_zoneset": 4881, + "]) + _srcGrid[(": 4882, + ") schedule(static, _2)": 4883, + "for (i = 0; i < len_; i++)\n{\n ": 4884, + "; j++)\n {\n if (_percentDiff(": 4885, + ")\n {\n fail++_;\n }\n\n }\n\n}\n\n": 4886, + " - 1_); k": 4887, + "for (i = 0; i < size_; i++)\n{\n ": 4888, + "rand()) / _32767": 4889, + " <=_ (n": 4890, + "else\n _if (i == ": 4891, + "a[i] = i_;\n": 4892, + ";\n _temp": 4893, + ") default_(none": 4894, + "MPI__Rec": 4895, + "real__t ": 4896, + " = 1.0_ / ": 4897, + "i_z": 4898, + "saved_key_[index": 4899, + "as_ser": 4900, + ",_a": 4901, + "N_ew": 4902, + "if_ ((((": 4903, + "Res_ult": 4904, + "time_();\n ": 4905, + ") _if (": 4906, + "2048 + 1)_) + j]": 4907, + "D_[c1][c2] = (((double) c1) * (c2": 4908, + "D[c1][c2] = (((double) c1) * (c2_ + 2)) / nk": 4909, + "; j++)_\n ": 4910, + "F_a": 4911, + "schedule (static, _4) ": 4912, + "));\n __mm_store": 4913, + "error_ = ": 4914, + "omp _teams ": 4915, + "for (x = 0; _x": 4916, + " = 0; _c": 4917, + ") firstprivate_(": 4918, + "scanf(_\"": 4919, + "48_3": 4920, + "483_64": 4921, + "g_ed": 4922, + "else_\n ": 4923, + "do_t": 4924, + "s_\\n\", ": 4925, + "ome_ga": 4926, + "key_buff__ptr": 4927, + ")) +_ (((": 4928, + "))_\n {\n ": 4929, + "s[(i_i * params.nx": 4930, + "l_d_": 4931, + "if ((_cbc[ntemp": 4932, + ")) + (_h": 4933, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk_ + (-1)) / 16)) <": 4934, + " ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk_ + (-1)) / 16)) :": 4935, + "MAT_ *": 4936, + "ela_ps": 4937, + "ri_Divided": 4938, + "riDivided_On": 4939, + "riDividedOn_Di": 4940, + "riDividedOnDi_Cla": 4941, + "riDividedOnDiCla_use": 4942, + "ni_ + (-1)) <": 4943, + " + (-1))) ?_ (ni": 4944, + " + (-1))) ? (ni_ + (-1)) :": 4945, + "sing_le": 4946, + ") > _0.": 4947, + "; i++)\n _for (j = 0; j < 1": 4948, + " = 0; i_2": 4949, + "]_;\n }\n\n}\n": 4950, + ") && (_j": 4951, + ") _ordered": 4952, + "stddev_[j]": 4953, + "__time": 4954, + "av_g": 4955, + "N_ - 1": 4956, + "W_ord": 4957, + "][_l": 4958, + "buf[_3": 4959, + "K_node": 4960, + ");\n\n_}\n": 4961, + "to_p": 4962, + "++)\n {\n _if (": 4963, + "6_, ": 4964, + " - 1); i_2": 4965, + "[_6": 4966, + ")\n goto _L": 4967, + "(_c": 4968, + "[i]_ = 0": 4969, + "1_) + 1": 4970, + "; i_ < (": 4971, + "_con_text ": 4972, + "s = _omp_get_num_threads(": 4973, + "be_gin": 4974, + "for (int j_ = ": 4975, + "si_ble": 4976, + "21_47": 4977, + "grid_[i][j]": 4978, + "s[_1]": 4979, + "K_L": 4980, + "_p_bkdf2": 4981, + ", &ipad_, &opad": 4982, + "[iel][_face": 4983, + " + k_][j]": 4984, + "c1_5": 4985, + "de_no": 4986, + "co_st": 4987, + "comm_un": 4988, + "stats->_distance": 4989, + "400_) * ((8 * ((2000 - 1) / 8)) + 8": 4990, + ") + 16_) + 1) / 16)) :": 4991, + "buf[_2": 4992, + "if (_key_rank": 4993, + "failed_ = 1": 4994, + " = _in.bit._": 4995, + " < _2": 4996, + ") + (j_ - 1)": 4997, + "for (i_3": 4998, + "__len": 4999, + "#pragma omp _single": 5000, + "; i++)\n{\n for (j = 0; j < _2048": 5001, + "dynamic_)": 5002, + "omp target parallel for simd _safelen(": 5003, + "256_ / 1": 5004, + "A_[i][k] * ": 5005, + "48364_7": 5006, + "box_es": 5007, + "4.0 / (1.0 + (_x * x": 5008, + "f_x": 5009, + "bo_ol": 5010, + "key_, ": 5011, + "const _float ": 5012, + "P_NG": 5013, + "s[_j": 5014, + "ro_ad": 5015, + "par_tition": 5016, + ";\n _}\n else\n {\n ": 5017, + "u[_1": 5018, + "g_am": 5019, + " = x_4": 5020, + "image_[indx": 5021, + "6_99": 5022, + "te_p": 5023, + "Bu_ffer": 5024, + "pend_(": 5025, + ", _f": 5026, + ", _unsigned ": 5027, + "my__grid->": 5028, + "=%f_\\n\", ": 5029, + "for (m = 0; m < 5; m_++)\n{\n ": 5030, + "lot_us_": 5031, + ", _float ": 5032, + "[i] = i_;\n ": 5033, + " * x_[j]": 5034, + "particle_s": 5035, + "row_][col": 5036, + "for (c4_ = ": 5037, + "omp parallel for private(j_)": 5038, + "))_) + ": 5039, + "ar_ch": 5040, + "for (k = 1; k <= (grid_points[2] - 2); k_++)\n {\n ": 5041, + "D_.": 5042, + ") ?_ (ni": 5043, + ") ? (ni_) : (n": 5044, + "tra_ns": 5045, + "sw_it": 5046, + "swit_ch": 5047, + "D_e": 5048, + "bo_die": 5049, + "j_g": 5050, + "ac_t_": 5051, + "row, _col": 5052, + "1.0_ - ": 5053, + "(x_yzInd": 5054, + "idmo_[ntemp": 5055, + "2048_ - 1": 5056, + ") + _row": 5057, + "for (m = 0; m_ < 3; m": 5058, + "q_l": 5059, + "head_.": 5060, + "for (int i = 0; i < x; i++)\n _for (int i = 0; i < ": 5061, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < _y": 5062, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < y_; i++)\n ": 5063, + " = ((-_tmp2) * fjac": 5064, + "symmat[(_j1": 5065, + "symmat[(j1_ * (": 5066, + ";\n }\n\n #pragma omp simd\n for (c4 = _nm": 5067, + " *= postScale_;\n u[": 5068, + "if (key_rank_ != (test_rank_array": 5069, + "[idx[i]]_, &": 5070, + " ^= u3;\n _;\n u1 = ": 5071, + "A_6": 5072, + " <= (((((((_(n": 5073, + "c_ptr": 5074, + "5__r": 5075, + "i_ - ": 5076, + " - 1)_; j": 5077, + "C_enter": 5078, + "ge_ne": 5079, + "point_s": 5080, + " + 1_) % ": 5081, + ";\n }\n\n for (c2_ = ": 5082, + "[i3][i2_ - 1": 5083, + "struc_t": 5084, + "_i_ter": 5085, + ", 0_, (MPI_Comm) 0x44000000": 5086, + "rec_v": 5087, + "for (z_ = 0; z": 5088, + ";\n int i_;\n int ": 5089, + "value_ = ": 5090, + "omp target teams distribute parallel for simd _collapse(": 5091, + "])_\n {\n ": 5092, + "s_u": 5093, + ";\n _else\n ": 5094, + "i_ += ": 5095, + ") +_ ((((": 5096, + "array_[i]": 5097, + ") - 1_) / ": 5098, + ", _float *": 5099, + "f_un": 5100, + "1, n2, n_3": 5101, + "lotus__magic": 5102, + "lotus_magic__table": 5103, + "40_e+00": 5104, + ") reduction(+:_c)": 5105, + "for (i = 0; i < 16_; ++i)\n{\n ": 5106, + "pa_ge": 5107, + "2_;\n double ": 5108, + "long long _int ": 5109, + "que_n": 5110, + "z_.": 5111, + " + (_a": 5112, + "(&_b": 5113, + "else_\n ": 5114, + "n_1": 5115, + "11_11": 5116, + "W_or": 5117, + "m_ * ": 5118, + "c_[": 5119, + ";\n _double ": 5120, + "orig_in": 5121, + ";\n x_0": 5122, + "thread__count": 5123, + "tx_[i": 5124, + "tx[i_l": 5125, + "u_tex": 5126, + ") * (1 * 100_)) * (1 * 100))))) + i": 5127, + "ps_c": 5128, + "cptr_[idx": 5129, + "; k_++)\n ": 5130, + ")\n{\n _float ": 5131, + "; row_++)\n{\n ": 5132, + ", s_up": 5133, + "[j_ + 1": 5134, + "OMP_Index_(x, y, z": 5135, + "__w": 5136, + "97_9": 5137, + "=_%d": 5138, + "mp_le": 5139, + "m_;\n ": 5140, + " = _temp": 5141, + "v__size": 5142, + "com_z1": 5143, + "][i + 1_][j][k": 5144, + "][i][j_ + 1][k": 5145, + "20_.": 5146, + "i_a": 5147, + "][0][_1": 5148, + ") + (_i * ": 5149, + "k_k": 5150, + "h_y": 5151, + " = j_;\n ": 5152, + ") * _ny": 5153, + "T_ime": 5154, + "omp parallel for schedule(dynam_ic": 5155, + " = 0.0_;\n }\n\n}\n": 5156, + "c1_0": 5157, + "y_ += ": 5158, + "0][_m]": 5159, + "))))_)))) + (": 5160, + "omp parallel for private(c2_)": 5161, + " + 1)_; j++)\n {\n ": 5162, + "for (row = 0; row_ < ": 5163, + "c_lose": 5164, + "]_)\n {\n ": 5165, + "5_ - ": 5166, + "c_ = 0; c": 5167, + "fab_s": 5168, + "local__B": 5169, + "omp target parallel for simd _simdlen(": 5170, + "G->_g": 5171, + "__ctx": 5172, + ")_.": 5173, + "2_d": 5174, + " =_ (-1": 5175, + "ex_act_": 5176, + "exact__solu": 5177, + "H_ash": 5178, + "avera_geR": 5179, + "average_G": 5180, + "average_B": 5181, + "ed_Image": 5182, + "; c3 <= ((((16 * c1) + 15) < (nm + (-1))) ? ((16 * c1) + 15) : (nm_ + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 5183, + "; c3 <= ((((16 * c1) + 15) < (n_j + (-1))) ? ((16 * c1) + 15) : (nj": 5184, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (n_m + (-1))) ? ((16 * c2) + 15) : (nm + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 5185, + "curr__p": 5186, + "->_v.": 5187, + " & m;\n _tmp = tmp": 5188, + "vo_t": 5189, + "omp target teams distribute parallel for _simd": 5190, + "A__i": 5191, + "for (j = 0; j < _N": 5192, + "eta_ * ": 5193, + "de_g": 5194, + " = _mm_load_u_ps(": 5195, + " = (_b": 5196, + "Pa_geRank": 5197, + "16 * _c0": 5198, + "2147_483647": 5199, + "rhs[m_][i][j][k] = ": 5200, + "B_[k][j]": 5201, + "__de": 5202, + " == 1_)\n ": 5203, + "(x)_;": 5204, + "[x_][y": 5205, + "]_;\n ": 5206, + "ou_r_": 5207, + "400) * ((8 * ((2000 - 1) / 8)) + 8_)) + (": 5208, + " * ((_8 * ((2000 - 1) / 8)) + 8": 5209, + "][5_ - 1]": 5210, + " + 1_)]": 5211, + "[i]_ + ": 5212, + "; i++)\n {\n _if (": 5213, + "(n_um_": 5214, + "ad_d_": 5215, + "ce_[1": 5216, + "][m] + (_xi": 5217, + "][m] + (xi_ * (ce[": 5218, + "][m] + (_eta * (ce[": 5219, + "][m] + (_zeta * (ce[": 5220, + "[10_37": 5221, + "b = _b": 5222, + ".tv__sec": 5223, + ") + i_] = ": 5224, + "s_ * ": 5225, + "; x_++)\n{\n ": 5226, + "omp parallel for simd _linear": 5227, + "\\n_\\n\", ": 5228, + "__z": 5229, + "mage->content_[i][j]": 5230, + "9_]": 5231, + " - _comz4": 5232, + ", _C": 5233, + ") - 1_;\n ": 5234, + "il_d": 5235, + "mask_edImage": 5236, + "diag_n": 5237, + " <= (m_m1 - 1); i1": 5238, + "96_9": 5239, + "] = _ntemp": 5240, + "]_) - ": 5241, + "[bid]_].": 5242, + "element__size": 5243, + "55_5": 5244, + "********_********": 5245, + "L_imit": 5246, + " <= 4_; m": 5247, + " << 4_) | ": 5248, + "atom_ic": 5249, + "}\n_}\n\n": 5250, + "s_;\n}\n": 5251, + "__int": 5252, + " ,_j": 5253, + "omp parallel for private_(x": 5254, + "dou_t": 5255, + "sum_, ": 5256, + "info_->": 5257, + "[k_][i": 5258, + "ro_o": 5259, + "local__C": 5260, + "mul_ti": 5261, + "t_Image": 5262, + "gr->vl_[i].": 5263, + "static _double ": 5264, + "C_[(i * ": 5265, + "++)\n{\n for (c2 = 0; c2_ <=": 5266, + "arg_v[": 5267, + ";\n _int ": 5268, + "n_)]": 5269, + " = %d_\\n\", ": 5270, + "; i++)_\n ": 5271, + "; i += _4)\n{\n ": 5272, + ";\n }\n\n _}\n else\n {\n ": 5273, + "(_double ": 5274, + "st_age": 5275, + "omp parallel for simd _aligned": 5276, + "_col_umn": 5277, + "o_k": 5278, + "])) + (_c2": 5279, + "])) + (_c3": 5280, + " * x_x": 5281, + "j_ + 1) * ": 5282, + "row__pointer": 5283, + "_h_ere": 5284, + "fa_ce[": 5285, + "point__no": 5286, + "[i + 1][ind_];\n ": 5287, + "b_1": 5288, + "wor_ld_": 5289, + "u[((2 * i3_) - ": 5290, + "u[((2 * i3) - _t3": 5291, + "u[((2 * i3) - t3_) - 1][((2 * i2": 5292, + ") - d_2": 5293, + ") - d2_) - 1][((2 * i1": 5294, + "[i3 - 1][i2 - 1_][i1 - 1]": 5295, + ") - _t1": 5296, + ") - _t2": 5297, + ") - t2_) - 1][((2 * i1": 5298, + "nn_2": 5299, + "; c3 <= ((((16 * c1) + 15) < (n_k + (-1))) ? ((16 * c1) + 15) : (nk": 5300, + "nm_) + (-1": 5301, + "u[((2 * i3_) - d3": 5302, + "u[((2 * i3) - d3_) - 1][((2 * i2": 5303, + " + _ni": 5304, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (n_j + (-1))) ? ((16 * c2) + 15) : (nj + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 5305, + "][2 * i_2": 5306, + "][(2 * i_1) + 1": 5307, + "][(2 * i_2) + 1": 5308, + "u[(_2 * i3": 5309, + "u[(2 * i3_) + 1": 5310, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t)))._B": 5311, + "]), (_vtype *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 5312, + " ^_ a": 5313, + "33_FF": 5314, + "AA_AA": 5315, + "7_A": 5316, + "000_F": 5317, + "3_B": 5318, + "C_9": 5319, + "key__perm": 5320, + "key_perm_ut": 5321, + "key_permut_ate": 5322, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj_ + (-1))) < (nl + (-1))) ? ((((": 5323, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nl + (-1))) ? ((((_16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj": 5324, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nl + (-1))) ? ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj_ + (-1))) : (nl": 5325, + " + (-1))) : (n_m + (-1))); c4++)\n {\n ": 5326, + "I_C": 5327, + ", _t": 5328, + "malloc_((sizeof(": 5329, + "for (i = 0; i < 2048_; i++)\n{\n for (j = 0; j < 2048": 5330, + ", int _m": 5331, + "dim_Y": 5332, + "e_ = ": 5333, + "threads_)": 5334, + "S_D.": 5335, + "2]_;\n ": 5336, + "[i_p": 5337, + "s[j]_ = ": 5338, + "uint8__t": 5339, + "no_t ": 5340, + "int *_b": 5341, + "*_j": 5342, + "ra_ck": 5343, + "rack_ed": 5344, + "t(_&": 5345, + "))_\n ": 5346, + "edge_List": 5347, + "atoi16[ARCH_INDEX(_ciphertext": 5348, + "cry_pt": 5349, + " / _8": 5350, + "}_;\n ": 5351, + "jtr_sha_512_": 5352, + "[(i * 1_000": 5353, + "c0_ = _mm_add_ps(": 5354, + "c0 = _mm_add_ps(_c0": 5355, + "S_rc": 5356, + ")))_;\n ": 5357, + "a_u": 5358, + "++)\n{\n _c": 5359, + "[i][j]_ = (": 5360, + "pro_cesse": 5361, + " + (_y * ": 5362, + "continue_;\n\n ": 5363, + "b_:": 5364, + "if (_j": 5365, + "[row_][col": 5366, + " + i)_;\n ": 5367, + "diff_erence": 5368, + "index_ = ": 5369, + ", &_status": 5370, + "omp parallel for default(none_) shared(": 5371, + "g_ap": 5372, + "now_ait": 5373, + "0.5) * _step": 5374, + "ri_al": 5375, + "s_3": 5376, + "i_, int *": 5377, + "j_));\n}\n\n": 5378, + "c_racked": 5379, + "][i][j][k]_ + ": 5380, + "JTR__A": 5381, + "JTR_A_ES": 5382, + "q_;\n ": 5383, + " - 1_] * ": 5384, + "29_496": 5385, + "at_or": 5386, + "bit_map": 5387, + "256_ * ": 5388, + "if_ntemp": 5389, + "test__index": 5390, + "test_index__array": 5391, + "]._hashNum": 5392, + "u__y": 5393, + "pro_c": 5394, + "for (i = 0; i < 1_00; i++)\n{\n ": 5395, + "ter_n": 5396, + " <_ (((": 5397, + " _)": 5398, + "input->_x": 5399, + "result_ = 0;\n ": 5400, + ":_ %d\\n\", ": 5401, + " * (sizeof(int_)));\n ": 5402, + "get_time": 5403, + "gettime_of": 5404, + "gettimeof_da": 5405, + " = j_ + 1": 5406, + "#pragma omp for_\n ": 5407, + "y_y * ": 5408, + "}_\n ": 5409, + "C_ + i": 5410, + "T_mp": 5411, + "}\n\n _}\n else\n {\n ": 5412, + "]_);\n ": 5413, + "7_2": 5414, + "k_nodes[": 5415, + "uni_que": 5416, + "F_ile": 5417, + "e__": 5418, + "a_[": 5419, + ")));\n _b = b": 5420, + "for (i = 0; i < n; i++)\n{\n for (j = 0; j < n_; j++)\n {\n ": 5421, + "linear(_b:": 5422, + " = (_k": 5423, + "for (i = 0; i < n_; ++i)\n{\n ": 5424, + "omp parallel for schedule(dynam_ic,1": 5425, + "tra_in": 5426, + ") /_ ((": 5427, + "ent_ries": 5428, + "for (i = 1; i <= (grid_points[0] - 2)_; i++)\n {\n ": 5429, + " + _x": 5430, + ")));\n _foo": 5431, + ")));\n foo_(&b": 5432, + ")));\n foo(&b_, &i": 5433, + "inline static void _foo(": 5434, + "inline static void foo(_int *b": 5435, + "inline static void foo(int *b_, int *": 5436, + "inline static void foo(int *b, int *_i, int *": 5437, + "inline static void foo(int *b, int *i, int *_j, int ": 5438, + "inline static void foo(int *b, int *i, int *j, int _x)\n{\n ": 5439, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n _*b": 5440, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b_ = (((": 5441, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((_*b": 5442, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b_) + x": 5443, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x_) + ((*": 5444, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*_i": 5445, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i_) - (*": 5446, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*_i": 5447, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i_))) + ((": 5448, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((_*j": 5449, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((*j_) - (*": 5450, + "inline static void foo(int *b, int *i, int *j, int x)\n{\n *b = (((*b) + x) + ((*i) - (*i))) + ((*j) - (*_j));\n}\n\n": 5451, + "d_neto": 5452, + "b_yte": 5453, + "_per__": 5454, + "m1]_))) + (": 5455, + "2)_;\n ": 5456, + "f_1_layer[o": 5457, + "ang * _ng": 5458, + "snakes[j]._head.": 5459, + "start_ = ": 5460, + "e_assign": 5461, + "vl_[i].": 5462, + "#_#": 5463, + "; c4 <= ((((16 * c2) + 15) < (n_l + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk": 5464, + "for (c2_ = ((": 5465, + "[l_36": 5466, + "7_) | (": 5467, + ")))) + (0.020408_ * (*(((*((": 5468, + "col = col + 4;\n }\n\n _#pragma omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 5469, + "d_len_p": 5470, + "3_,": 5471, + "; _r": 5472, + "[(_x * ": 5473, + "-_c": 5474, + "(n_um": 5475, + "out_[": 5476, + "for (i = 0; i < 8192_; i++)\n{\n ": 5477, + "; ++j_)\n ": 5478, + "for (int i = 0; i < N_; i++)\n{\n ": 5479, + "l_->": 5480, + "->_tab": 5481, + ")))_;\n": 5482, + ", _temp": 5483, + " _th": 5484, + ";\n }\n\n }\n\n _if (": 5485, + "x = 0; _x < ": 5486, + ", _tmp": 5487, + "b[i]_;\n}\n": 5488, + "[i][j]_ = i": 5489, + "1_F": 5490, + " +_=": 5491, + "start_ing": 5492, + "for (j = 1; j <= (grid_points[1] - 2)_; j++)\n {\n ": 5493, + "for (i = 0; i < 512_; i++)\n{\n for (j = 0; j < ": 5494, + "for (i = 0; i < 512; i++)\n{\n for (j = 0; j < _512": 5495, + "m_ed": 5496, + "pass_word": 5497, + ");\n _sph_sha1": 5498, + "_sq_r": 5499, + "L_in": 5500, + "[_position": 5501, + "B_1": 5502, + "29496_729": 5503, + "29496729_5": 5504, + "294967295_U": 5505, + "ch_ild": 5506, + "y_[l36": 5507, + "*((_MD5_std_combined *) (((char *) MD5_std_all_p) + t))).": 5508, + "E_E": 5509, + "]);\n _tmp": 5510, + "2_12": 5511, + "for (int i = 0; i < g->N_; i++)\n{\n ": 5512, + "for (int i = 0; i < g->N; i++)\n{\n _node *": 5513, + "elem_at(&g->vertices_, i);\n ": 5514, + "#pragma omp simd_\n ": 5515, + "c_->": 5516, + " >= _1": 5517, + "%_s": 5518, + ") _reduction (+:": 5519, + "omp parallel for collapse(_2": 5520, + ")))_\n {\n ": 5521, + "m;\n _k": 5522, + ")_[i]": 5523, + ", _4)": 5524, + " + 1_); ": 5525, + ")_\\n\", ": 5526, + ") reduction(+:_sum)": 5527, + "I_d": 5528, + ";\n _}\n else\n ": 5529, + "struct time_val": 5530, + "ow_(": 5531, + "omp parallel for schedule(static_)": 5532, + "p_2": 5533, + "sph_sha1__context ": 5534, + "xx_ * xx": 5535, + ":_%": 5536, + "char_ *) (&": 5537, + "r_[j]": 5538, + "f_unc": 5539, + "veloc_ity": 5540, + "lhs[j_][i": 5541, + "h_prime": 5542, + "30_30": 5543, + "_m_utex": 5544, + "][0]))), (*((vtype *) (&_(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).E.E": 5545, + "dev_ice": 5546, + " - 1_) - 1)": 5547, + "size_; j++)\n {\n ": 5548, + "C_h": 5549, + "for (i1_ = 1; i": 5550, + "for (i1 = 1; i_1": 5551, + "y_ - ": 5552, + " = i_ * ": 5553, + "));\n _mm_store_u_ps(": 5554, + "co_s": 5555, + " =_= (n": 5556, + ") num_threads_ (": 5557, + "sizeo_f": 5558, + "Di_mension": 5559, + "0)_\n {\n ": 5560, + ")) :_ ((": 5561, + "rhs[m][i][j][k] = _rhs[m": 5562, + "P_tr": 5563, + "gettimeofda_y(&": 5564, + "u_sec": 5565, + "[j]_ - ": 5566, + "g_lobal": 5567, + "ree_(": 5568, + "0_][i][j][k] = lhs[": 5569, + "1_][i][j][k]": 5570, + "lhs[_2": 5571, + "for (i = 1; i < (_5 - 1)": 5572, + "u[_3": 5573, + " + (N_CELL_ENTRIES * ((0 + (0 * (1 * 100_))) + (((": 5574, + "][ii_ + (jj * params.nx)]": 5575, + "flo_or": 5576, + ");\n _lhs[i][j][k": 5577, + "road_cast": 5578, + "256 * _256": 5579, + "512 * _512)": 5580, + "ue_[4": 5581, + "__order": 5582, + "u[_2 * i3": 5583, + "temp_4": 5584, + "temp_5": 5585, + "temp_6": 5586, + "spe_ed_": 5587, + "V_ec": 5588, + "N_K": 5589, + "] + _b": 5590, + "memcp_y": 5591, + "s_, int ": 5592, + "s_on": 5593, + " > _nl": 5594, + "omp parallel for _lastprivate": 5595, + "input->_d": 5596, + " = 0; i_3": 5597, + "(_seed": 5598, + "alpha_ * ": 5599, + "uint8__t *": 5600, + "for (l_ = 0; l": 5601, + "; c3 <= ((((16 * c1) + 15) < (n_i + (-1))) ? ((16 * c1) + 15) : (ni": 5602, + "um_ent": 5603, + "matrix_->nb": 5604, + "_p_d(": 5605, + "un_ion": 5606, + ", _sum": 5607, + "sph_ere": 5608, + "[i] = (_double": 5609, + " _ ": 5610, + "1.0 - (_xx * xx": 5611, + "yy * _yy": 5612, + "s[_m": 5613, + " + (N_CELL_ENTRIES * ((_x + (": 5614, + " + (N_CELL_ENTRIES * ((x + (_y": 5615, + " + (N_CELL_ENTRIES * ((x + (y_ * (1 * 100": 5616, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100_))) + ((": 5617, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((_z": 5618, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((z_ * (1 * 100": 5619, + " + (N_CELL_ENTRIES * ((x + (y * (1 * 100))) + ((z * (1 * 100_)) * (1 * 100))))": 5620, + "idmo_[iel][face": 5621, + "ri_ce": 5622, + " = x_0": 5623, + "i)_;\n}\n": 5624, + "filter_list_[y": 5625, + "j_k": 5626, + "commun_ity": 5627, + "rand_48": 5628, + "B_4": 5629, + "ti_ty": 5630, + "B_lock": 5631, + "25_0": 5632, + "en_cryp": 5633, + "add_r": 5634, + "newe[iel_] = ": 5635, + "newe[iel] = _newe[iel": 5636, + " == 3_) && (": 5637, + "[(_indx": 5638, + " = i_del": 5639, + " = idel_[ie][iface": 5640, + "F_(": 5641, + "i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni_ + (-1)) / 16)) <": 5642, + " + (-1)) / 16))) ? ((((n_i + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni": 5643, + " + (-1)) / 16))) ? ((((ni + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(ni + (-1))) + 16) + 1) / 16)) : (-((((-(ni + (-1))) + 16) - 1) / 16))) : ((ni_ + (-1)) / 16)) :": 5644, + "*_ha": 5645, + "*ha_ = ": 5646, + "Knode_[bid]].": 5647, + "b_ack": 5648, + ";\n }\n\n #pragma omp simd\n for (c4 = _nj": 5649, + "-2) * _c3) + ": 5650, + ";\n vtype x_4": 5651, + " = a_6": 5652, + "(png_, ": 5653, + "B[c3][c4] = (((double) c3) * (c4 + 1)) / nj_;\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 5654, + "temp_7": 5655, + "temp_0": 5656, + "] = __mm512_set1_ps(": 5657, + "c1_ * ": 5658, + "for (k = 0; k_ < n": 5659, + "sor_ted_": 5660, + "elaps_ed": 5661, + "P_P": 5662, + "[i][j]_;\n }\n\n}\n": 5663, + "__B": 5664, + "]_ != ": 5665, + " _h": 5666, + "dat_len": 5667, + "T_ype": 5668, + "P_os": 5669, + "; i_ter": 5670, + " - (_4.0 * ": 5671, + "data_ = ": 5672, + "__P": 5673, + "block__size": 5674, + "john_MD5__Update": 5675, + "ER_R": 5676, + "ERR_OR": 5677, + "++_;\n}\n": 5678, + "edge_s": 5679, + "\\t_\", ": 5680, + "asser_t(": 5681, + "c_at": 5682, + "E_dge": 5683, + " (_*": 5684, + "Se_t->": 5685, + "ff_).": 5686, + ") :_ (-": 5687, + "]_))": 5688, + "; _fi": 5689, + "gra_m": 5690, + " << 4) | _atoi16[ARCH_INDEX(p": 5691, + "#pragma omp _atomic": 5692, + "im_um": 5693, + "sal_t->": 5694, + ") _schedule (": 5695, + ";\n\n _}\n\n ": 5696, + "[i]._x": 5697, + "re_v": 5698, + "cop_y": 5699, + " = ((((_DATA_TYPE) i": 5700, + " *) _calloc(": 5701, + "row_ = ": 5702, + "0_:": 5703, + "1.0 - (_yy * yy": 5704, + "dou_to": 5705, + "][i_][j]": 5706, + "ve_t": 5707, + "4_.": 5708, + ") + k_m0": 5709, + "I_dx": 5710, + "newe[iel] = newe[iel_] + 1": 5711, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (_i": 5712, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (i_ * ((8 * ((2000 - 1) / 8)) + 8": 5713, + ".r_;\n double ": 5714, + "_mm256__b": 5715, + "_mm256_b_roadcast": 5716, + "_mm256_broadcast__s": 5717, + "po_si": 5718, + "lin_ha": 5719, + "); c4_++)\n {\n ": 5720, + "1010_1010": 5721, + "C_3": 5722, + "[i]._bit._": 5723, + "in_iti": 5724, + "w_eigh": 5725, + "ou_ter": 5726, + "for (m = 0; m_ <= 4; m": 5727, + ") + k]_) * ": 5728, + "for (i = 0; i < 10000_; ++i)\n{\n ": 5729, + "))_;\n }\n\n ": 5730, + "])_\n ": 5731, + ")) /_ ((double) ": 5732, + "mat_->": 5733, + "lide__grid": 5734, + "for (i = 0; i < 1024_; i++)\n{\n for (j = 0; j < 1": 5735, + "for (i = 0; i < 1024; i++)\n{\n for (j = 0; j < 1_024": 5736, + "p_ad": 5737, + " * _re": 5738, + "u[_2": 5739, + "s[(ii * params.nx_) + jj].speeds[": 5740, + " *_ (n": 5741, + "vertex__id": 5742, + "7_5": 5743, + "selec_ted": 5744, + "data_Set": 5745, + "_f_ree(": 5746, + "E_nd": 5747, + "private[i]._d_": 5748, + "sqrt_(i": 5749, + "omp parallel for schedule(SCHEDULING_METHOD_)": 5750, + "fi_ = 0; ": 5751, + "fi = 0; _fi": 5752, + "fi = 0; fi_ < 1": 5753, + "fi = 0; fi < 1_0.0": 5754, + "fi = 0; fi < 10.0_; fi": 5755, + "fi = 0; fi < 10.0; fi_++)\n{\n c": 5756, + "fi = 0; fi < 10.0; fi++)\n{\n c_[(int) fi": 5757, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi_] = a": 5758, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a_[(int) fi": 5759, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi_] + b": 5760, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi] + b_[(int) fi": 5761, + "fi = 0; fi < 10.0; fi++)\n{\n c[(int) fi] = a[(int) fi] + b[(int) fi_];\n}\n": 5762, + "}\n\n\n_\n": 5763, + "weight_s[": 5764, + "array_Y": 5765, + "mar_k": 5766, + "][i][j_2": 5767, + ";\n _if (": 5768, + "_c_lose": 5769, + "col_, ": 5770, + "tab_lo": 5771, + "F_A": 5772, + "cs_.": 5773, + "un_a": 5774, + "struct timeval_ ": 5775, + "OMP_xMax_; x": 5776, + "C_ent": 5777, + "[_d": 5778, + "b_v_size": 5779, + "b_v[": 5780, + "s_[i][j]": 5781, + "R_O": 5782, + "fprintf(st_dout": 5783, + "p_.": 5784, + "ran_ge": 5785, + "exact_solu_tion(": 5786, + "arr_[": 5787, + ") - 1_] * nu;\n u[": 5788, + ") + 1_] * nu;\n u[": 5789, + "__end": 5790, + "ex_change": 5791, + "d_w": 5792, + "));\n c00 = _mm_add_ps(c00_, _mm_mul_ps(a": 5793, + ") + _A": 5794, + "child_ren": 5795, + "ic_i": 5796, + " + (-1))) : (nm_ + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((((": 5797, + " + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (n_k + (-1))) ? ((16 * c2) + 15) : (nk + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 5798, + ") <_ ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))) ?": 5799, + "); c4_ <= ((((16 * c2) + 15) < (n": 5800, + "con_4": 5801, + ") + 1_;\n ": 5802, + ";\n _uint32_t ": 5803, + "all_/": 5804, + "v_2": 5805, + "j_;\n ": 5806, + "FP_NUMBER_) ": 5807, + " + (_i": 5808, + "for (int j_j = 0; j": 5809, + "; col_++)\n {\n ": 5810, + "diff_;\n double ": 5811, + "[k_][j][i]": 5812, + "->_entries": 5813, + "->entries_ + (": 5814, + "[_5]": 5815, + "i_ - 1) * ": 5816, + "0_);\n ": 5817, + "num__hf": 5818, + "[i]_; j < ": 5819, + " / _2;\n ": 5820, + "local_A_->n_bar": 5821, + ") + _l": 5822, + "m_x": 5823, + "output__array[x": 5824, + "nx_) * ny": 5825, + "++_;\n\n ": 5826, + "_par_tition": 5827, + "rand_lc": 5828, + "Q_ue": 5829, + "po_le": 5830, + "__dest": 5831, + "snake_s[i].": 5832, + "block__width": 5833, + "tag__h": 5834, + "2 * _c3": 5835, + "ij_k": 5836, + "ic_k": 5837, + ") + k] * _B": 5838, + "omp distribute parallel for simd _aligned": 5839, + "[_src": 5840, + " = 0; _r": 5841, + "A[c1][c2] = (((double) c1) * c2) / ni_;\n ": 5842, + "]._neighbor": 5843, + "k_ - 1": 5844, + "[i1]_ = ((": 5845, + "[i1_ + 1]": 5846, + "_ptr_)": 5847, + "time_ = ": 5848, + "._val": 5849, + "u_th": 5850, + "\"_, \"": 5851, + "pre_v": 5852, + "]_;\n int i": 5853, + "ori_a": 5854, + "z.r_ * z": 5855, + "}_;\n ": 5856, + "4_]": 5857, + "[(i * N_J": 5858, + "[(i * 1024_) + j]": 5859, + "i_sh": 5860, + "mem_cmp(": 5861, + "p_; ": 5862, + "_a_ux": 5863, + "2__g": 5864, + "[(_col * ": 5865, + "large_st_": 5866, + "vi_de": 5867, + "][_ti": 5868, + "#pragma omp flush_\n ": 5869, + " == 3) && (_sje[ntemp": 5870, + ") - 1_] + (": 5871, + "][i1 - 1]_) + z": 5872, + "_p_article": 5873, + "T_4": 5874, + " = _box": 5875, + "tmor_[ig": 5876, + "je_1": 5877, + "E_6": 5878, + ") + n_) + 1": 5879, + "eta_) * ": 5880, + ")) = zero_;\n *((vtype *) (((long *) (&(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B[": 5881, + ")) ^_ (": 5882, + "32__t ": 5883, + "ti_l": 5884, + "sum_ = 0.0;\n ": 5885, + ");\n _if (!": 5886, + "z_[j]": 5887, + "#pragma _omp parallel for private(c2": 5888, + "[i][j]_ * ": 5889, + "++_;\n\n ": 5890, + "s_g": 5891, + "n_ * ": 5892, + "__length": 5893, + "#pragma omp ordered_\n ": 5894, + "s[i]_;\n ": 5895, + ")) _&": 5896, + "i0_ = i": 5897, + "en_cod": 5898, + "s_z": 5899, + "in_ate": 5900, + "c_[i] = ": 5901, + "saved__len": 5902, + "public.in2__sub": 5903, + "vide_o": 5904, + " == _c2": 5905, + "[_r": 5906, + "mo_d": 5907, + "7_50": 5908, + "400) * ((8 * ((2000 - 1) / 8)) + 8)) + (i * ((8 * ((2000 - 1) / 8)) + 8_))": 5909, + "new__centroid": 5910, + "hal_o": 5911, + "edge__label": 5912, + "ue_[1": 5913, + "ue_[2": 5914, + "ue_[3": 5915, + "[_element_size": 5916, + "cell_s[((": 5917, + "Cou_nter": 5918, + "b_, ": 5919, + ")_; i++)\n ": 5920, + "V_ertex": 5921, + "nz_a": 5922, + "exit(_1": 5923, + ";\n int i_2": 5924, + " > nk_) ? (nj) : (n": 5925, + " > nk) ? (nj) : (n_k": 5926, + "gr_ou": 5927, + "omp parallel for reduction(+: l) collapse(_3)": 5928, + "omp parallel for reduction(+: l) collapse(3_) schedule(runtime)": 5929, + "ker_n_": 5930, + "crypt_out_[index": 5931, + "Thread_s": 5932, + "[col]);\n _col = col + 4;\n}\n": 5933, + "._j": 5934, + " %_s": 5935, + ")) + _3": 5936, + "rand() % 1_0": 5937, + "for (i = 0; i < 10_; i++)\n{\n ": 5938, + "rhs[m_][i][j][k]": 5939, + ", int i, int _j, int ": 5940, + ", _index": 5941, + " / _4) * ": 5942, + "=_=": 5943, + "num_thread_s = omp_get_num_threads(": 5944, + " + (_1 * ": 5945, + ") + (_d": 5946, + "[j_ - 1]": 5947, + ") / _2": 5948, + "a[i]_ * ": 5949, + "(_j": 5950, + "for (size_t _i = 0; i < ": 5951, + "rowstr_[j]": 5952, + "graph_ *": 5953, + "fprintf(stdout_, \"": 5954, + "size__": 5955, + "iteration_s": 5956, + "switch_ (": 5957, + "break_;\n\n ": 5958, + "[(i * N_Y) + j]": 5959, + "num__team": 5960, + "1__g": 5961, + "A_[i": 5962, + " = (_x": 5963, + "omp parallel for reduction(+: l) collapse(3_) schedule(static, 2)": 5964, + "t_p": 5965, + "ind_ + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 5966, + "dEo_11": 5967, + "dEo_22": 5968, + "chunk__idx": 5969, + "for (int i = 0; i < _3": 5970, + "][ti_].": 5971, + "3 * _h": 5972, + "con_ver": 5973, + "4_294967295U": 5974, + " = (_tmp1 * 2.0) * njac": 5975, + " = (_tmp2 * fjac": 5976, + "3276_8": 5977, + "it_Image": 5978, + "buffer__": 5979, + "T_1;\n ": 5980, + " ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))_); c2++)\n {\n for (c3 = 16 * c1": 5981, + "; c3 <= ((((16 * c1) + 15) < (nj + (-1))) ? ((16 * c1) + 15) : (nj_ + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nm + (-1))) ? ((16 * c2) + 15) : (nm + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 5982, + "nk_ + ni": 5983, + ") + _nj": 5984, + "data_.": 5985, + "3_2 * c0": 5986, + ") + _29": 5987, + "5A_0F": 5988, + "D_2": 5989, + "B_6": 5990, + ";\n vtype x_11": 5991, + "33CC_33CC": 5992, + "55_AA": 5993, + "C0_C0": 5994, + "7B_7B": 5995, + "5A_55": 5996, + "_mm256_broadcast_s_s(&": 5997, + ".._..": 5998, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) <_ ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl": 5999, + "j + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) < ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl_ + (-1)) / 16))) ? ((((nj + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nj + (-1))) + 16) + 1) / 16)) : (-((((-(nj + (-1))) + 16) - 1) / 16))) : ((nj + (-1)) / 16)) :": 6000, + " <= ((_16 * c2) + 15": 6001, + " <= ((16 * c2) + 15_); c4++)\n {\n ": 6002, + "7_))) ^": 6003, + "7))) ^_ ((": 6004, + "))_)) ^ (": 6005, + "thread__l": 6006, + ") collapse(_2)": 6007, + "2_,": 6008, + "_output_FromGpu": 6009, + "tmp_ += ": 6010, + "key_s": 6011, + "for (i = 0; i < N_X": 6012, + "for (j = _k": 6013, + "th_er": 6014, + " _0.0": 6015, + "omp_get_thread_num(_)": 6016, + "0000000_; j++)\n ": 6017, + "(_t": 6018, + "y_[i]": 6019, + "_h_mac": 6020, + "hash_ = ": 6021, + "}\n _else": 6022, + ")) _|": 6023, + "R_and": 6024, + "][4_] = ": 6025, + ".0_;\n ": 6026, + "1_'": 6027, + "ro_n": 6028, + "compute__t": 6029, + "s[_thread": 6030, + "coe_f": 6031, + "unsigned _long ": 6032, + ") + (_3 * ": 6033, + "][0]_))) ^ (*((vtype *) (&k[": 6034, + "3__r": 6035, + "2__r": 6036, + "1__r": 6037, + "4, _8)": 6038, + ";\n}\n\n_void ": 6039, + "for (int i = 0; i < _64": 6040, + "[i - 1_][j - 1]": 6041, + "elem_at(&g->vertices, i);\n _payload *": 6042, + ", \"_\\n\");\n}\n": 6043, + "ter_min": 6044, + "sum_ += (": 6045, + "4_ 4)": 6046, + "foo(_))": 6047, + "#pragma omp parallel for private(c2_ )\n ": 6048, + "dist__": 6049, + "[j]_);\n }\n\n}\n": 6050, + "omp parallel for firstprivate_(i": 6051, + ") lastprivate_(i": 6052, + "for (i = 0; i < _2": 6053, + "2._5)": 6054, + "4, _, 4)": 6055, + "q_->": 6056, + "E_-": 6057, + "4, _)": 6058, + "m_; i++)\n{\n ": 6059, + "N_O": 6060, + "ff_f": 6061, + "ctx_;\n ": 6062, + "._3": 6063, + "-_5)": 6064, + "c3_c4": 6065, + "struct _tablo": 6066, + "hash = _hf": 6067, + "hash = hf_[j]": 6068, + "hash = hf[j]_(": 6069, + "hash_ %= ": 6070, + "hash %= _bv_size": 6071, + "lhs[n + 4_][i][j][k": 6072, + "])_]": 6073, + " + 1_;\n": 6074, + " = (_i": 6075, + "tex_t": 6076, + " =_ (n": 6077, + ";\n _}\n else\n ": 6078, + "B_y": 6079, + "el_i": 6080, + "mage_[indx": 6081, + " = __mm256_": 6082, + "p_ed_": 6083, + " >> _2": 6084, + "));\n _c0 = _mm_add_ps(c0": 6085, + "ray__": 6086, + "6__g": 6087, + "omp parallel for default(none_) private(i": 6088, + "C_[i]": 6089, + "for (int i = 0; i < _size; i++)\n{\n ": 6090, + "for (int j = 0; j < _N": 6091, + ")\n _return 1;\n\n": 6092, + "for (int i = 1; i_ < ": 6093, + "sum += _sqrt(i": 6094, + "[x_ + (y * ": 6095, + " - 1); i_3": 6096, + "s[i]_, ": 6097, + "C_K": 6098, + ") +_ (n": 6099, + "up_per": 6100, + "label_path": 6101, + ", y_, z": 6102, + " - 1_) * (": 6103, + "(_double x": 6104, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + x_;\n}\n\n\nint ": 6105, + "for (z = 0; z_ < ": 6106, + "2_ * 1": 6107, + "m_is": 6108, + "St_at": 6109, + ";\n _}\n\n ": 6110, + " + 1_;\n ": 6111, + "#pragma _ce": 6112, + "#pragma ce_t": 6113, + "#pragma cet_us": 6114, + "4_ - ": 6115, + ")) -_ ((": 6116, + "] = _input_array[x": 6117, + "ne_ss": 6118, + "_c_omp": 6119, + "O_nes": 6120, + "mat_B": 6121, + "dim__cpu": 6122, + "dim_cpu_.": 6123, + "if (c1_ == c2": 6124, + "grid_points[_1]": 6125, + "grid_points[_2]": 6126, + "*_p": 6127, + " for_ ": 6128, + " = (_i * ": 6129, + "]_;\n double ": 6130, + "for (i2_ = 1; i": 6131, + "for (i2 = 1; i_2": 6132, + "di_ameter": 6133, + "lo_ne": 6134, + "atoi16[ARCH_INDEX_(*": 6135, + "omp parallel for shared_ (": 6136, + "[i]_ = ((": 6137, + "S_or": 6138, + "__curr": 6139, + ")_, (": 6140, + "A[(i * _8192": 6141, + " = _m": 6142, + "OMP__z": 6143, + "OMP_z_Max": 6144, + "0.5_)\n {\n ": 6145, + "5_ + (": 6146, + " of _the ": 6147, + "n__grid": 6148, + "num_p_article": 6149, + "0.5) * step_;\n ": 6150, + ", 1_, (MPI_Datatype) 0x4c00040": 6151, + "L_, ": 6152, + ")_; i++)\n {\n ": 6153, + "(int _n": 6154, + "bv[_hash": 6155, + "Matrix_(": 6156, + "for (i = 1; i <= 10_; i++)\n{\n ": 6157, + "par_ent": 6158, + "omp parallel for reduction(+:sum_) schedule(static,": 6159, + "u[_0]": 6160, + "0]_;\n ": 6161, + "fin_ish": 6162, + "g_lob": 6163, + "r_at": 6164, + "25_ * (((": 6165, + "xyzInd_ + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 6166, + "private._point_no": 6167, + "][_t": 6168, + "n_ang * ng": 6169, + "m_om": 6170, + "__state": 6171, + ") + (j * _size": 6172, + "temp_U": 6173, + "[iel_][3": 6174, + ")) :_ (": 6175, + "set_lock(&tlock[ig_])": 6176, + "E_n": 6177, + "t_t": 6178, + "; c3 <= ((((16 * c1) + 15) < (nk + (-1))) ? ((16 * c1) + 15) : (nk_ + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))); c4++)\n {\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 6179, + "m__free(": 6180, + "zeta_) * ": 6181, + "ce_nt_": 6182, + "if (c1 == c2_)\n {\n ": 6183, + "if (c1 == c2)\n {\n _#pragma omp simd\n ": 6184, + ") + _0x": 6185, + "for (i = 0; i < 20; ++i)\n{\n _dsum += ": 6186, + "for (i = 0; i < 20; ++i)\n{\n dsum += _pow(dt, i);\n}\n": 6187, + "bo_t": 6188, + "for (int i = 0; i < 1_024": 6189, + " >>_ (": 6190, + ";\n _C": 6191, + "for (_n = 0; n": 6192, + "r_ = 0; r": 6193, + "[i3 - 1][i2 - 1_][i1]": 6194, + "/_ho": 6195, + "/ho_me": 6196, + "/home_/": 6197, + "/home/_ree": 6198, + "/home/ree_mh": 6199, + "/home/reemh_/": 6200, + "/home/reemh/_CL": 6201, + "/home/reemh/CL_PP": 6202, + "/home/reemh/CLPP_/": 6203, + "/home/reemh/CLPP/_g": 6204, + "/home/reemh/CLPP/g_ith": 6205, + "/home/reemh/CLPP/gith_ub": 6206, + "/home/reemh/CLPP/github_-c": 6207, + "/home/reemh/CLPP/github-c_lone": 6208, + "/home/reemh/CLPP/github-clone_-": 6209, + "/home/reemh/CLPP/github-clone-_all/": 6210, + "/home/reemh/CLPP/github-clone-all/_re": 6211, + "/home/reemh/CLPP/github-clone-all/re_pos_": 6212, + "/home/reemh/CLPP/github-clone-all/repos__final": 6213, + "/home/reemh/CLPP/github-clone-all/repos_final_/": 6214, + "j_)\n {\n ": 6215, + "__O": 6216, + "size_, ": 6217, + "break_;\n }\n\n}\n": 6218, + "2.0_ * (": 6219, + "y_ * (": 6220, + ") reduction(+:_ ": 6221, + "1.0_ / ": 6222, + " %_lf": 6223, + "[(i * N_L": 6224, + "a[i]_;\n}\n": 6225, + " <= (((_(((((": 6226, + "Lo_cal": 6227, + "; j_--": 6228, + "i_sect": 6229, + ");\n _if (": 6230, + "for (i = 1; i <= 10; i++)\n{\n _product *= ": 6231, + "for (i = 1; i <= 10; i++)\n{\n product *= _i;\n}\n": 6232, + "0_) * ": 6233, + "__K": 6234, + "1_ = (": 6235, + "_h_eight": 6236, + ") == 0_)\n ": 6237, + "; ++i)\n{\n _diff = diff - i": 6238, + "; ++i)\n{\n diff = diff - i_;\n}\n": 6239, + "ch_k": 6240, + "[0_][i": 6241, + "world_->": 6242, + " == 0_)\n {\n ": 6243, + "k_ = 0; k": 6244, + "dcomp_lex ": 6245, + ") == _1": 6246, + ")))_) + ((": 6247, + " = ((double) _i": 6248, + "for (i = 0; i < 20; ++i)\n{\n _ddiff -= ": 6249, + "for (i = 0; i < 20; ++i)\n{\n ddiff -= _pow(dt, i);\n}\n": 6250, + "u_[k][j][i": 6251, + "_sq_u": 6252, + "set_up": 6253, + "gam_ma": 6254, + "33_0": 6255, + "_po_ol": 6256, + "(*((_MD5_std_combined *) (((char *) MD5_std_all_p) + t))).": 6257, + "kern__cent_": 6258, + "4__r": 6259, + "vertices->_out_degree": 6260, + "sorted__edges_array": 6261, + "us_ed": 6262, + "x_[i": 6263, + " <= (((_((": 6264, + "for (int j = 0; j < n_; j++)\n ": 6265, + "add_ed": 6266, + "m_; j++)\n{\n ": 6267, + "[i][j]_ = ((": 6268, + "flux_[i][j][k": 6269, + "if (((_(i": 6270, + "0_) += (*((A + i) + k": 6271, + "(_0": 6272, + "][i][j1_][k]": 6273, + " - (lhs[n_ + 0": 6274, + "stat_ic,1": 6275, + "))_\n ": 6276, + "r_ * ": 6277, + " + 1]_ - ": 6278, + "0_)\n {\n ": 6279, + "Node_s[i].": 6280, + ") + j] = (((DATA_TYPE) i_) * (j": 6281, + "sum = sum + i_2": 6282, + ")) >_ (((": 6283, + "sec_tion": 6284, + "M_e": 6285, + ") + _offset": 6286, + " -_1": 6287, + "for (j = 0; j < _5": 6288, + "matrix__size": 6289, + "crypt_out_[index], ": 6290, + "->_p": 6291, + "stats->_vector": 6292, + "omp parallel for reduction(+:sum) schedule(static,_7": 6293, + "s_ome": 6294, + "][i][j][k] - (dssp_ * (((": 6295, + "test_s": 6296, + "are_a": 6297, + "][i1_][j][k]": 6298, + " / _2)": 6299, + ")) /_ ((": 6300, + "low_) - 1;\n ": 6301, + ";\n _else\n ": 6302, + "));\n *((C + i) + _m": 6303, + "for (int i = 0; i < x; i++)\n for (int i = 0; i < y; i++)\n _;\n\n": 6304, + "_s_rc": 6305, + "sum = sum + (_i + i": 6306, + "ol_d_": 6307, + "mask_Matrix": 6308, + " >> 1_3": 6309, + "256 * 256_)) + ((": 6310, + "f_, ": 6311, + "512 * 512)_) + ((": 6312, + "512)_) + (": 6313, + "old_Distance": 6314, + "n_3": 6315, + "INT__TYPE": 6316, + ") + i_mage->content": 6317, + "_b_4": 6318, + "dsum_)": 6319, + "for (i = 0; i < _rows": 6320, + "*(_p": 6321, + ") shared_(n": 6322, + "omp parallel for reduction(+:sum_) schedule(": 6323, + "6_.0": 6324, + ")\n {\n _if (": 6325, + "NUM__THREADS": 6326, + " = 0.5_;\n double ": 6327, + ",_y": 6328, + "5 - _5)": 6329, + ")]_ += ": 6330, + "7_ffff": 6331, + "7ffff_fff": 6332, + "arg_c": 6333, + "send__": 6334, + "val_1 - val2": 6335, + "/_ ": 6336, + "p_red": 6337, + " = _2": 6338, + ");\n _double ": 6339, + "argv[i]_, \"": 6340, + ", n_);\n ": 6341, + ";\n }\n\n _}\n\n }\n\n ": 6342, + "st_ack": 6343, + "g_it": 6344, + ", i)_;\n ": 6345, + ":_ %f": 6346, + "break_;\n\n ": 6347, + "_chunk_.x": 6348, + "0_) : (": 6349, + "sal_t_": 6350, + "key__array": 6351, + "2]_ * ": 6352, + "e_s_": 6353, + "_c_nt": 6354, + ";\n _vtype ": 6355, + "); c2_ <=": 6356, + ") private_(x)": 6357, + " + 2_) * ": 6358, + "omp parallel for ordered_ ": 6359, + "D_B": 6360, + "image->_col": 6361, + "c_[j]": 6362, + ") + _6": 6363, + ");\n }\n\n _}\n\n}\n\n": 6364, + " + ((_i": 6365, + "-_2": 6366, + ";\n int _y": 6367, + "8_; j++)\n{\n ": 6368, + " = (((_((((": 6369, + ";\n\n_}\n\n\n": 6370, + "5_.0 * ": 6371, + "hz_[(i * 2048) + j]": 6372, + " = (_2 * ": 6373, + "(_S": 6374, + "*:product_)": 6375, + ")\n _continue": 6376, + "start_[0]": 6377, + " = (-1_.0": 6378, + ";\n register _int ": 6379, + " = (_char *) (&": 6380, + "mem_cnt": 6381, + "loop_ ": 6382, + ";\n _}\n\n }\n\n }\n\n}\n\n": 6383, + "3_.0 * ": 6384, + "] += _u[(": 6385, + "OMP_xMax) + OMP_xMax_] += u[": 6386, + "] += u[_((((": 6387, + "[_(n": 6388, + "queue_(": 6389, + "[(((_offset": 6390, + "[(((offset_ * size": 6391, + "-_16": 6392, + "omp parallel for reduction(+:sum_) private(i": 6393, + "5_;\n x": 6394, + "channel_s": 6395, + "V_F": 6396, + "face_a_[itemp]": 6397, + "N_ame": 6398, + "for (c2 = 0; c2_ <= ((((((n": 6399, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) <_ ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))) ?": 6400, + "k + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) < ((((nl + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nl + (-1))) + 16) + 1) / 16)) : (-((((-(nl + (-1))) + 16) - 1) / 16))) : ((nl + (-1)) / 16))) ?_ ((((nk + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nk + (-1))) + 16) + 1) / 16)) : (-((((-(nk + (-1))) + 16) - 1) / 16))) : ((nk + (-1)) / 16)) :": 6401, + "; c3 <= ((((((_16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni": 6402, + "ax_p": 6403, + "[i][_1": 6404, + "s[_th": 6405, + "s[th_id]": 6406, + "_pool_->": 6407, + "16 * _c8": 6408, + "C_;\n vtype x": 6409, + ";\n vtype x_21": 6410, + ";\n vtype x_30": 6411, + "31_;\n x": 6412, + ";\n x_30": 6413, + " = x_30": 6414, + "33_66": 6415, + "3CC_3C": 6416, + "1_A": 6417, + "0F_0FF": 6418, + "0F0FF_0F0": 6419, + "); c3_ <= ((((16 * c1) + 15) < (n": 6420, + "; c4_ <= ((16 * c2) + 15); c4++)\n {\n ": 6421, + ")) ? (((_nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj": 6422, + ")) ? (((nj * 16) < 0) ? (-((-nj) / 16)) : ((16 < 0) ? ((((-nj) + (-16)) - 1) / (-16)) : (((nj_ + 16) - 1) / 16))) : (((": 6423, + " + (-1))) < (n_j": 6424, + " + (-1))) < (nj_ + (-1))) ? ((((": 6425, + " + (-1))) < (nj + (-1))) ? ((((_16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni": 6426, + " + (-1))) < (nj + (-1))) ? ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni_ + (-1))) : (n": 6427, + " + (-1))) < (nj + (-1))) ? ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni + (-1))) : (n_j": 6428, + ";\n p_str->": 6429, + "float) _32767": 6430, + "%d_\\n\", ": 6431, + ")\n _return": 6432, + "dynam_ic,": 6433, + ",_n": 6434, + "s_,": 6435, + "fscanf(_fp": 6436, + " - 1_; i": 6437, + "for (i = 0; i < 64_; i++)\n{\n ": 6438, + "ab_s(": 6439, + ") * (_sizeof(": 6440, + "]_) * ": 6441, + "9_;\n int ": 6442, + ";\n int p_ro": 6443, + "]_;\n }\n\n ": 6444, + ") schedule(_dynamic)": 6445, + "arg_ument": 6446, + " > _0) ? (": 6447, + "local_B_->n_bar": 6448, + "struct tablo_ *": 6449, + " th_an": 6450, + "\\n\");\n exit(_1);\n ": 6451, + "l_y": 6452, + "[m_u": 6453, + "for (j = 1; j_ <= n": 6454, + "for (i_ter": 6455, + "y_[i] = (": 6456, + "strcmp(_argv[i], \"": 6457, + "_sha_256": 6458, + "ordered_(": 6459, + "last__i": 6460, + " *_*": 6461, + "s[i]_->": 6462, + "omp parallel for reduction(+:sum) schedule(static,7_) private(i": 6463, + "scanf(\"_%d": 6464, + "ma_nn": 6465, + "-:diff_)": 6466, + "N_Z": 6467, + "++_;\n }\n\n ": 6468, + "]._x": 6469, + "A_L": 6470, + ";\n}\n\n\n_inline ": 6471, + "-:ddiff_)": 6472, + "1024 + 1)_) + j]": 6473, + "add_res": 6474, + "sc_ore": 6475, + "spl_it": 6476, + "L_a": 6477, + "compute_t_riple": 6478, + "Col_s": 6479, + "swap_ped_": 6480, + ";\n _va = va | tmp": 6481, + ";\n va = va | tmp_;\n tmp = v": 6482, + ";\n _vb = vb | tmp": 6483, + "3__b": 6484, + "rho__i": 6485, + "le_ader": 6486, + "graph->_vertice": 6487, + "s[i]_);\n}\n": 6488, + "b_;\n ": 6489, + " = _sqrt(": 6490, + "[j_ + ": 6491, + " * i_) + j]": 6492, + "[i] = i;\n _s = ": 6493, + "[i] = i;\n s = _-": 6494, + "[i] = i;\n s = -_s;\n}\n": 6495, + "F_I": 6496, + "))_) * (": 6497, + "max_:": 6498, + "test_omp_parallel__reduction(": 6499, + ";\n int _result": 6500, + "logic_or_ = 0;\n ": 6501, + "bit_or_ = 0;\n ": 6502, + "exclusiv_bit_or_ = 0;\n ": 6503, + " %d\\n\", _sum, ": 6504, + "i_;\n }\n\n ": 6505, + " = _36": 6506, + " == 0_;\n}\n\n": 6507, + "vo_lu": 6508, + "for (i = _row": 6509, + " (((_((": 6510, + " * r_u1": 6511, + "uint8_t_ *) ": 6512, + "is_larger_ = ": 6513, + "is_larger = _check_i_islarger": 6514, + "is_larger = check_i_islarger_2(i": 6515, + " _, ": 6516, + "])_];\n": 6517, + "2_) ": 6518, + "[1_][": 6519, + "ci_ti": 6520, + "q_[j]": 6521, + "col_idx": 6522, + "s[i]._x": 6523, + " = ((((DATA_TYPE) i_) * j": 6524, + "%d_ ": 6525, + "q_b": 6526, + "_p_os": 6527, + "hist_o": 6528, + "]_) / ": 6529, + "stats->distance_s[": 6530, + "((_char *) ": 6531, + "A_rr": 6532, + "A_ + k": 6533, + "my_id": 6534, + "nt_1": 6535, + "C_2": 6536, + "[ii_].speeds[": 6537, + "7__r": 6538, + "_r_5_r": 6539, + "7__b": 6540, + "6__b": 6541, + ") lastprivate_ (": 6542, + "2_,i": 6543, + "*_a": 6544, + "grou_p": 6545, + "1]_ - ": 6546, + ":_\n ": 6547, + " == 0_) || (": 6548, + "reg_ion": 6549, + " - 1)_; i++)\n ": 6550, + "2__X86": 6551, + " = 1. / _lhs[n + 2": 6552, + " + ((_x": 6553, + ")\n{\n int sum_;\n int known_sum": 6554, + ")\n{\n int sum;\n int known_sum_;\n double ": 6555, + ")\n{\n int sum;\n int known_sum;\n double _dsum": 6556, + ")\n{\n int sum;\n int known_sum;\n double dsum_;\n double ": 6557, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double _dknown_sum": 6558, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum_;\n double ": 6559, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double _dt": 6560, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt_ = 0.5;\n double ": 6561, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double _rounding_error": 6562, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error_ = 1.": 6563, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1._E-": 6564, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-_9;\n int ": 6565, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int _diff;\n double ": 6566, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double _ddiff": 6567, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff_;\n int pro": 6568, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int pro_duct": 6569, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product_;\n int ": 6570, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int _known_product": 6571, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product_;\n int ": 6572, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int _logic_and": 6573, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and_;\n int ": 6574, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int _logic_or": 6575, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or_;\n int ": 6576, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int _bit_and": 6577, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and_;\n int ": 6578, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int _bit_or": 6579, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or_;\n int ": 6580, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int _exclusiv_bit_or": 6581, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or_;\n int ": 6582, + "];\n int i_;\n double ": 6583, + "];\n int i;\n double _dpt": 6584, + "];\n int i;\n double dpt_;\n int result": 6585, + "];\n int i;\n double dpt;\n int result_;\n sum = 0;\n ": 6586, + "];\n int i;\n double dpt;\n int result;\n sum = 0;\n _dsum = 0;\n ": 6587, + "product_ = 1;\n ": 6588, + "product = 1;\n _logic_and = 1;\n ": 6589, + "product = 1;\n logic_and = 1;\n _logic_or = 0;\n ": 6590, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n _bit_and = 1;\n ": 6591, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n bit_and = 1;\n _bit_or = 0;\n ": 6592, + "product = 1;\n logic_and = 1;\n logic_or = 0;\n bit_and = 1;\n bit_or = 0;\n _exclusiv_bit_or = 0;\n ": 6593, + "dt_ = 1. / ": 6594, + "dt = 1. / _3.": 6595, + "dt = 1. / 3._;\n ": 6596, + ";\n }\n\n if (_known_sum": 6597, + ";\n }\n\n if (known_sum_ != ": 6598, + ";\n }\n\n if (known_sum != _sum": 6599, + ";\n }\n\n if (known_sum != sum_)\n {\n result++;\n fprintf(stderr, \"Error in sum with ": 6600, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with _integers: Result was %d instead of": 6601, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of_ %d\\n\", sum, ": 6602, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, _known_sum": 6603, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum_);\n }\n\n ": 6604, + ";\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n _diff": 6605, + "; ++i)\n {\n _diff = diff - i": 6606, + "; ++i)\n {\n diff = diff - i_;\n }\n\n if (": 6607, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (_diff": 6608, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff_ != 0": 6609, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0_)\n {\n result++;\n fprintf(stderr, \"Error in ": 6610, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in _difference": 6611, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference_ with ": 6612, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with _integers: Result was %d instead of": 6613, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of_ ": 6614, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of _0.": 6615, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0._\\n\", ": 6616, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", _diff": 6617, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff_);\n }\n\n ": 6618, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n _dsum = 0;\n ": 6619, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n _dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 6620, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n _dknown_sum": 6621, + "; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum_ = (1 - dpt) / (1 - dt);\n ": 6622, + "dsum_)\n for (i = 0; i < 20; ++i)\n {\n ": 6623, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n _dsum += ": 6624, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += _pow(dt, i);\n }\n\n if (fabs(": 6625, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(_dsum - dknown_sum": 6626, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum_) > rounding_error": 6627, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error_)\n {\n result++;\n fprintf(stderr, \"Error in sum with ": 6628, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with _doubles: Result was": 6629, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was_ %f": 6630, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f_ instead of": 6631, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of_ %f": 6632, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f_ (": 6633, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (_Difference": 6634, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference_: %": 6635, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %_E": 6636, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E_)\\n\", ": 6637, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", _dsum": 6638, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum_, ": 6639, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, _dknown_sum": 6640, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum_, ": 6641, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, _dsum - dknown_sum": 6642, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum_);\n }\n\n ": 6643, + "dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n _dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 6644, + "fprintf(stderr, \"_\\n\");\n ": 6645, + "ddiff_ = (1 - dpt) / (1 - dt);\n ": 6646, + ")\n for (i = 0; i < 20; ++i)\n {\n _ddiff -= ": 6647, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= _pow(dt, i);\n }\n\n if (fabs(": 6648, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(_ddiff": 6649, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff_) > rounding_error": 6650, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error_)\n {\n result++;\n fprintf(stderr, \"Error in ": 6651, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in _Difference": 6652, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference_ with ": 6653, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with _doubles: Result was": 6654, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was_ %": 6655, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %_E": 6656, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E_ instead of": 6657, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of_ 0.0": 6658, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0_\\n\", ": 6659, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", _ddiff": 6660, + ")\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff_);\n }\n\n ": 6661, + ")\n _for (i = 1; i <= 10": 6662, + ")\n for (i = 1; i <= 10_; i++)\n {\n ": 6663, + ")\n for (i = 1; i <= 10; i++)\n {\n _product *= ": 6664, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= _i;\n }\n\n ": 6665, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n _known_product": 6666, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product_ = 36": 6667, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 36_28": 6668, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628_800": 6669, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800_;\n if (": 6670, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (_known_pro": 6671, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_pro_duct ": 6672, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product _!= ": 6673, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != _product": 6674, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product_)\n {\n result++;\n fprintf(stderr, \"Error in ": 6675, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in _Pro": 6676, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Pro_duct ": 6677, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product _with ": 6678, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with _integers: Result was %d instead of": 6679, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of_ %d": 6680, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d_\\n\\n\", ": 6681, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", _product": 6682, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product_, ": 6683, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, _known_product": 6684, + ")\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product_);\n }\n\n ": 6685, + " logics[i];\n }\n\n if (!_logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 6686, + " logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par_t 1.\\n\");\n }\n\n ": 6687, + " logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n _logic_and = 1;\n ": 6688, + " logics[i];\n }\n\n if (_logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 6689, + " logics[i];\n }\n\n if (_logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par": 6690, + " logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par_t 1.\\n\");\n }\n\n ": 6691, + " logics[i];\n }\n\n if (!_logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par": 6692, + " logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR par_t 2.\\n\");\n }\n\n ": 6693, + " logics[i];\n }\n\n if (!_bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 6694, + " logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par_t 1.\\n\");\n }\n\n ": 6695, + " logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n _bit_and = 1;\n ": 6696, + " logics[i];\n }\n\n if (_bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 6697, + " logics[i];\n }\n\n if (_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par": 6698, + " logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par_t 1\\n\");\n }\n\n ": 6699, + " logics[i];\n }\n\n if (!_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par": 6700, + " logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR par_t 2\\n\");\n }\n\n ": 6701, + "t 2\\n\");\n }\n\n _return result": 6702, + "t 2\\n\");\n }\n\n return result_ == 0;\n}\n\n": 6703, + "->_next": 6704, + ") reduction(_+ : ": 6705, + "3.14159_26": 6706, + "[index_] = ": 6707, + "omp parallel for schedule(_static,1) private(i": 6708, + "fprintf(stderr, \"_ ": 6709, + "for (i = 0; i < _4096": 6710, + "; i++)\n _a[i]": 6711, + "8_2": 6712, + "_s_tep": 6713, + "B_[(i * ": 6714, + "ic_t_": 6715, + "/_src": 6716, + "/src_/": 6717, + "num_b_ucke": 6718, + "K_ey": 6719, + "#_0": 6720, + "[j][i_] = ": 6721, + "H_el": 6722, + "__1": 6723, + "ob_j": 6724, + "}\n\n_\n ": 6725, + "grid_[(": 6726, + "f_ / ": 6727, + "omp_get_w_time();\n ": 6728, + "5_8": 6729, + "__R": 6730, + "for (_nn": 6731, + "-_1, ": 6732, + " = 0_x0": 6733, + "data__size": 6734, + "3__g": 6735, + "omp parallel for schedule(dynamic,1) private(i) reduction(+:_dsum)": 6736, + ")_\n": 6737, + "[k_][i]": 6738, + "c_[i][j]": 6739, + "m1_[k], ": 6740, + "m1[k], _m2": 6741, + "m1[k], m2_[k], ": 6742, + "m1[k], m2[k], _m3": 6743, + "debu_g_": 6744, + "debug__vec": 6745, + "for (i = 1; i <= 1000; i++)\n{\n _sum = sum + i;\n}\n": 6746, + "omp parallel for schedule(dynamic,1) private(i) reduction(+:_sum)": 6747, + "pla_ce": 6748, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or;\n int _logics[1000": 6749, + ")\n{\n int sum;\n int known_sum;\n double dsum;\n double dknown_sum;\n double dt = 0.5;\n double rounding_error = 1.E-9;\n int diff;\n double ddiff;\n int product;\n int known_product;\n int logic_and;\n int logic_or;\n int bit_and;\n int bit_or;\n int exclusiv_bit_or;\n int logics[1000_];\n int i;\n double dpt;\n int result;\n sum = 0;\n dsum = 0;\n ": 6750, + "known_sum = (1000 * (1000 + 1)) / 2;\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:": 6751, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:_sum": 6752, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum_)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i": 6753, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i_;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff": 6754, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff_ = (1000 * (1000 + 1)) / 2;\n ": 6755, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6756, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_-:diff": 6757, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff_)\n for (i = 1; i <= 1000": 6758, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000_; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n ": 6759, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:": 6760, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:_dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n ": 6761, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n _fprintf(stderr, \"\\n\");\n ": 6762, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n _ddiff = (1 - dpt) / (1 - dt);\n ": 6763, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6764, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_-:ddiff": 6765, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff_)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n ": 6766, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n _#pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6767, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_*:product": 6768, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product_)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n ": 6769, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n _for (i = 0; i < 1000; i++)\n {\n ": 6770, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n _logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6771, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&": 6772, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&_ logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n ": 6773, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n _logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6774, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&": 6775, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and &&_ logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par": 6776, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND par_t 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6777, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||": 6778, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||_ logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n ": 6779, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n _logic_or": 6780, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or_ = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6781, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||": 6782, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or ||_ logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n ": 6783, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n _for (i = 0; i < 1000; ++i)\n {\n ": 6784, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n _logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6785, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &": 6786, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &_ logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n ": 6787, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n _logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6788, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &": 6789, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and &_ logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par": 6790, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND par_t 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6791, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |": 6792, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |_ logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n ": 6793, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n _bit_or": 6794, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or_ = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6795, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |": 6796, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or |_ logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n ": 6797, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n _for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6798, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^": 6799, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^_ logics[i];\n }\n\n if (": 6800, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (_exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par": 6801, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par_t 1\\n\");\n }\n\n ": 6802, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n _exclusiv_bit_or": 6803, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or_ = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(": 6804, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(_^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^": 6805, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^_ logics[i];\n }\n\n if (!": 6806, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (!_exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par": 6807, + "known_sum = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:sum)\n for (i = 1; i <= 1000; i++)\n {\n sum = sum + i;\n }\n\n if (known_sum != sum)\n {\n result++;\n fprintf(stderr, \"Error in sum with integers: Result was %d instead of %d\\n\", sum, known_sum);\n }\n\n diff = (1000 * (1000 + 1)) / 2;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:diff)\n for (i = 1; i <= 1000; ++i)\n {\n diff = diff - i;\n }\n\n if (diff != 0)\n {\n result++;\n fprintf(stderr, \"Error in difference with integers: Result was %d instead of 0.\\n\", diff);\n }\n\n dsum = 0;\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n dknown_sum = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(+:dsum)\n for (i = 0; i < 20; ++i)\n {\n dsum += pow(dt, i);\n }\n\n if (fabs(dsum - dknown_sum) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in sum with doubles: Result was %f instead of %f (Difference: %E)\\n\", dsum, dknown_sum, dsum - dknown_sum);\n }\n\n dpt = 1;\n for (i = 0; i < 20; ++i)\n {\n dpt *= dt;\n }\n\n fprintf(stderr, \"\\n\");\n ddiff = (1 - dpt) / (1 - dt);\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(-:ddiff)\n for (i = 0; i < 20; ++i)\n {\n ddiff -= pow(dt, i);\n }\n\n if (fabs(ddiff) > rounding_error)\n {\n result++;\n fprintf(stderr, \"Error in Difference with doubles: Result was %E instead of 0.0\\n\", ddiff);\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(*:product)\n for (i = 1; i <= 10; i++)\n {\n product *= i;\n }\n\n known_product = 3628800;\n if (known_product != product)\n {\n result++;\n fprintf(stderr, \"Error in Product with integers: Result was %d instead of %d\\n\\n\", product, known_product);\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (!logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 1.\\n\");\n }\n\n logic_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&&:logic_and)\n for (i = 0; i < 1000; ++i)\n {\n logic_and = logic_and && logics[i];\n }\n\n if (logic_and)\n {\n result++;\n fprintf(stderr, \"Error in logic AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 1.\\n\");\n }\n\n logic_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(||:logic_or)\n for (i = 0; i < 1000; ++i)\n {\n logic_or = logic_or || logics[i];\n }\n\n if (!logic_or)\n {\n result++;\n fprintf(stderr, \"Error in logic OR part 2.\\n\");\n }\n\n for (i = 0; i < 1000; ++i)\n {\n logics[i] = 1;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (!bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 1.\\n\");\n }\n\n bit_and = 1;\n logics[1000 / 2] = 0;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(&:bit_and)\n for (i = 0; i < 1000; ++i)\n {\n bit_and = bit_and & logics[i];\n }\n\n if (bit_and)\n {\n result++;\n fprintf(stderr, \"Error in BIT AND part 2.\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 1\\n\");\n }\n\n bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(|:bit_or)\n for (i = 0; i < 1000; ++i)\n {\n bit_or = bit_or | logics[i];\n }\n\n if (!bit_or)\n {\n result++;\n fprintf(stderr, \"Error in BIT OR part 2\\n\");\n }\n\n for (i = 0; i < 1000; i++)\n {\n logics[i] = 0;\n }\n\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR part 1\\n\");\n }\n\n exclusiv_bit_or = 0;\n logics[1000 / 2] = 1;\n #pragma omp parallel for schedule(dynamic,1) private(i) reduction(^:exclusiv_bit_or)\n for (i = 0; i < 1000; ++i)\n {\n exclusiv_bit_or = exclusiv_bit_or ^ logics[i];\n }\n\n if (!exclusiv_bit_or)\n {\n result++;\n fprintf(stderr, \"Error in EXCLUSIV BIT OR par_t 2\\n\");\n }\n\n return result == 0;\n}\n\n": 6808, + ";\n _}\n else\n {\n ": 6809, + ") - 1_;\n ": 6810, + "e_ro": 6811, + "atoi_(": 6812, + "5_35": 6813, + "omp parallel for private(i_) if (": 6814, + "omp parallel for private(i) if (_control": 6815, + "omp parallel for private(i) if (control_==": 6816, + "for (i = 0; i <= _1000": 6817, + ");\n _return (known_sum == sum": 6818, + "test_omp_parallel_for__p": 6819, + "test_omp_parallel_for_p_rivate": 6820, + "test_omp_parallel_for_private_(": 6821, + "omp parallel for reduction(+:sum) schedule(_static,1) private(i": 6822, + "omp parallel for reduction(+:sum) schedule(static,1) private(i_) private(i": 6823, + "2_)\n for (i = 1; i <= 1000; i++)\n {\n ": 6824, + "#pragma omp flush_\n ": 6825, + "known_sum == sum_;\n}\n\n": 6826, + "for (i = 0; i < 1000; ++i)\n{\n _logics[i] = 1;\n}\n": 6827, + ");\n\n_\n": 6828, + ");\n}\n\n_double ": 6829, + "#pragma omp for\n _for (i = 1; i <= (grid_points[0] - 2); i++)\n {\n ": 6830, + "chan_ged": 6831, + "float_ x": 6832, + "max__num_": 6833, + "nuc_lide_grid": 6834, + "schedule (static, 4) _linear(b:": 6835, + "s__larger": 6836, + "omp parallel for schedule(static,1) private(i_) ordered": 6837, + "is_larger = check_i_islarger2(i_i": 6838, + "is_larger = check_i_islarger2(ii_) && is_larger": 6839, + " < (_m": 6840, + ")));\n foo(&b, &i_, &": 6841, + ")));\n foo(&b, &i, &_j, ": 6842, + "omp parallel for schedule(dynamic,1) private(i) reduction(_*:product)": 6843, + "for (i = 0; i < 1000; i++)\n{\n _logics[i] = 1;\n}\n": 6844, + "omp parallel for reduction(+:sum) schedule(static,7) private(i_) lastprivate(i": 6845, + "for (i = 1; i <= (grid_points[0] - 2)_; i++)\n{\n ": 6846, + "__set_": 6847, + "len_ame": 6848, + "])) + (_6.0 * ": 6849, + ") + (_dy": 6850, + "___func": 6851, + "__func___": 6852, + "for (i = 1; i <= 1000_; ++i)\n{\n diff = diff - i;\n}\n": 6853, + "omp parallel for schedule(dynamic,1) private(i) reduction(_-:diff)": 6854, + "[i3_ + 2": 6855, + "[i3 + 2_][i2": 6856, + "[0]_;\n ": 6857, + "s_printf(": 6858, + "qb_new": 6859, + "in_f": 6860, + ";\n _j_temp = j": 6861, + "[i][ind_];\n ": 6862, + "omp parallel for schedule(dynamic,1) private(i) reduction(_-:ddiff)": 6863, + "norm_temp_11": 6864, + " * _X": 6865, + ") ?_ (nk": 6866, + ") ? (nk_) : (n": 6867, + "omp parallel for reduction(+:sum) private(i_) firstprivate(i": 6868, + "_f_inal": 6869, + ")) + i_y": 6870, + "eassign_[iel][": 6871, + "j_el": 6872, + "c__mul(": 6873, + "':_\n ": 6874, + "ici_ent": 6875, + " < (_5 - 1": 6876, + " < (5 - 1_); ": 6877, + "1 * _A[(((i": 6878, + "1 * A[(((i_ - 1) * (": 6879, + "3 * _A[(((i": 6880, + "3 * A[(((i_ + 1) * (": 6881, + "new_Distance": 6882, + "C_B": 6883, + "fa_st": 6884, + "; c3 <= ((((16 * c1) + 15) < (ni + (-1))) ? ((16 * c1) + 15) : (ni_ + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nk + (-1))) ? ((16 * c2) + 15) : (nk + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni": 6885, + ";\n }\n\n }\n\n }\n\n }\n\n _if (": 6886, + "00_;\n x": 6887, + "d__e": 6888, + " = 0.0;\n _njac": 6889, + "\\n\");\n _#pragma omp parallel for shared(col)\n for (col = 0; col < 95100; col++)\n {\n ": 6890, + ") < ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))) ?_ ((((((n": 6891, + "if (c1 == c2)\n {\n #pragma omp simd\n _for (c4 = ": 6892, + " + (-1))); c4_++)\n {\n ": 6893, + "idx_)\n ": 6894, + "idx)\n _pstr->": 6895, + "idx)\n pstr->_datlen": 6896, + "SS_E": 6897, + ",j,k_)": 6898, + ") + (j_ + 1)]": 6899, + "m_g": 6900, + "sor_ted": 6901, + "2 * i_) + 1": 6902, + "for (j = 0; j < _32": 6903, + "for (i = 0; i < 100000_; i++)\n ": 6904, + "; i++)\n{\n for (j = 0; j < _M": 6905, + "->_nx": 6906, + "disp_l": 6907, + "c_la": 6908, + ");\n\n_\n\n": 6909, + ",j_,": 6910, + "ne_le": 6911, + "; i_--": 6912, + ", (MPI_Datatype) 0x4c000_80": 6913, + "for (x = 0; x < _OMP_xMax; x": 6914, + "ray_->": 6915, + "double_)) * ": 6916, + "a1_[i] = ": 6917, + "*_x": 6918, + "1.0_) * ": 6919, + " * _i)": 6920, + "]._y": 6921, + "e_t": 6922, + "d_2": 6923, + " = (_0": 6924, + "Le_ng": 6925, + "Leng_th": 6926, + "if (_input_array[x": 6927, + "var_Num": 6928, + "t_0": 6929, + "ta_ule": 6930, + "fi_t": 6931, + "array__": 6932, + "][1_][1": 6933, + "c_ri": 6934, + "y_c": 6935, + "c_d": 6936, + "p_len": 6937, + "2__b": 6938, + "1__b": 6939, + " += 1)\n {\n _#pragma omp parallel for private (": 6940, + "2_ * (": 6941, + ");\n\n_}\n\n": 6942, + "matrix_ ": 6943, + "uint64__t": 6944, + "re_pe": 6945, + " != 0_)\n {\n ": 6946, + ", n_1, n2, n3": 6947, + " += 2_;\n}\n": 6948, + ");\n _c": 6949, + " - _start": 6950, + "fail_++;\n }\n\n}\n\n": 6951, + "2_, i": 6952, + ";\n _for (": 6953, + "z_.imag": 6954, + " -_ (((": 6955, + "][i][j_ - 1": 6956, + "1.0_ + ": 6957, + "for (i = 0; i < N_I": 6958, + "omp parallel for num_threads(_16": 6959, + "Cent_roid": 6960, + "(_g": 6961, + "A[i][k] * _B[k][j]": 6962, + "steps_; i++)\n{\n ": 6963, + "s[(i_ * ": 6964, + "guided_)": 6965, + " << _5": 6966, + " * _temp": 6967, + "3_; j++)\n {\n ": 6968, + "s_ol": 6969, + "}\n else\n _if ((": 6970, + "[k_ - 1": 6971, + "con_v": 6972, + ") * _k": 6973, + "dcomp_lex": 6974, + "wor_d_": 6975, + "))))_\n {\n ": 6976, + "7_ * ": 6977, + "cri_tic": 6978, + ") + (_b": 6979, + "->edges_array__dest": 6980, + "coeff_icient": 6981, + "_ps_(((": 6982, + "4_.5": 6983, + "3_r_2_r": 6984, + "3_r2_r_1_r": 6985, + " += _data[(i * (": 6986, + "uint32_t_) ": 6987, + "for (i = 0; i < len_; i++)\n ": 6988, + "O_T": 6989, + "for (i = 0; i < N_; i++)\n{\n for (j = 0; j < N": 6990, + " - 1)_; j++)\n {\n ": 6991, + " = _C": 6992, + ", _w": 6993, + "0.5_ * ": 6994, + "num__cols": 6995, + "3.1415926_535": 6996, + " == 1_)\n {\n ": 6997, + "train_ing": 6998, + "sa_mple": 6999, + "epsilon_)\n {\n ": 7000, + "grid__col": 7001, + "%_lf": 7002, + "node *_*) ": 7003, + "z_.real": 7004, + "]_) ": 7005, + "mac_ro_x": 7006, + "s_)\n{\n ": 7007, + "ic_ro_x": 7008, + "for (i = 0; i < NI_; i++)\n{\n for (j = 0; j < N": 7009, + "[i][k] * _b": 7010, + ";\n _f": 7011, + "for (j = 1; j <= (grid_points[1] - 2)_; j++)\n {\n ": 7012, + "f_[i][j]": 7013, + "[j]_;\n }\n\n ": 7014, + "->_x": 7015, + "cell_s, ": 7016, + ")\n _return ": 7017, + "sav_ed": 7018, + "U_T": 7019, + "de_t": 7020, + "G_R": 7021, + "Que_ue": 7022, + "new_Value": 7023, + "(_ci": 7024, + "Po_sition": 7025, + ") + 16_) - 1) / 16))) : (((": 7026, + "cell_s_": 7027, + "w_g": 7028, + "32_2": 7029, + "block_width_ + 2": 7030, + ", b_lock": 7031, + "s->_ve": 7032, + "1_,i": 7033, + "y_data_[i]": 7034, + "(_struct ": 7035, + " != _1": 7036, + "][0]_;\n ": 7037, + "A_[(j * ": 7038, + "for (i = 0; i < N; i++)\n _p[i] = v1[i] * v2[i];\n": 7039, + "u__data": 7040, + " < _k": 7041, + "S_Q": 7042, + ")))_\n ": 7043, + "))_\n ": 7044, + "[0]_, ": 7045, + "u[m_][i][j][k]": 7046, + "Se_quen": 7047, + ";\n #pragma _omp parallel for\n ": 7048, + "a2_[i] = i;\n s = -s;\n}\n": 7049, + "v_p": 7050, + "r_1": 7051, + "_M_AX": 7052, + "fi_lename": 7053, + "(\"_/home/reemh/CLPP/github-clone-all/repos_final/": 7054, + "t__id": 7055, + "i_o": 7056, + "L_c": 7057, + " * re_stri": 7058, + "for (int _y = 0; y < ": 7059, + "y_[i": 7060, + "][i][j][k];\n _r": 7061, + "nj + (-1)) <_ (nk": 7062, + "nj + (-1)) < (nk_ + (-1))) ? (nj + (-1)) :": 7063, + "nj + (-1)) < (nk + (-1))) ? (nj + (-1)) :_ (nk": 7064, + "]_ *= boundryScale;\n ": 7065, + "OMP_xMax) + OMP_xMax_] *= boundryScale;\n u[": 7066, + "ff_tz": 7067, + ", _fftblock": 7068, + "; k_++)\n {\n ": 7069, + "for (i = 0; i < 512; i++)\n{\n for (j = 0; j < 512_; j++)\n {\n ": 7070, + "output->content_[i][j] = i": 7071, + "output->content[i][j] = i_mage->content[i][j]": 7072, + "_c_um": 7073, + ") * _nx": 7074, + "GR_ID": 7075, + "GRID__SIZE": 7076, + "d_um": 7077, + "h__graph": 7078, + "__k": 7079, + "jtr_sha_512": 7080, + "tMask_X": 7081, + "tMask_Y": 7082, + "cessor__id": 7083, + "l_g": 7084, + "a_f": 7085, + "to__visi": 7086, + " = 0._50": 7087, + " = 0.50_ * ": 7088, + " = _2.0 * ": 7089, + "cin_ * ": 7090, + "for (j = 1; j <= ((lastcol - firstcol) + 1)_; j++)\n {\n ": 7091, + "int_emp": 7092, + ";\n }\n\n }\n\n for (c3 = _nm": 7093, + "Node_ID": 7094, + "vi_ou": 7095, + ") + j]_.": 7096, + ";\n _B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 7097, + "vertex_[i][j]": 7098, + "OMP_xMax_] * nu;\n u[": 7099, + "3_322": 7100, + ";\n vtype x_10": 7101, + " ^ x_0": 7102, + "11_BB": 7103, + "00F_0": 7104, + "44_44": 7105, + "27_FF": 7106, + "for (c2_ = (((": 7107, + "color__type": 7108, + ") :_ ((((nm + (-1)) * 16) < 0) ? ((16 < 0) ? (-((((-(nm + (-1))) + 16) + 1) / 16)) : (-((((-(nm + (-1))) + 16) - 1) / 16))) : ((nm + (-1)) / 16))); c2++)\n {\n for (c3 = 16 * c1": 7109, + ";\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk_;\n }\n\n #pragma omp simd\n for (c4": 7110, + "-2) * _c0": 7111, + "total__vector": 7112, + "grid__current": 7113, + "[k_ - 1]": 7114, + ") > 0.05_)\n {\n fail++;\n }\n\n }\n\n}\n\n": 7115, + " = 0;\n _}\n\n}\n\n": 7116, + "re_ce": 7117, + "[_lev": 7118, + "[i][_0] = ": 7119, + "Fa_iled": 7120, + " * _tmp": 7121, + "; k_++)\n ": 7122, + ", _max": 7123, + "a_[j] = ": 7124, + "[0][_0]": 7125, + " _the ": 7126, + "matrix->_tab": 7127, + "double) _i": 7128, + " = 0; i_ter": 7129, + "9_) | (": 7130, + "static _void p": 7131, + "K_, int ": 7132, + " = 0_;\n ": 7133, + "[j]_;\n ": 7134, + "v_x": 7135, + ")) ||_ ((": 7136, + "[i][k_] + ": 7137, + "sum_s[i].": 7138, + "scanf(\"%d_\", &": 7139, + " == _0x": 7140, + " - _hz": 7141, + ".c_\"": 7142, + "0_);\n ": 7143, + "\"_);\n ": 7144, + "re_z": 7145, + ")_\n {\n ": 7146, + "y * _k": 7147, + "nz_v": 7148, + "))_) - ((": 7149, + "coord_inate": 7150, + "ass_word": 7151, + "rand48_(": 7152, + ") + j] = (((DATA_TYPE) i) * j_) / ": 7153, + "t_riple": 7154, + "][c_]": 7155, + "__epi": 7156, + "mer_ge": 7157, + "[j_j": 7158, + ") & 0x_ffff": 7159, + "__u": 7160, + "23 * _h": 7161, + "1_->": 7162, + ";\n _col": 7163, + "u[i][j][k_ - 1": 7164, + "2_; j++)\n {\n ": 7165, + "x_i * ": 7166, + "for (i3_ = 1; i": 7167, + "for (i3 = 1; i_3": 7168, + "++)\n{\n for (_y = 0; y < ": 7169, + ") ^_ ": 7170, + " + 1)_) + j]": 7171, + " < (_*": 7172, + "#pragma omp _task": 7173, + "8_)\n {\n ": 7174, + "le_ar": 7175, + "124_35": 7176, + "12435_ * ": 7177, + "#pragma omp ordered_\n {\n ": 7178, + "(_char *": 7179, + "++_i": 7180, + "l_2": 7181, + ",m_)": 7182, + "4_)\n ": 7183, + "[i]_ = 1": 7184, + "data_Size": 7185, + "[1]_, ": 7186, + "*((_node **) ": 7187, + "*((node **) _elem_at(&": 7188, + "R_A": 7189, + "ma_s": 7190, + "6_]": 7191, + "for (i = 0; i < _M": 7192, + "OMP_zMax_; z": 7193, + "s(_)": 7194, + "}\n _;\n ": 7195, + "a_)": 7196, + "c_t ": 7197, + ";\n }\n\n _}\n\n ": 7198, + "; k_k": 7199, + "[i_ + (n": 7200, + "[i + (n_x": 7201, + " * (j_ + (n": 7202, + "y * k_)))": 7203, + "s__index": 7204, + "dt_) * ": 7205, + "[j]_ > ": 7206, + "c_uf": 7207, + "[(k * _512": 7208, + "alive__": 7209, + "yy_con": 7210, + "tra_ce": 7211, + "m_ult": 7212, + "2)_;\n}\n": 7213, + "h_old": 7214, + "critic_al": 7215, + "mask_Dimension": 7216, + "co_v": 7217, + "K_S": 7218, + "tmor_t": 7219, + "__fast": 7220, + ", unsigned _int *": 7221, + ")) * _tmp": 7222, + "nt1_ == '": 7223, + "'_) && (n": 7224, + "') && (n_t2": 7225, + "') && (nt2_ == '": 7226, + "_cpu_[n": 7227, + "_cpu[n_h": 7228, + "f_Tmp": 7229, + "pstr->_cptr[idx": 7230, + "cells->_speed_": 7231, + "int_) (": 7232, + "ra_te": 7233, + "#pragma omp parallel_ ": 7234, + ";\n\n_\n ": 7235, + ", int _b": 7236, + "s[v_].": 7237, + "A_[i] = ": 7238, + "[i3 + 1][i2_][i1]": 7239, + "A_->": 7240, + "error = _error": 7241, + "}\n else\n _if (i": 7242, + "X_ = ": 7243, + "j_)) + ((": 7244, + " = 0;\n _double ": 7245, + ",_c": 7246, + "for (int i = 0; i < 1_0000": 7247, + "rand() % 1_00": 7248, + "omp__set_": 7249, + "for (int i = 0; i < _size": 7250, + "ix_ * ": 7251, + " = (_int) ((": 7252, + "Row_s": 7253, + "M_ul": 7254, + ");\n}\n\n\n_void ": 7255, + " = 0._25 * (((": 7256, + ";\n _}\n\n ": 7257, + "res_ult ": 7258, + "] == _filter_list[y": 7259, + " %_ 1": 7260, + " != _3": 7261, + "are__": 7262, + "5_] = ": 7263, + "u_y": 7264, + ";\n }\n\n }\n\n _}\n\n ": 7265, + "_sub__ps(": 7266, + "S_V": 7267, + " = _m_": 7268, + " == 1)\n {\n _numAliveNeighbors++": 7269, + "C_nt": 7270, + "32_14": 7271, + "3214_212": 7272, + "3214212_.0": 7273, + "[i][j]_);\n }\n\n printf(\"\\n\");\n}\n": 7274, + "w__": 7275, + "T_YPE": 7276, + "v_) shared(": 7277, + "dtemp_[m]": 7278, + "[i] = (_atoi16[ARCH_INDEX(*": 7279, + "p_)]": 7280, + "[1]_)]": 7281, + "neighbor_s[j].": 7282, + "for (i_ = i": 7283, + "#pragma omp ordered_ de": 7284, + "#pragma omp ordered de_pend(": 7285, + "1_, i": 7286, + "num__vector": 7287, + "(i_, ": 7288, + "_p_r": 7289, + "grid->_comm": 7290, + "for (c1 = 0; _c1": 7291, + ")) ?_ ((": 7292, + " + _m": 7293, + "cur_ = ": 7294, + "x = (_i + ": 7295, + ".tv__usec": 7296, + "for (int ii = 0; i_i": 7297, + "))_;\n ": 7298, + " = (_row": 7299, + "for (k = _k": 7300, + "fprintf(stdout, \"_[": 7301, + "]_ %s": 7302, + "] %s_:%d": 7303, + "] %s:%d_:%": 7304, + "] %s:%d:%_s()": 7305, + "name_(\"/home/reemh/CLPP/github-clone-all/repos_final/": 7306, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/_a": 7307, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/a_mann": 7308, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amann_ou": 7309, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannou_gra": 7310, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougra_hi": 7311, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahi_y": 7312, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiy_a": 7313, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya_/im": 7314, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/im_op": 7315, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop_-": 7316, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-_comp": 7317, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-comp_ile": 7318, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compile_r": 7319, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler_/": 7320, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/_tests": 7321, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests_/im": 7322, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/im_su": 7323, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsu_ite": 7324, + "name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsuite_/src/": 7325, + "i)\n{\n _int ": 7326, + "d_3": 7327, + "for (i_i = 0; i": 7328, + "for (j = 1; j <= (grid_points[1] - 2); j++)\n {\n _for (k = 1; k <= (grid_points[2] - 2); k++)\n {\n ": 7329, + " - x_21": 7330, + " * 1_024": 7331, + "Par_tition": 7332, + "private.d_in2__pad": 7333, + "pos__ori": 7334, + "private.d_in2__sub": 7335, + "_pro_b": 7336, + "_f_lu": 7337, + "norm_temp_12": 7338, + "Index_].": 7339, + "to_visi_t": 7340, + "CitiesX[_city": 7341, + "CitiesY[_city": 7342, + ")) + (k_ - 1)": 7343, + "c1_ <= ((((((n": 7344, + ";\n }\n\n #pragma omp simd\n for (c4 = _nk": 7345, + ";\n }\n\n }\n\n for (c3 = _ni": 7346, + "; c3 <= ((((16 * c1) + 15) < (nm + (-1))) ? ((16 * c1) + 15) : (nm + (-1))); c3++)\n {\n #pragma omp simd\n for (c4 = 16 * c2; c4 <= ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))); c4++)\n {\n D[c3][c4] = (((double) c3) * (c4 + 2)) / nk_;\n }\n\n }\n\n }\n\n }\n\n if ((c1 <=": 7347, + ";\n }\n\n }\n\n }\n\n }\n\n if (_c1 <=": 7348, + "2D__": 7349, + ";\n }\n\n }\n\n for (c3 = _nj": 7350, + "curr_p_ath": 7351, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj_ + (-1))) < (nk + (-1))) ? ((((": 7352, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nk + (-1))) ? ((((_16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj": 7353, + "16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj + (-1))) < (nk + (-1))) ? ((((16 * c2) + 15) < (nj + (-1))) ? ((16 * c2) + 15) : (nj_ + (-1))) : (nk": 7354, + ";\n }\n\n }\n\n for (c3 = _nk": 7355, + "n + (2 * tsteps)) + (-_3))": 7356, + "c1_)) + ": 7357, + "r__vec": 7358, + ";\n }\n\n }\n\n _for (c3": 7359, + ")) && (_c1 >= (((": 7360, + "); c2_ <= ((((((n": 7361, + "7__g": 7362, + "initi_al": 7363, + "vector__sum": 7364, + "for (i = 0; i < _MatrixDim": 7365, + "[i] = (atoi16[ARCH_INDEX(*_p)]": 7366, + "[i] = (atoi16[ARCH_INDEX(*p)]_ << 4) | atoi16[ARCH_INDEX(p": 7367, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p_[1])]": 7368, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p[1])]_;\n p": 7369, + "[i] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p[1])];\n p_ += 2;\n}\n": 7370, + "[0][_j]": 7371, + " = _s": 7372, + ", _out": 7373, + "3.1415926535_8": 7374, + ")\n _printf(\"": 7375, + "oria_.": 7376, + "m_; j++)\n ": 7377, + "c1_c5": 7378, + " = 0_; (": 7379, + "for (k = 0; k < 1_024": 7380, + ") + 1_) / ": 7381, + " - 1_] = ": 7382, + "_p_re": 7383, + "u[_ind": 7384, + "for (z = 0; z < _OMP_zMax; z": 7385, + " = (int_) (": 7386, + "I_ni": 7387, + "count_++": 7388, + " + (_r": 7389, + "lhs[_4": 7390, + "; p_ < (": 7391, + " == 3_)\n {\n ": 7392, + "u[m_][i][j][k": 7393, + "[j]_]": 7394, + "->_num_": 7395, + ";\n _if (!": 7396, + "for_e": 7397, + " * restri_ct ": 7398, + "ro_ot": 7399, + "R_I": 7400, + "s[i]._y": 7401, + "l_k": 7402, + " - 1_][": 7403, + "_p_lug": 7404, + "; col_++)\n {\n ": 7405, + "][i][j][k_])) + ": 7406, + "':_\n ": 7407, + "++;\n_\n ": 7408, + "F_or": 7409, + "j_)": 7410, + "_m_sg": 7411, + "Array_[": 7412, + "'_))": 7413, + "11_ = x": 7414, + " * 1_000": 7415, + " = _255": 7416, + "[iel_][1": 7417, + "][i][j][k];\n _lhs[": 7418, + " + 1_0][i][j][k] = lhs[": 7419, + "T_HREADS": 7420, + "_squ_ared": 7421, + "n_ - 1]": 7422, + "D_L": 7423, + " = _rho": 7424, + "forcing[m_][i][j][k] = ": 7425, + "forcing[m][i][j][k] = _forcing[m": 7426, + " + (_2 * 1": 7427, + "_cpu[nh_].": 7428, + "fjac_[i][j][k": 7429, + "dim_) + j": 7430, + "d_z1": 7431, + "[((i_ + 1) * ": 7432, + "A_[i] = (": 7433, + "[_tid": 7434, + "meas_ure": 7435, + "t_ = (": 7436, + "L_en": 7437, + "omp parallel for reduction(_+ : ": 7438, + "]_;\n }\n\n }\n\n}\n": 7439, + " -= _2": 7440, + "; j++)\n {\n _tmp": 7441, + "tr_uth": 7442, + "%_ld": 7443, + "x_ = 1": 7444, + "w_2": 7445, + "0x_7fffffff": 7446, + "OMP_Index(int x, int y, int z)\n{\n return (((z * OMP_yMax) + y) * OMP_xMax) + x_;\n}\n\n": 7447, + "for (j_ = col": 7448, + "[i]_ != ": 7449, + "; j_ < n": 7450, + "exp(_-": 7451, + "for (m = 0; m <= 4; m_ += 1)\n{\n ": 7452, + " / (_sizeof(": 7453, + "__load": 7454, + "(_K": 7455, + " + i)_) + j": 7456, + "result_)": 7457, + "99_9": 7458, + "world->_bodie": 7459, + "; ++j_)\n {\n ": 7460, + ");\n _}\n\n ": 7461, + "len_ = ": 7462, + "for (j = 0; j < 1_0000000; j++)\n ": 7463, + "Po_int ": 7464, + "ut_ation": 7465, + "te_m": 7466, + " == 1_)\n {\n ": 7467, + "f_ = ": 7468, + "5_2": 7469, + " = _mm_load_u_ps((": 7470, + "u_do": 7471, + "for (int i = 0; i < _4": 7472, + "E_C": 7473, + "3_;\n x": 7474, + "h_id": 7475, + "__update": 7476, + "0._7": 7477, + "ti_al_": 7478, + "s[thread_Num": 7479, + "A__addres": 7480, + "[index_ + ": 7481, + "ty_1": 7482, + "[b_id": 7483, + "double_Word": 7484, + "j_ = i": 7485, + "for (i = 1; i < (_2048 + 1)": 7486, + "for (j = 0; j_ <= (": 7487, + "u[i][j][k_ + 1": 7488, + "2_ * ((((": 7489, + "(x_) ": 7490, + ", _const int ": 7491, + "vl_[id].": 7492, + "j_;\n ": 7493, + " + (_2 * i": 7494, + ")) /_ (": 7495, + "O_CK": 7496, + "d_.": 7497, + "; i++)\n{\n if (_percentDiff(": 7498, + "for (x = 0; x_ < N": 7499, + "\\n\", i, _a[i]": 7500, + "c_;\n ": 7501, + "total_ += ": 7502, + " + _3]": 7503, + "for (i = 0; i < _num": 7504, + "); _x": 7505, + "]_ -= ": 7506, + "A_[k][j]": 7507, + "se_arch": 7508, + "; i++)\n{\n _double ": 7509, + "0_;\n ": 7510, + ", _long ": 7511, + "in_s": 7512, + "union_ ": 7513, + "}_ ": 7514, + "ray_.": 7515, + "__key": 7516, + "for (j_ = i + 1": 7517, + "temp__mat": 7518, + "__omp": 7519, + ");\n _}\n while (": 7520, + "t_ *": 7521, + "Mul_ti": 7522, + "000000_000": 7523, + "__S": 7524, + "h_ouse": 7525, + "[(_16 * ": 7526, + "O_r": 7527, + "public.in_mod__rows": 7528, + "u[_0": 7529, + "Node_s": 7530, + "long_ *": 7531, + ", _struct ": 7532, + "__force": 7533, + "break;\n\n _case '": 7534, + "per_son": 7535, + "__e": 7536, + "IM_G": 7537, + "_in_fo": 7538, + "la_ve": 7539, + "s_[i": 7540, + "5_1]": 7541, + "zz_con": 7542, + ") - (_c2 * ": 7543, + "))_);\n }\n\n }\n\n}\n": 7544, + "uint32_t_ *) ": 7545, + ")\n{\n int i_;\n ": 7546, + "__input": 7547, + "pro_cess": 7548, + "processe_s[i].": 7549, + ");\n }\n\n _return ": 7550, + " + (-1))); c2++)\n {\n _A[c1][c2] = (((double) c1) * c2) / ni;\n ": 7551, + "[k], _m1[k], m2[k], m3": 7552, + "MPI_Send_(&": 7553, + "for (i = 0; i < 16_; i++)\n{\n ": 7554, + "c = c + (b != (7_ + (2 * i": 7555, + ")));\n b = b_ + 2": 7556, + "foo(_3": 7557, + "omp parallel for shared (_a, b": 7558, + "idx_ = ": 7559, + "2_) reduction(+:c)": 7560, + "(_input->x": 7561, + ", sup_->": 7562, + ", sup->_V": 7563, + "A[(i * 8192_) + j]": 7564, + "a[i]_ - ": 7565, + "int_)) * ": 7566, + "for (x = 0; x < N_particles": 7567, + "x = 1_; x": 7568, + "stride__y": 7569, + "++)\n {\n _for (": 7570, + "OMP__SQ": 7571, + "OMP_SQ_R": 7572, + "float percentDiff(double val1, double val2_)\n{\n double ": 7573, + "float percentDiff(double val1, double val2)\n{\n double _val3": 7574, + "float percentDiff(double val1, double val2)\n{\n double val3_ = (": 7575, + "float percentDiff(double val1, double val2)\n{\n double val3 = (_val1": 7576, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1_ >= ": 7577, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= _val2": 7578, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2_) ? (": 7579, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (_val1 - val2": 7580, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2_) : (": 7581, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (_val2": 7582, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2_ - ": 7583, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - _val1": 7584, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1_);\n if (": 7585, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (_val3": 7586, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3_ < ": 7587, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3 < _0.5)\n {\n ": 7588, + "float percentDiff(double val1, double val2)\n{\n double val3 = (val1 >= val2) ? (val1 - val2) : (val2 - val1);\n if (val3 < 0.5)\n {\n _return 0.0f;\n }\n else\n {\n return 100.0f * absVal(absVal(val1 - val2) / absVal(val1 + 0.00000001f));\n }\n\n}\n\n": 7589, + "; i += 4)\n{\n _c = c + (b != (7": 7590, + "; i += 4)\n{\n c = c + (b != (7_ + ((i": 7591, + "; i += 4)\n{\n c = c + (b != (7 + ((i_ / 4) * ": 7592, + "; i += 4)\n{\n c = c + (b != (7 + ((i / 4) * _3": 7593, + "value[col_ + 4": 7594, + "for (j_ = i": 7595, + "8; j++)\n{\n _c = c + (b": 7596, + "8; j++)\n{\n c = c + (b_ != ((": 7597, + "8; j++)\n{\n c = c + (b != ((_7": 7598, + "8; j++)\n{\n c = c + (b != ((7_ + (2 * ": 7599, + "8; j++)\n{\n c = c + (b != ((7 + (2 * _j)) + ((": 7600, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((_2 * ": 7601, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((2 * _8) * ": 7602, + "8; j++)\n{\n c = c + (b != ((7 + (2 * j)) + ((2 * 8) * _i": 7603, + "._at": 7604, + "for (int i = 0; i < 1_000": 7605, + "5 + (_c1c5": 7606, + "5 + (c1c5_ * ru1": 7607, + ") <_ ((": 7608, + "float_) (": 7609, + " %d_, ": 7610, + "RA_Y": 7611, + "for (int _x = 0; x < ": 7612, + "cur_->data": 7613, + "matrix__": 7614, + " =_ (ni": 7615, + ", unsigned char *_out": 7616, + "C_DF": 7617, + "[k_ + 1": 7618, + "; p < (_&buf[": 7619, + " /_ ((double) ": 7620, + "; i++)\n _for (k = k": 7621, + "if (!_memcmp(": 7622, + "15_E": 7623, + "[(j * n_) + i]": 7624, + "r = _r": 7625, + "p = _q;\n ": 7626, + "t_1 = ": 7627, + " - 1_)) ? (": 7628, + ";\n int i_;\n ": 7629, + "for (m = 0; m < 5; m_++)\n {\n ": 7630, + "5_.2f": 7631, + "]_, (": 7632, + ") * s_) * s": 7633, + "(xyzInd_ + OMP_xMax) + OMP_xMax) + OMP_xMax) + OMP_xMax) + ": 7634, + "xx_con": 7635, + "_C_OL": 7636, + "[_private.point_no": 7637, + " + 1_][k]": 7638, + ";\n\n _if (": 7639, + "[col_] * ": 7640, + "dou_th": 7641, + "1, _b": 7642, + "size_y": 7643, + "w_ = ": 7644, + "ni + (-1)) <_ (nj": 7645, + "ni + (-1)) < (nj_ + (-1))) ? (ni + (-1)) :": 7646, + "ni + (-1)) < (nj + (-1))) ? (ni + (-1)) :_ (nj": 7647, + "u_.": 7648, + "diagn_[iel][": 7649, + "2 * _speed": 7650, + "__coefficient": 7651, + "[(i * 1000_) + j]": 7652, + "file__name": 7653, + "j_sr": 7654, + "for (nn_ = 1; ": 7655, + "for (nn = 1; _nn": 7656, + "for (nn = 1; nn_ < (5 - 1); ": 7657, + "for (nn = 1; nn < (5 - 1); _nn": 7658, + "mor_v_[n": 7659, + "mor_v[n_n - 1]": 7660, + "centroid_s, ": 7661, + ") < 0) ?_ (-((-": 7662, + " < 0) ?_ ((((-": 7663, + ")) - 1) /_ (-": 7664, + ") < 0) ?_ ((": 7665, + "node->_children": 7666, + "il_ = idel[ie][iface": 7667, + ")) / _2": 7668, + "[(i * 1_28": 7669, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl_ + (-1))) < (nm + (-1))) ? ((((": 7670, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((_16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl": 7671, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl_ + (-1))) : (n": 7672, + "16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) < (nm + (-1))) ? ((((16 * c2) + 15) < (nl + (-1))) ? ((16 * c2) + 15) : (nl + (-1))) : (n_m + (-1))); c4++)\n {\n C[c3][c4] = (((double) c3) * (c4 + 3)) / nl": 7673, + " + (-1))); c4++)\n {\n A[c3][c4] = (((double) c3) * c4) / ni_;\n B[c3][c4] = (((double) c3) * (c4 + 1)) / nj": 7674, + "*((MD5_std_combined *) (((char *) MD5_std_all_p) + t))).__pool->": 7675, + "id_].": 7676, + "!_rt": 7677, + "!rt_Is": 7678, + ") - _OMP_xMax] * nu;\n u[": 7679, + " = m__get(": 7680, + ");\n _m_free(": 7681, + " - p_2": 7682, + "n + (2 * tsteps)) + (-_3": 7683, + " (-((((-((_n + (2 * tsteps)) + (-3))": 7684, + "16 * c2_) + ((-1) * n)) + ": 7685, + "-2) * c3) + _c4": 7686, + "x[_temp": 7687, + "x[temp_] = ntemp": 7688, + "3333_FFFF": 7689, + "6_A": 7690, + ";\n vtype x_20": 7691, + " ^ x_00": 7692, + ";\n x_10": 7693, + "11_44": 7694, + "6_A9": 7695, + "4_F": 7696, + "4_F4": 7697, + "E_F4": 7698, + " = x_3C": 7699, + "22_DD": 7700, + " < _iel": 7701, + "tmort_[ig": 7702, + "v_mag": 7703, + "[zoneset_[i]": 7704, + "16 * c1) + 15) < (n_k + (-1))) ? ((16 * c1) + 15) : (nk": 7705, + ", 0, 0_, 0, 0": 7706, + " >> _25": 7707, + "d_1_2 * h": 7708, + "d_1_3 * h": 7709, + ")))) + (_h": 7710, + ")) + (_d_": 7711, + "3_g_2_g": 7712, + "3_g2_g_1_g": 7713, + "7_b_6_b": 7714, + ")) + (_bv": 7715, + ") default_(shared": 7716, + " + _n": 7717, + "rh_s[i][j][k": 7718, + "1_D": 7719, + "for (int j = 0; j < n_; j++)\n {\n ": 7720, + "energ_y_": 7721, + "; y_++)\n{\n ": 7722, + "sum_;\n}\n": 7723, + "(n_ew": 7724, + "a[i]_);\n}\n": 7725, + "printf(\"_Failed": 7726, + "sum_ = 0;\n ": 7727, + ");\n _free": 7728, + "an_sw": 7729, + "answ_er": 7730, + "a_[i][j] = ": 7731, + "str_cp": 7732, + " _thread": 7733, + "max_(": 7734, + "memcp_y(&": 7735, + " * (sizeof(_float": 7736, + "for (i = 1; i_ < n": 7737, + "c_v": 7738, + "__value": 7739, + "is_o": 7740, + "S_, int ": 7741, + "o_c": 7742, + " = (_int) ": 7743, + "binary_, ": 7744, + " %d_\\n\", i": 7745, + "rowptr_[i + 1]": 7746, + "1_);\n ": 7747, + "rhs[_0": 7748, + "T_im": 7749, + "[_16": 7750, + "for (k = 0; k < _512": 7751, + ") + _3)": 7752, + "c_mom": 7753, + " * j_)]": 7754, + "0_, b": 7755, + "[(_k": 7756, + "cell_s[(ii * params.nx) + jj].speeds[": 7757, + "li_k": 7758, + "i_si": 7759, + ";\n\n if (_a": 7760, + "3_(": 7761, + "th_is_": 7762, + "wg_ll": 7763, + "passed_verification_++;\n\n ": 7764, + ") + (-_2": 7765, + "(*((DES_bs_combined *) (((char *) DES_bs_all_p) + t))).B_[1": 7766, + "Thread_Limit": 7767, + ";\n }\n\n}\n\n_int ": 7768, + "]_]": 7769, + "graph->vertice_s[v].": 7770, + " (nk_ + (-1)); c2++)\n {\n ": 7771, + "i = 0; i_ < n": 7772, + "48_]": 7773, + ") <_ p": 7774, + "l_at": 7775, + "for (j = 0; j < _8192": 7776, + "printf(\"_\\t": 7777, + ", x_, y": 7778, + "v_y": 7779, + "e_)": 7780, + "a[i]_;\n printf(\"": 7781, + "][i][j1_][k] = ": 7782, + "x_[i] = ": 7783, + "[(_0 * ": 7784, + "for (i = 0; i < 10_; i++)\n ": 7785, + ";\n\n _}\n\n}\n\n": 7786, + "u_data_ = u": 7787, + "u_data = u_->data": 7788, + "Ele_m": 7789, + "os_sible": 7790, + ";\n _c": 7791, + "omp parallel for default(none_) private(": 7792, + "z_.i": 7793, + "malloc(_sizeof(": 7794, + ", _hash": 7795, + "[i][k] * b_[k][j]": 7796, + "tw_o": 7797, + "ate__": 7798, + ");\n _}\n else\n {\n ": 7799, + ":_\n ": 7800, + ") / 1_024": 7801, + "collapse_ (": 7802, + " - (_0.5 * (": 7803, + "base_name(\"/home/reemh/CLPP/github-clone-all/repos_final/amannougrahiya/imop-compiler/tests/imsuite/src/": 7804, + "s[_m]": 7805, + "timer__": 7806, + "[%d_] = ": 7807, + "ma_ny": 7808, + "for (j_1": 7809, + "))\n {\n _printf(\"": 7810, + "[j_][k]": 7811, + "][i1]_) + r": 7812, + "][i1 + 1]_) + r": 7813, + "im_z": 7814, + "tid_ = omp_get_thread_num(": 7815, + "; i++)_\n {\n ": 7816, + "f_ound": 7817, + ");\n _b": 7818, + "rhs[_2": 7819, + "rhs[_4": 7820, + "s[_t": 7821, + "mask__con": 7822, + "5_d": 7823, + "c_j": 7824, + "0)_\n ": 7825, + "_p_ixel": 7826, + ")) /_ 1": 7827, + "unsigned _int) ": 7828, + "z_2": 7829, + ";\n _}\n else": 7830, + "][i1][j][k_] = ": 7831, + "._C": 7832, + "ue[m_][k": 7833, + "j_m1": 7834, + "][k_m1]": 7835, + "64_ + (2 * 1": 7836, + "][j_m1]": 7837, + "\n _passed_verification": 7838, + "\n passed_verification_++;\n\n ": 7839, + "_r5_r_4_r": 7840, + "_r5_r4_r_3_r2_r1_r": 7841, + "5__g": 7842, + "_g_3_g2_g1_g": 7843, + "3_b_2_b": 7844, + "3_b2_b_1_b": 7845, + "for (int i = 0; i < n_; i++)\n ": 7846, + "Point_s; i++)\n{\n ": 7847, + "if ((_!": 7848, + "[i]_ / ": 7849, + " = _n": 7850, + ") schedule(_dynamic,": 7851, + "M_at": 7852, + "stats->pageRanks[v_] / ": 7853, + "double_) (((": 7854, + "[i1]_ + ": 7855, + "k_)\n {\n ": 7856, + "if (i_ < ": 7857, + "))_) / ": 7858, + "}\n\n\n\n\n_}\n": 7859, + "o_ver": 7860, + "4_)\n {\n ": 7861, + ".j_p": 7862, + "omp distribute parallel for simd _linear": 7863, + ");\n _float ": 7864, + "->_width": 7865, + " = (((_((": 7866, + "G_B": 7867, + "3.14159265358_979": 7868, + "3.14159265358979_32": 7869, + "for (j = 1; j_ < ": 7870, + "m_m": 7871, + "in_.": 7872, + "union _\n {\n ": 7873, + "y_;\n ": 7874, + "; i_--)\n{\n ": 7875, + "if ((_*": 7876, + "i_tion": 7877, + "for (j = 0; j_ <= n": 7878, + "ig_ = ": 7879, + ";\n }\n\n _}\n\n }\n\n }\n\n}\n": 7880, + ")\n{\n int i;\n int j_;\n int k": 7881, + " private(_j": 7882, + "printf(\"_%f": 7883, + " += _16": 7884, + "Wor_ld": 7885, + "il_t": 7886, + "7_84": 7887 + } +} \ No newline at end of file