#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 */
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ printf(char *);
void generate_primes_window(int start, int end, bool *primes) {
  if (start >= end)
    return;
  if (start < 3) {
    printf("Use regular eratosthenes if you want to start from 1 or 2\n");
    free(primes);
    return;
  }
  for (int c = 0; c < (end - start); c++) {
    primes[c] = true;
  }
  for (int c = 2; (c * c) <= end; c++) {
    for (int d = start; d < end; d++) {
      if (primes[d - start] && (d % c == 0)) {
        while (d < end) {
          primes[d - start] = false;
          d += c;
        }
        break;
      }
    }
  }
}


x86 assembly (clang, -O0):
<generate_primes_window>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     1143 <generate_primes_window+0x23>
jmp    124a <generate_primes_window+0x12a>
cmpl   $0x3,-0x4(%rbp)
jge    1167 <generate_primes_window+0x47>
lea    0xeac(%rip),%rdi
call   1040 <printf@plt>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
jmp    124a <generate_primes_window+0x12a>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jge    119c <generate_primes_window+0x7c>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116e <generate_primes_window+0x4e>
movl   $0x2,-0x18(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     124a <generate_primes_window+0x12a>
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1237 <generate_primes_window+0x117>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1224 <generate_primes_window+0x104>
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x18(%rbp)
cmp    $0x0,%edx
jne    1224 <generate_primes_window+0x104>
jmp    11f1 <generate_primes_window+0xd1>
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    121f <generate_primes_window+0xff>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    11f1 <generate_primes_window+0xd1>
jmp    1237 <generate_primes_window+0x117>
jmp    1229 <generate_primes_window+0x109>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b9 <generate_primes_window+0x99>
jmp    123c <generate_primes_window+0x11c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11a3 <generate_primes_window+0x83>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generate_primes_window>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%ecx
sub    %edi,%ecx
jle    1286 <generate_primes_window+0x166>
mov    %rdx,%r14
cmp    $0x3,%edi
jge    1158 <generate_primes_window+0x38>
lea    0xece(%rip),%rdi
call   1040 <puts@plt>
mov    %r14,%rdi
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
jmp    1030 <free@plt>
test   %ecx,%ecx
jle    1281 <generate_primes_window+0x161>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    116e <generate_primes_window+0x4e>
xor    %ecx,%ecx
jmp    1270 <generate_primes_window+0x150>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbx
mov    %rbx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x7,%r8d
cmp    $0x38,%rbx
jae    1196 <generate_primes_window+0x76>
xor    %ebx,%ebx
jmp    1235 <generate_primes_window+0x115>
and    $0xfffffffffffffff8,%rdx
xor    %ebx,%ebx
movaps 0xe5d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm0,(%r14,%rbx,4)
movups %xmm0,0x10(%r14,%rbx,4)
movups %xmm0,0x20(%r14,%rbx,4)
movups %xmm0,0x30(%r14,%rbx,4)
movups %xmm0,0x40(%r14,%rbx,4)
movups %xmm0,0x50(%r14,%rbx,4)
movups %xmm0,0x60(%r14,%rbx,4)
movups %xmm0,0x70(%r14,%rbx,4)
movups %xmm0,0x80(%r14,%rbx,4)
movups %xmm0,0x90(%r14,%rbx,4)
movups %xmm0,0xa0(%r14,%rbx,4)
movups %xmm0,0xb0(%r14,%rbx,4)
movups %xmm0,0xc0(%r14,%rbx,4)
movups %xmm0,0xd0(%r14,%rbx,4)
movups %xmm0,0xe0(%r14,%rbx,4)
movups %xmm0,0xf0(%r14,%rbx,4)
add    $0x40,%rbx
add    $0xfffffffffffffff8,%rdx
jne    11b0 <generate_primes_window+0x90>
test   %r8,%r8
je     1262 <generate_primes_window+0x142>
lea    (%r14,%rbx,4),%rdx
add    $0x10,%rdx
shl    $0x5,%r8
xor    %ebx,%ebx
movaps 0xdb1(%rip),%xmm0
nop
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm0,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1250 <generate_primes_window+0x130>
cmp    %rax,%rcx
je     1281 <generate_primes_window+0x161>
nopw   0x0(%rax,%rax,1)
movl   $0x1,(%r14,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1270 <generate_primes_window+0x150>
cmp    $0x4,%esi
jge    1290 <generate_primes_window+0x170>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
movslq %edi,%rax
mov    %esi,%r10d
mov    %rax,%r8
shl    $0x20,%r8
shl    $0x2,%rax
mov    %r14,%r9
sub    %rax,%r9
mov    $0x2,%r12d
mov    $0x8,%r11d
movabs $0x100000000,%r15
jmp    12d3 <generate_primes_window+0x1b3>
nop
add    $0x1,%r12
mov    %r12d,%eax
imul   %r12d,%eax
add    $0x4,%r11
cmp    %esi,%eax
jg     1286 <generate_primes_window+0x166>
mov    %r14,%rbx
mov    %r8,%r13
mov    %edi,%ecx
jmp    12ee <generate_primes_window+0x1ce>
nopl   (%rax)
add    $0x1,%ecx
add    %r15,%r13
add    $0x4,%rbx
cmp    %ecx,%esi
je     12c0 <generate_primes_window+0x1a0>
cmpl   $0x0,(%rbx)
je     12e0 <generate_primes_window+0x1c0>
mov    %ecx,%eax
cltd
idiv   %r12d
test   %edx,%edx
jne    12e0 <generate_primes_window+0x1c0>
cmp    %esi,%ecx
jge    12c0 <generate_primes_window+0x1a0>
sar    $0x20,%r13
movslq %ecx,%rax
lea    (%r9,%rax,4),%rax
nopl   0x0(%rax)
movl   $0x0,(%rax)
add    %r12,%r13
add    %r11,%rax
cmp    %r10,%r13
jl     1310 <generate_primes_window+0x1f0>
jmp    12c0 <generate_primes_window+0x1a0>

LLVM IR (-O0):
@.str = [59 x i8] c"Use regular eratosthenes if you want to start from 1 or 2\0A\00"
define void @generate_primes_window(i32 %0, i32 %1, i32* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
store i32* %2, i32** %6
%10 = load i32, i32* %4
%11 = load i32, i32* %5
%12 = icmp sge i32 %10, %11
br i1 %12, label %13, label %14
13: ; preds = %3
br label %87
14: ; preds = %3
%15 = load i32, i32* %4
%16 = icmp slt i32 %15, 3
br i1 %16, label %17, label %21
17: ; preds = %14
%18 = call i32 @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%19 = load i32*, i32** %6
%20 = call i32 @free(i32* %19)
br label %87
21: ; preds = %14
store i32 0, i32* %7
br label %22
22: ; preds = %33, %21
%23 = load i32, i32* %7
%24 = load i32, i32* %5
%25 = load i32, i32* %4
%26 = sub nsw i32 %24, %25
%27 = icmp slt i32 %23, %26
br i1 %27, label %28, label %36
28: ; preds = %22
%29 = load i32*, i32** %6
%30 = load i32, i32* %7
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
store i32 1, i32* %32
br label %33
33: ; preds = %28
%34 = load i32, i32* %7
%35 = add nsw i32 %34, 1
store i32 %35, i32* %7
br label %22
36: ; preds = %22
store i32 2, i32* %8
br label %37
37: ; preds = %84, %36
%38 = load i32, i32* %8
%39 = load i32, i32* %8
%40 = mul nsw i32 %38, %39
%41 = load i32, i32* %5
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %87
43: ; preds = %37
%44 = load i32, i32* %4
store i32 %44, i32* %9
br label %45
45: ; preds = %80, %43
%46 = load i32, i32* %9
%47 = load i32, i32* %5
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %83
49: ; preds = %45
%50 = load i32*, i32** %6
%51 = load i32, i32* %9
%52 = load i32, i32* %4
%53 = sub nsw i32 %51, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %50, i64 %54
%56 = load i32, i32* %55
%57 = icmp ne i32 %56, 0
br i1 %57, label %58, label %79
58: ; preds = %49
%59 = load i32, i32* %9
%60 = load i32, i32* %8
%61 = srem i32 %59, %60
%62 = icmp eq i32 %61, 0
br i1 %62, label %63, label %79
63: ; preds = %58
br label %64
64: ; preds = %68, %63
%65 = load i32, i32* %9
%66 = load i32, i32* %5
%67 = icmp slt i32 %65, %66
br i1 %67, label %68, label %78
68: ; preds = %64
%69 = load i32*, i32** %6
%70 = load i32, i32* %9
%71 = load i32, i32* %4
%72 = sub nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %69, i64 %73
store i32 0, i32* %74
%75 = load i32, i32* %8
%76 = load i32, i32* %9
%77 = add nsw i32 %76, %75
store i32 %77, i32* %9
br label %64
78: ; preds = %64
br label %83
79: ; preds = %58, %49
br label %80
80: ; preds = %79
%81 = load i32, i32* %9
%82 = add nsw i32 %81, 1
store i32 %82, i32* %9
br label %45
83: ; preds = %78, %45
br label %84
84: ; preds = %83
%85 = load i32, i32* %8
%86 = add nsw i32 %85, 1
store i32 %86, i32* %8
br label %37
87: ; preds = %13, %17, %37
ret void
}

LLVM IR (-O2):
@str = [58 x i8] c"Use regular eratosthenes if you want to start from 1 or 2\00"
define void @generate_primes_window(i32 %0, i32 %1, i32* nocapture %2) {
%4 = icmp sgt i32 %1, %0
br i1 %4, label %5, label %131
5: ; preds = %3
%6 = icmp slt i32 %0, 3
br i1 %6, label %84, label %7
7: ; preds = %5
%8 = sub i32 %1, %0
%9 = icmp sgt i32 %8, 0
br i1 %9, label %10, label %87
10: ; preds = %7
%11 = zext i32 %8 to i64
%12 = icmp ult i32 %8, 8
br i1 %12, label %82, label %13
13: ; preds = %10
%14 = and i64 %11, 4294967288
%15 = add nsw i64 %14, -8
%16 = lshr exact i64 %15, 3
%17 = add nuw nsw i64 %16, 1
%18 = and i64 %17, 7
%19 = icmp ult i64 %15, 56
br i1 %19, label %67, label %20
20: ; preds = %13
%21 = and i64 %17, 4611686018427387896
br label %22
22: ; preds = %22, %20
%23 = phi i64 [ 0, %20 ], [ %64, %22 ]
%24 = phi i64 [ 0, %20 ], [ %65, %22 ]
%25 = getelementptr inbounds i32, i32* %2, i64 %23
%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 = getelementptr inbounds i32, i32* %25, i64 4
%28 = bitcast i32* %27 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %28
%29 = or i64 %23, 8
%30 = getelementptr inbounds i32, i32* %2, i64 %29
%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 = getelementptr inbounds i32, i32* %30, i64 4
%33 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %33
%34 = or i64 %23, 16
%35 = getelementptr inbounds i32, i32* %2, i64 %34
%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 = getelementptr inbounds i32, i32* %35, i64 4
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %38
%39 = or i64 %23, 24
%40 = getelementptr inbounds i32, i32* %2, i64 %39
%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 = getelementptr inbounds i32, i32* %40, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %43
%44 = or i64 %23, 32
%45 = getelementptr inbounds i32, i32* %2, i64 %44
%46 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %46
%47 = getelementptr inbounds i32, i32* %45, i64 4
%48 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %48
%49 = or i64 %23, 40
%50 = getelementptr inbounds i32, i32* %2, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %51
%52 = getelementptr inbounds i32, i32* %50, i64 4
%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 = or i64 %23, 48
%55 = getelementptr inbounds i32, i32* %2, i64 %54
%56 = bitcast i32* %55 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %56
%57 = getelementptr inbounds i32, i32* %55, i64 4
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %58
%59 = or i64 %23, 56
%60 = getelementptr inbounds i32, i32* %2, i64 %59
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %61
%62 = getelementptr inbounds i32, i32* %60, i64 4
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %63
%64 = add nuw i64 %23, 64
%65 = add nuw i64 %24, 8
%66 = icmp eq i64 %65, %21
br i1 %66, label %67, label %22
67: ; preds = %22, %13
%68 = phi i64 [ 0, %13 ], [ %64, %22 ]
%69 = icmp eq i64 %18, 0
br i1 %69, label %80, label %70
70: ; preds = %67, %70
%71 = phi i64 [ %77, %70 ], [ %68, %67 ]
%72 = phi i64 [ %78, %70 ], [ 0, %67 ]
%73 = getelementptr inbounds i32, i32* %2, i64 %71
%74 = bitcast i32* %73 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %74
%75 = getelementptr inbounds i32, i32* %73, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %76
%77 = add nuw i64 %71, 8
%78 = add i64 %72, 1
%79 = icmp eq i64 %78, %18
br i1 %79, label %80, label %70
80: ; preds = %70, %67
%81 = icmp eq i64 %14, %11
br i1 %81, label %87, label %82
82: ; preds = %10, %80
%83 = phi i64 [ 0, %10 ], [ %14, %80 ]
br label %92
84: ; preds = %5
%85 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @str, i64 0, i64 0))
%86 = tail call i32 @free(i32* %2)
br label %131
87: ; preds = %92, %80, %7
%88 = icmp slt i32 %1, 4
br i1 %88, label %131, label %89
89: ; preds = %87
%90 = sext i32 %0 to i64
%91 = zext i32 %1 to i64
br label %97
92: ; preds = %82, %92
%93 = phi i64 [ %95, %92 ], [ %83, %82 ]
%94 = getelementptr inbounds i32, i32* %2, i64 %93
store i32 1, i32* %94
%95 = add nuw nsw i64 %93, 1
%96 = icmp eq i64 %95, %11
br i1 %96, label %87, label %92
97: ; preds = %126, %89
%98 = phi i64 [ 2, %89 ], [ %127, %126 ]
%99 = trunc i64 %98 to i32
br label %100
100: ; preds = %97, %122
%101 = phi i64 [ %90, %97 ], [ %123, %122 ]
%102 = sub nsw i64 %101, %90
%103 = getelementptr inbounds i32, i32* %2, i64 %102
%104 = load i32, i32* %103
%105 = icmp eq i32 %104, 0
br i1 %105, label %122, label %106
106: ; preds = %100
%107 = trunc i64 %101 to i32
%108 = srem i32 %107, %99
%109 = icmp eq i32 %108, 0
br i1 %109, label %110, label %122
110: ; preds = %106
%111 = trunc i64 %101 to i32
%112 = icmp slt i32 %111, %1
br i1 %112, label %113, label %126
113: ; preds = %110
%114 = shl i64 %101, 32
%115 = ashr exact i64 %114, 32
br label %116
116: ; preds = %113, %116
%117 = phi i64 [ %115, %113 ], [ %120, %116 ]
%118 = sub nsw i64 %117, %90
%119 = getelementptr inbounds i32, i32* %2, i64 %118
store i32 0, i32* %119
%120 = add i64 %117, %98
%121 = icmp slt i64 %120, %91
br i1 %121, label %116, label %126
122: ; preds = %100, %106
%123 = add nsw i64 %101, 1
%124 = trunc i64 %123 to i32
%125 = icmp eq i32 %124, %1
br i1 %125, label %126, label %100
126: ; preds = %122, %116, %110
%127 = add nuw i64 %98, 1
%128 = trunc i64 %127 to i32
%129 = mul nsw i32 %128, %128
%130 = icmp sgt i32 %129, %1
br i1 %130, label %131, label %97
131: ; preds = %126, %87, %3, %84
ret void
}