#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ check(int *, int, int);
int /*<<< orphan*/ printf(char *, long, ...);
int main() {
  int primes[200000];
  int n = 1;
  int i;
  long int sum = 0;
  primes[0] = 2;
  for (i = 3; i < 2000000; i++)
    if (check(primes, n, i)) {
      primes[n] = i;
      n++;
    }
  for (i = 0; i < n; i++)
    sum += primes[i];
  printf("n: %d\n", n);
  printf("primes[0]: %d\nprimes[1]: %d\nprimes[99]: %d\nprimes[148932]: %d\n",
         primes[0], primes[1], primes[99], primes[148932]);
  printf("sum: %ld\n", sum);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc3520,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0xc3514(%rbp)
movq   $0x0,-0xc3520(%rbp)
movl   $0x2,-0xc3510(%rbp)
movl   $0x3,-0xc3518(%rbp)
cmpl   $0x1e8480,-0xc3518(%rbp)
jge    11c9 <main+0xa9>
lea    -0xc3510(%rbp),%rdi
mov    -0xc3514(%rbp),%esi
mov    -0xc3518(%rbp),%edx
call   1040 <check@plt>
cmp    $0x0,%rax
je     11b0 <main+0x90>
mov    -0xc3518(%rbp),%ecx
movslq -0xc3514(%rbp),%rax
mov    %ecx,-0xc3510(%rbp,%rax,4)
mov    -0xc3514(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc3514(%rbp)
jmp    11b5 <main+0x95>
mov    -0xc3518(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc3518(%rbp)
jmp    115b <main+0x3b>
movl   $0x0,-0xc3518(%rbp)
mov    -0xc3518(%rbp),%eax
cmp    -0xc3514(%rbp),%eax
jge    1216 <main+0xf6>
movslq -0xc3518(%rbp),%rax
movslq -0xc3510(%rbp,%rax,4),%rax
ff
add    -0xc3520(%rbp),%rax
mov    %rax,-0xc3520(%rbp)
mov    -0xc3518(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc3518(%rbp)
jmp    11d3 <main+0xb3>
movslq -0xc3514(%rbp),%rsi
lea    0xddc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0xc3510(%rbp),%rsi
mov    -0xc350c(%rbp),%edx
mov    -0xc3384(%rbp),%ecx
mov    -0x31e00(%rbp),%r8d
lea    0xdbb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc3520(%rbp),%rsi
lea    0xde5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xc3520,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0xc3500,%rsp
movl   $0x2,(%rsp)
mov    $0x1,%ebp
mov    $0x3,%ebx
mov    %rsp,%r14
jmp    115b <main+0x3b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebx
cmp    $0x1e8480,%ebx
je     1177 <main+0x57>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
call   1040 <check@plt>
test   %rax,%rax
je     1150 <main+0x30>
movslq %ebp,%rax
mov    %ebx,(%rsp,%rax,4)
add    $0x1,%ebp
jmp    1150 <main+0x30>
test   %ebp,%ebp
jle    118b <main+0x6b>
mov    %ebp,%eax
cmp    $0x4,%ebp
jae    1192 <main+0x72>
xor    %ecx,%ecx
xor    %ebx,%ebx
jmp    1270 <main+0x150>
xor    %ebx,%ebx
jmp    1280 <main+0x160>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     12d5 <main+0x1b5>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
movq   (%rsp,%rsi,4),%xmm2
movq   0x8(%rsp,%rsi,4),%xmm3
pxor   %xmm4,%xmm4
pcmpgtd %xmm2,%xmm4
punpckldq %xmm4,%xmm2
paddq  %xmm0,%xmm2
pxor   %xmm0,%xmm0
pcmpgtd %xmm3,%xmm0
punpckldq %xmm0,%xmm3
paddq  %xmm1,%xmm3
movq   0x10(%rsp,%rsi,4),%xmm0
movq   0x18(%rsp,%rsi,4),%xmm1
pxor   %xmm4,%xmm4
pcmpgtd %xmm0,%xmm4
punpckldq %xmm4,%xmm0
paddq  %xmm2,%xmm0
pxor   %xmm2,%xmm2
pcmpgtd %xmm1,%xmm2
punpckldq %xmm2,%xmm1
paddq  %xmm3,%xmm1
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11c0 <main+0xa0>
test   $0x1,%dl
je     1251 <main+0x131>
movq   (%rsp,%rsi,4),%xmm2
movq   0x8(%rsp,%rsi,4),%xmm3
pxor   %xmm4,%xmm4
pxor   %xmm5,%xmm5
pcmpgtd %xmm2,%xmm5
punpckldq %xmm5,%xmm2
paddq  %xmm2,%xmm0
pcmpgtd %xmm3,%xmm4
punpckldq %xmm4,%xmm3
paddq  %xmm3,%xmm1
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rbx
cmp    %rax,%rcx
je     1280 <main+0x160>
nopl   0x0(%rax,%rax,1)
movslq (%rsp,%rcx,4),%rdx
add    %rdx,%rbx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1270 <main+0x150>
movslq %ebp,%rsi
lea    0xd76(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
movslq (%rsp),%rsi
mov    0x4(%rsp),%edx
mov    0x18c(%rsp),%ecx
mov    0x91710(%rsp),%r8d
lea    0xd58(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xd89(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xc3500,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    1226 <main+0x106>
jmp    1251 <main+0x131>

LLVM IR (-O0):
@.str = [7 x i8] c"n: %d\0A\00"
@.str.1 = [63 x i8] c"primes[0]: %d\0Aprimes[1]: %d\0Aprimes[99]: %d\0Aprimes[148932]: %d\0A\00"
@.str.2 = [10 x i8] c"sum: %ld\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [200000 x i32]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i64
store i32 0, i32* %1
store i32 1, i32* %3
store i64 0, i64* %5
%6 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 0
store i32 2, i32* %6
store i32 3, i32* %4
br label %7
7: ; preds = %24, %0
%8 = load i32, i32* %4
%9 = icmp slt i32 %8, 2000000
br i1 %9, label %10, label %27
10: ; preds = %7
%11 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 0
%12 = load i32, i32* %3
%13 = load i32, i32* %4
%14 = call i64 @check(i32* %11, i32 %12, i32 %13)
%15 = icmp ne i64 %14, 0
br i1 %15, label %16, label %23
16: ; preds = %10
%17 = load i32, i32* %4
%18 = load i32, i32* %3
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 %19
store i32 %17, i32* %20
%21 = load i32, i32* %3
%22 = add nsw i32 %21, 1
store i32 %22, i32* %3
br label %23
23: ; preds = %16, %10
br label %24
24: ; preds = %23
%25 = load i32, i32* %4
%26 = add nsw i32 %25, 1
store i32 %26, i32* %4
br label %7
27: ; preds = %7
store i32 0, i32* %4
br label %28
28: ; preds = %40, %27
%29 = load i32, i32* %4
%30 = load i32, i32* %3
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %43
32: ; preds = %28
%33 = load i32, i32* %4
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 %34
%36 = load i32, i32* %35
%37 = sext i32 %36 to i64
%38 = load i64, i64* %5
%39 = add nsw i64 %38, %37
store i64 %39, i64* %5
br label %40
40: ; preds = %32
%41 = load i32, i32* %4
%42 = add nsw i32 %41, 1
store i32 %42, i32* %4
br label %28
43: ; preds = %28
%44 = load i32, i32* %3
%45 = sext i32 %44 to i64
%46 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i64 %45)
%47 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 0
%48 = load i32, i32* %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 1
%51 = load i32, i32* %50
%52 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 99
%53 = load i32, i32* %52
%54 = getelementptr inbounds [200000 x i32], [200000 x i32]* %2, i64 0, i64 148932
%55 = load i32, i32* %54
%56 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.1, i64 0, i64 0), i64 %49, i32 %51, i32 %53, i32 %55)
%57 = load i64, i64* %5
%58 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), i64 %57)
ret i32 0
}

LLVM IR (-O2):
@.str = [7 x i8] c"n: %d\0A\00"
@.str.1 = [63 x i8] c"primes[0]: %d\0Aprimes[1]: %d\0Aprimes[99]: %d\0Aprimes[148932]: %d\0A\00"
@.str.2 = [10 x i8] c"sum: %ld\0A\00"
define i32 @main() {
%1 = alloca [200000 x i32]
%2 = bitcast [200000 x i32]* %1 to i8*
%3 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 0
store i32 2, i32* %3
br label %74
4: ; preds = %83
%5 = icmp sgt i32 %84, 0
br i1 %5, label %6, label %96
6: ; preds = %4
%7 = zext i32 %84 to i64
%8 = icmp ult i32 %84, 4
br i1 %8, label %71, label %9
9: ; preds = %6
%10 = and i64 %7, 4294967292
%11 = add nsw i64 %10, -4
%12 = lshr exact i64 %11, 2
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 1
%15 = icmp eq i64 %11, 0
br i1 %15, label %47, label %16
16: ; preds = %9
%17 = and i64 %13, 9223372036854775806
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %44, %18 ]
%20 = phi <2 x i64> [ zeroinitializer, %16 ], [ %42, %18 ]
%21 = phi <2 x i64> [ zeroinitializer, %16 ], [ %43, %18 ]
%22 = phi i64 [ 0, %16 ], [ %45, %18 ]
%23 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 %19
%24 = bitcast i32* %23 to <2 x i32>*
%25 = load <2 x i32>, <2 x i32>* %24
%26 = getelementptr inbounds i32, i32* %23, i64 2
%27 = bitcast i32* %26 to <2 x i32>*
%28 = load <2 x i32>, <2 x i32>* %27
%29 = sext <2 x i32> %25 to <2 x i64>
%30 = sext <2 x i32> %28 to <2 x i64>
%31 = add <2 x i64> %20, %29
%32 = add <2 x i64> %21, %30
%33 = or i64 %19, 4
%34 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 %33
%35 = bitcast i32* %34 to <2 x i32>*
%36 = load <2 x i32>, <2 x i32>* %35
%37 = getelementptr inbounds i32, i32* %34, i64 2
%38 = bitcast i32* %37 to <2 x i32>*
%39 = load <2 x i32>, <2 x i32>* %38
%40 = sext <2 x i32> %36 to <2 x i64>
%41 = sext <2 x i32> %39 to <2 x i64>
%42 = add <2 x i64> %31, %40
%43 = add <2 x i64> %32, %41
%44 = add nuw i64 %19, 8
%45 = add i64 %22, 2
%46 = icmp eq i64 %45, %17
br i1 %46, label %47, label %18
47: ; preds = %18, %9
%48 = phi <2 x i64> [ undef, %9 ], [ %42, %18 ]
%49 = phi <2 x i64> [ undef, %9 ], [ %43, %18 ]
%50 = phi i64 [ 0, %9 ], [ %44, %18 ]
%51 = phi <2 x i64> [ zeroinitializer, %9 ], [ %42, %18 ]
%52 = phi <2 x i64> [ zeroinitializer, %9 ], [ %43, %18 ]
%53 = icmp eq i64 %14, 0
br i1 %53, label %65, label %54
54: ; preds = %47
%55 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 %50
%56 = bitcast i32* %55 to <2 x i32>*
%57 = load <2 x i32>, <2 x i32>* %56
%58 = getelementptr inbounds i32, i32* %55, i64 2
%59 = bitcast i32* %58 to <2 x i32>*
%60 = load <2 x i32>, <2 x i32>* %59
%61 = sext <2 x i32> %57 to <2 x i64>
%62 = sext <2 x i32> %60 to <2 x i64>
%63 = add <2 x i64> %51, %61
%64 = add <2 x i64> %52, %62
br label %65
65: ; preds = %47, %54
%66 = phi <2 x i64> [ %48, %47 ], [ %63, %54 ]
%67 = phi <2 x i64> [ %49, %47 ], [ %64, %54 ]
%68 = add <2 x i64> %67, %66
%69 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %68)
%70 = icmp eq i64 %10, %7
br i1 %70, label %96, label %71
71: ; preds = %6, %65
%72 = phi i64 [ 0, %6 ], [ %10, %65 ]
%73 = phi i64 [ 0, %6 ], [ %69, %65 ]
br label %87
74: ; preds = %0, %83
%75 = phi i32 [ 3, %0 ], [ %85, %83 ]
%76 = phi i32 [ 1, %0 ], [ %84, %83 ]
%77 = call i64 @check(i32* %3, i32 %76, i32 %75)
%78 = icmp eq i64 %77, 0
br i1 %78, label %83, label %79
79: ; preds = %74
%80 = sext i32 %76 to i64
%81 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 %80
store i32 %75, i32* %81
%82 = add nsw i32 %76, 1
br label %83
83: ; preds = %74, %79
%84 = phi i32 [ %82, %79 ], [ %76, %74 ]
%85 = add nuw nsw i32 %75, 1
%86 = icmp eq i32 %85, 2000000
br i1 %86, label %4, label %74
87: ; preds = %71, %87
%88 = phi i64 [ %94, %87 ], [ %72, %71 ]
%89 = phi i64 [ %93, %87 ], [ %73, %71 ]
%90 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 %88
%91 = load i32, i32* %90
%92 = sext i32 %91 to i64
%93 = add nsw i64 %89, %92
%94 = add nuw nsw i64 %88, 1
%95 = icmp eq i64 %94, %7
br i1 %95, label %96, label %87
96: ; preds = %87, %65, %4
%97 = phi i64 [ 0, %4 ], [ %69, %65 ], [ %93, %87 ]
%98 = sext i32 %84 to i64
%99 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i64 %98)
%100 = load i32, i32* %3
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 1
%103 = load i32, i32* %102
%104 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 99
%105 = load i32, i32* %104
%106 = getelementptr inbounds [200000 x i32], [200000 x i32]* %1, i64 0, i64 148932
%107 = load i32, i32* %106
%108 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.1, i64 0, i64 0), i64 %101, i32 %103, i32 %105, i32 %107)
%109 = call i32 (i8*, i64, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i64 0, i64 0), i64 %97)
ret i32 0
}