#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__ floor(int /*<<< orphan*/);
int /*<<< orphan*/ sqrt(int);
int prime(int p[], int max) {
  int i, j;
  for (i = 1; i <= max; i++) {
    p[i] = 1;
  }
  for (i = 2; i <= (int)floor(sqrt(max)); i++) {
    if (i == 0)
      continue;
    for (j = 2; i * j <= max; j++) {
      p[i * j] = 0;
    }
  }
  j = 0;
  for (i = 1; i <= max; i++) {
    if (p[i] == 1)
      p[j++] = i;
  }
  p[j] = 0;
}


x86 assembly (clang, -O0):
<prime>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     115f <prime+0x3f>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1136 <prime+0x16>
movl   $0x2,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%edi
call   1030 <sqrt@plt>
mov    %eax,%edi
call   1040 <floor@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%eax
cmp    %ecx,%eax
jg     11e5 <prime+0xc5>
cmpl   $0x0,-0x18(%rbp)
jne    1198 <prime+0x78>
jmp    11d7 <prime+0xb7>
movl   $0x2,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11d2 <prime+0xb2>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    119f <prime+0x7f>
jmp    11d7 <prime+0xb7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1166 <prime+0x46>
movl   $0x0,-0x1c(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     123c <prime+0x11c>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1229 <prime+0x109>
mov    -0x18(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    122e <prime+0x10e>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11f3 <prime+0xd3>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prime>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r12d
mov    %rdi,%r15
mov    %esi,%r14d
test   %esi,%esi
jle    1211 <prime+0xf1>
mov    $0x1,%eax
cmp    $0x8,%r12d
jb     11fa <prime+0xda>
mov    %r14d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdx
jae    116f <prime+0x4f>
xor    %edx,%edx
jmp    11ba <prime+0x9a>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
movaps 0xe84(%rip),%xmm0
nopl   0x0(%rax)
movups %xmm0,0x4(%r15,%rdx,4)
movups %xmm0,0x14(%r15,%rdx,4)
movups %xmm0,0x24(%r15,%rdx,4)
movups %xmm0,0x34(%r15,%rdx,4)
movups %xmm0,0x44(%r15,%rdx,4)
movups %xmm0,0x54(%r15,%rdx,4)
movups %xmm0,0x64(%r15,%rdx,4)
movups %xmm0,0x74(%r15,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1180 <prime+0x60>
test   %rcx,%rcx
je     11f1 <prime+0xd1>
movaps 0xe3a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rdx,4),%rsi
or     $0x4,%rsi
movups %xmm0,(%r15,%rsi,1)
movups %xmm0,0x10(%r15,%rsi,1)
add    $0x8,%rdx
add    $0xffffffffffffffff,%rcx
jne    11d0 <prime+0xb0>
cmp    %rax,%r14
je     1211 <prime+0xf1>
or     $0x1,%rax
lea    0x1(%r14),%rcx
xchg   %ax,%ax
movl   $0x1,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1200 <prime+0xe0>
mov    %r12d,%edi
call   1030 <sqrt@plt>
mov    %eax,%edi
call   1040 <floor@plt>
cmp    $0x2,%eax
jge    1254 <prime+0x134>
test   %r12d,%r12d
jle    12a3 <prime+0x183>
cmp    $0x1,%r12d
jne    12be <prime+0x19e>
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%r14b
je     12a5 <prime+0x185>
cmpl   $0x1,(%r15,%rcx,4)
jne    12a5 <prime+0x185>
movslq %eax,%rdx
add    $0x1,%eax
mov    %ecx,(%r15,%rdx,4)
jmp    12a5 <prime+0x185>
mov    $0x2,%ebp
mov    $0x4,%ebx
jmp    127d <prime+0x15d>
lea    0x1(%rbp),%r13d
mov    %r12d,%edi
call   1030 <sqrt@plt>
mov    %eax,%edi
call   1040 <floor@plt>
add    $0x2,%ebx
cmp    %eax,%ebp
mov    %r13d,%ebp
jge    1225 <prime+0x105>
lea    0x0(%rbp,%rbp,1),%ecx
mov    %ebx,%eax
cmp    %r12d,%ecx
jg     1260 <prime+0x140>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
movl   $0x0,(%r15,%rcx,4)
add    %ebp,%eax
cmp    %r12d,%eax
jle    1290 <prime+0x170>
jmp    1260 <prime+0x140>
xor    %eax,%eax
cltq
movl   $0x0,(%r15,%rax,4)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14d,%edx
and    $0xfffffffe,%edx
neg    %rdx
xor    %eax,%eax
mov    $0x1,%ecx
jmp    12e6 <prime+0x1c6>
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
je     123b <prime+0x11b>
cmpl   $0x1,(%r15,%rcx,4)
jne    12f7 <prime+0x1d7>
movslq %eax,%rsi
add    $0x1,%eax
mov    %ecx,(%r15,%rsi,4)
cmpl   $0x1,0x4(%r15,%rcx,4)
jne    12d0 <prime+0x1b0>
movslq %eax,%rsi
add    $0x1,%eax
lea    0x1(%rcx),%edi
mov    %edi,(%r15,%rsi,4)
jmp    12d0 <prime+0x1b0>

LLVM IR (-O0):
define i32 @prime(i32* %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 1, i32* %6
br label %8
8: ; preds = %17, %2
%9 = load i32, i32* %6
%10 = load i32, i32* %5
%11 = icmp sle i32 %9, %10
br i1 %11, label %12, label %20
12: ; preds = %8
%13 = load i32*, i32** %4
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i32, i32* %13, i64 %15
store i32 1, i32* %16
br label %17
17: ; preds = %12
%18 = load i32, i32* %6
%19 = add nsw i32 %18, 1
store i32 %19, i32* %6
br label %8
20: ; preds = %8
store i32 2, i32* %6
br label %21
21: ; preds = %50, %20
%22 = load i32, i32* %6
%23 = load i32, i32* %5
%24 = call i32 @sqrt(i32 %23)
%25 = call i64 @floor(i32 %24)
%26 = trunc i64 %25 to i32
%27 = icmp sle i32 %22, %26
br i1 %27, label %28, label %53
28: ; preds = %21
%29 = load i32, i32* %6
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %32
31: ; preds = %28
br label %50
32: ; preds = %28
store i32 2, i32* %7
br label %33
33: ; preds = %46, %32
%34 = load i32, i32* %6
%35 = load i32, i32* %7
%36 = mul nsw i32 %34, %35
%37 = load i32, i32* %5
%38 = icmp sle i32 %36, %37
br i1 %38, label %39, label %49
39: ; preds = %33
%40 = load i32*, i32** %4
%41 = load i32, i32* %6
%42 = load i32, i32* %7
%43 = mul nsw i32 %41, %42
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %40, i64 %44
store i32 0, i32* %45
br label %46
46: ; preds = %39
%47 = load i32, i32* %7
%48 = add nsw i32 %47, 1
store i32 %48, i32* %7
br label %33
49: ; preds = %33
br label %50
50: ; preds = %49, %31
%51 = load i32, i32* %6
%52 = add nsw i32 %51, 1
store i32 %52, i32* %6
br label %21
53: ; preds = %21
store i32 0, i32* %7
store i32 1, i32* %6
br label %54
54: ; preds = %73, %53
%55 = load i32, i32* %6
%56 = load i32, i32* %5
%57 = icmp sle i32 %55, %56
br i1 %57, label %58, label %76
58: ; preds = %54
%59 = load i32*, i32** %4
%60 = load i32, i32* %6
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %59, i64 %61
%63 = load i32, i32* %62
%64 = icmp eq i32 %63, 1
br i1 %64, label %65, label %72
65: ; preds = %58
%66 = load i32, i32* %6
%67 = load i32*, i32** %4
%68 = load i32, i32* %7
%69 = add nsw i32 %68, 1
store i32 %69, i32* %7
%70 = sext i32 %68 to i64
%71 = getelementptr inbounds i32, i32* %67, i64 %70
store i32 %66, i32* %71
br label %72
72: ; preds = %65, %58
br label %73
73: ; preds = %72
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
store i32 %75, i32* %6
br label %54
76: ; preds = %54
%77 = load i32*, i32** %4
%78 = load i32, i32* %7
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
store i32 0, i32* %80
%81 = load i32, i32* %3
ret i32 %81
}

LLVM IR (-O2):
define i32 @prime(i32* nocapture %0, i32 %1) {
%3 = icmp slt i32 %1, 1
br i1 %3, label %63, label %4
4: ; preds = %2
%5 = add nuw i32 %1, 1
%6 = zext i32 %5 to i64
%7 = add nsw i64 %6, -1
%8 = icmp ult i64 %7, 8
br i1 %8, label %61, label %9
9: ; preds = %4
%10 = and i64 %7, -8
%11 = or i64 %10, 1
%12 = add nsw i64 %10, -8
%13 = lshr exact i64 %12, 3
%14 = add nuw nsw i64 %13, 1
%15 = and i64 %14, 3
%16 = icmp ult i64 %12, 24
br i1 %16, label %45, label %17
17: ; preds = %9
%18 = and i64 %14, 4611686018427387900
br label %19
19: ; preds = %19, %17
%20 = phi i64 [ 0, %17 ], [ %42, %19 ]
%21 = phi i64 [ 0, %17 ], [ %43, %19 ]
%22 = or i64 %20, 1
%23 = getelementptr inbounds i32, i32* %0, i64 %22
%24 = bitcast i32* %23 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %24
%25 = getelementptr inbounds i32, i32* %23, i64 4
%26 = bitcast i32* %25 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %26
%27 = or i64 %20, 9
%28 = getelementptr inbounds i32, i32* %0, i64 %27
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %29
%30 = getelementptr inbounds i32, i32* %28, i64 4
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %31
%32 = or i64 %20, 17
%33 = getelementptr inbounds i32, i32* %0, i64 %32
%34 = bitcast i32* %33 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %34
%35 = getelementptr inbounds i32, i32* %33, i64 4
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %36
%37 = or i64 %20, 25
%38 = getelementptr inbounds i32, i32* %0, i64 %37
%39 = bitcast i32* %38 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %39
%40 = getelementptr inbounds i32, i32* %38, i64 4
%41 = bitcast i32* %40 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %41
%42 = add nuw i64 %20, 32
%43 = add i64 %21, 4
%44 = icmp eq i64 %43, %18
br i1 %44, label %45, label %19
45: ; preds = %19, %9
%46 = phi i64 [ 0, %9 ], [ %42, %19 ]
%47 = icmp eq i64 %15, 0
br i1 %47, label %59, label %48
48: ; preds = %45, %48
%49 = phi i64 [ %56, %48 ], [ %46, %45 ]
%50 = phi i64 [ %57, %48 ], [ 0, %45 ]
%51 = or i64 %49, 1
%52 = getelementptr inbounds i32, i32* %0, i64 %51
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %53
%54 = getelementptr inbounds i32, i32* %52, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %55
%56 = add nuw i64 %49, 8
%57 = add i64 %50, 1
%58 = icmp eq i64 %57, %15
br i1 %58, label %59, label %48
59: ; preds = %48, %45
%60 = icmp eq i64 %7, %10
br i1 %60, label %63, label %61
61: ; preds = %4, %59
%62 = phi i64 [ 1, %4 ], [ %11, %59 ]
br label %68
63: ; preds = %68, %59, %2
%64 = tail call i32 @sqrt(i32 %1)
%65 = tail call i64 @floor(i32 %64)
%66 = trunc i64 %65 to i32
%67 = icmp slt i32 %66, 2
br i1 %67, label %77, label %73
68: ; preds = %61, %68
%69 = phi i64 [ %71, %68 ], [ %62, %61 ]
%70 = getelementptr inbounds i32, i32* %0, i64 %69
store i32 1, i32* %70
%71 = add nuw nsw i64 %69, 1
%72 = icmp eq i64 %71, %6
br i1 %72, label %63, label %68
73: ; preds = %63, %93
%74 = phi i32 [ %94, %93 ], [ 2, %63 ]
%75 = shl nuw nsw i32 %74, 1
%76 = icmp sgt i32 %75, %1
br i1 %76, label %93, label %84
77: ; preds = %93, %63
br i1 %3, label %141, label %78
78: ; preds = %77
%79 = zext i32 %1 to i64
%80 = and i64 %79, 1
%81 = icmp eq i32 %1, 1
br i1 %81, label %127, label %82
82: ; preds = %78
%83 = and i64 %79, 4294967294
br label %99
84: ; preds = %73, %84
%85 = phi i64 [ %89, %84 ], [ 2, %73 ]
%86 = phi i32 [ %91, %84 ], [ %75, %73 ]
%87 = zext i32 %86 to i64
%88 = getelementptr inbounds i32, i32* %0, i64 %87
store i32 0, i32* %88
%89 = add nuw nsw i64 %85, 1
%90 = trunc i64 %89 to i32
%91 = mul nsw i32 %74, %90
%92 = icmp sgt i32 %91, %1
br i1 %92, label %93, label %84
93: ; preds = %84, %73
%94 = add nuw nsw i32 %74, 1
%95 = tail call i32 @sqrt(i32 %1)
%96 = tail call i64 @floor(i32 %95)
%97 = trunc i64 %96 to i32
%98 = icmp slt i32 %74, %97
br i1 %98, label %73, label %77
99: ; preds = %122, %82
%100 = phi i64 [ 1, %82 ], [ %124, %122 ]
%101 = phi i32 [ 0, %82 ], [ %123, %122 ]
%102 = phi i64 [ 0, %82 ], [ %125, %122 ]
%103 = getelementptr inbounds i32, i32* %0, i64 %100
%104 = load i32, i32* %103
%105 = icmp eq i32 %104, 1
br i1 %105, label %106, label %111
106: ; preds = %99
%107 = add nsw i32 %101, 1
%108 = sext i32 %101 to i64
%109 = getelementptr inbounds i32, i32* %0, i64 %108
%110 = trunc i64 %100 to i32
store i32 %110, i32* %109
br label %111
111: ; preds = %99, %106
%112 = phi i32 [ %107, %106 ], [ %101, %99 ]
%113 = add nuw nsw i64 %100, 1
%114 = getelementptr inbounds i32, i32* %0, i64 %113
%115 = load i32, i32* %114
%116 = icmp eq i32 %115, 1
br i1 %116, label %117, label %122
117: ; preds = %111
%118 = add nsw i32 %112, 1
%119 = sext i32 %112 to i64
%120 = getelementptr inbounds i32, i32* %0, i64 %119
%121 = trunc i64 %113 to i32
store i32 %121, i32* %120
br label %122
122: ; preds = %117, %111
%123 = phi i32 [ %118, %117 ], [ %112, %111 ]
%124 = add nuw nsw i64 %100, 2
%125 = add i64 %102, 2
%126 = icmp eq i64 %125, %83
br i1 %126, label %127, label %99
127: ; preds = %122, %78
%128 = phi i32 [ undef, %78 ], [ %123, %122 ]
%129 = phi i64 [ 1, %78 ], [ %124, %122 ]
%130 = phi i32 [ 0, %78 ], [ %123, %122 ]
%131 = icmp eq i64 %80, 0
br i1 %131, label %141, label %132
132: ; preds = %127
%133 = getelementptr inbounds i32, i32* %0, i64 %129
%134 = load i32, i32* %133
%135 = icmp eq i32 %134, 1
br i1 %135, label %136, label %141
136: ; preds = %132
%137 = add nsw i32 %130, 1
%138 = sext i32 %130 to i64
%139 = getelementptr inbounds i32, i32* %0, i64 %138
%140 = trunc i64 %129 to i32
store i32 %140, i32* %139
br label %141
141: ; preds = %127, %136, %132, %77
%142 = phi i32 [ 0, %77 ], [ %128, %127 ], [ %137, %136 ], [ %130, %132 ]
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %0, i64 %143
store i32 0, i32* %144
ret i32 undef
}