#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 */
typedef int uint8_t;
typedef int uint32_t;

/* Variables and functions */
int MAP_ANONYMOUS;
int *MAP_FAILED;
int MAP_SHARED;
int /*<<< orphan*/ PROT_NONE;
int PROT_READ;
int PROT_WRITE;
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ init();
int *malloc(int);
int *mmap(int /*<<< orphan*/ *, int, int, int, int, int /*<<< orphan*/);
int mprotect(int *, int, int /*<<< orphan*/);
int /*<<< orphan*/ read_ints(int /*<<< orphan*/, int *, int *, int);
int main(int argc, char **argv) {
  uint8_t *addr = mmap(NULL, 8192, PROT_READ | PROT_WRITE,
                       MAP_SHARED | MAP_ANONYMOUS, -1, 0);
  if (addr == MAP_FAILED)
    exit(1);
  int err = mprotect(addr + 4096, 4096, PROT_NONE);
  if (err != 0)
    exit(2);
  uint32_t *mem = malloc(sizeof(uint32_t) * 4096);
  addr[0] = 0x81;
  addr[1] = 0x80;
  addr[2] = 0x80;
  addr[3] = 0x00;
  addr[4] = 0x81;
  addr[5] = 0x80;
  addr[6] = 0x80;
  addr[7] = 0x00;
  addr[8] = 0x81;
  addr[9] = 0x80;
  addr[10] = 0x80;
  addr[11] = 0x00;
  for (int i = 12; i < 4096; i++) {
    addr[i] = 1;
  }
  init();
  read_ints(0, addr, mem, 4087);
  assert(4087 == mem[4086]);
  for (int i = 0; i < 4096; i++) {
    addr[i] = 1;
  }
  read_ints(0, addr, mem, 4096);
  assert(4096 == mem[4095]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0x2e6b(%rip),%rax
mov    (%rax),%edx
mov    0x2e2a(%rip),%rax
or     (%rax),%edx
mov    0x2e41(%rip),%rax
mov    (%rax),%ecx
mov    0x2e28(%rip),%rax
or     (%rax),%ecx
xor    %eax,%eax
mov    %eax,%edi
mov    $0x2000,%esi
mov    $0xffffffff,%r8d
xor    %r9d,%r9d
call   1030 <mmap@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    0x2de8(%rip),%rcx
cmp    (%rcx),%rax
jne    11e3 <main+0x73>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x18(%rbp),%rdi
add    $0x4000,%rdi
mov    0x2df3(%rip),%rax
mov    (%rax),%edx
mov    $0x1000,%esi
call   1070 <mprotect@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1218 <main+0xa8>
mov    $0x2,%edi
call   1080 <exit@plt>
mov    $0x4000,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x81,(%rax)
mov    -0x18(%rbp),%rax
movl   $0x80,0x4(%rax)
mov    -0x18(%rbp),%rax
movl   $0x80,0x8(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0xc(%rax)
mov    -0x18(%rbp),%rax
movl   $0x81,0x10(%rax)
mov    -0x18(%rbp),%rax
movl   $0x80,0x14(%rax)
mov    -0x18(%rbp),%rax
movl   $0x80,0x18(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0x1c(%rax)
mov    -0x18(%rbp),%rax
movl   $0x81,0x20(%rax)
mov    -0x18(%rbp),%rax
movl   $0x80,0x24(%rax)
mov    -0x18(%rbp),%rax
movl   $0x80,0x28(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0x2c(%rax)
movl   $0xc,-0x2c(%rbp)
cmpl   $0x1000,-0x2c(%rbp)
jge    12da <main+0x16a>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b0 <main+0x140>
mov    $0x0,%al
call   1050 <init@plt>
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
xor    %edi,%edi
mov    $0xff7,%ecx
call   1090 <read_ints@plt>
mov    -0x28(%rbp),%rcx
mov    $0xff7,%eax
cmp    0x3fd8(%rcx),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x1000,-0x30(%rbp)
jge    1342 <main+0x1d2>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1318 <main+0x1a8>
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
xor    %edi,%edi
mov    $0x1000,%ecx
call   1090 <read_ints@plt>
mov    -0x28(%rbp),%rcx
mov    $0x1000,%eax
cmp    0x3ffc(%rcx),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
push   %rax
mov    0x2e7d(%rip),%rax
mov    0x2e3e(%rip),%rcx
mov    (%rcx),%edx
or     (%rax),%edx
mov    0x2e53(%rip),%rax
mov    0x2e3c(%rip),%rcx
mov    (%rcx),%ecx
or     (%rax),%ecx
xor    %edi,%edi
mov    $0x2000,%esi
mov    $0xffffffff,%r8d
xor    %r9d,%r9d
call   1030 <mmap@plt>
mov    %rax,%rbx
mov    0x2e01(%rip),%rax
cmp    (%rax),%rbx
je     1352 <main+0x1e2>
lea    0x4000(%rbx),%rdi
mov    0x2e1a(%rip),%rax
mov    (%rax),%edx
mov    $0x1000,%esi
call   1070 <mprotect@plt>
test   %eax,%eax
jne    135c <main+0x1ec>
mov    $0x4000,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
movaps 0xe0a(%rip),%xmm0
movups %xmm0,(%rbx)
movups %xmm0,0x10(%rbx)
movups %xmm0,0x20(%rbx)
mov    $0x38,%eax
movaps 0xe03(%rip),%xmm0
nopl   (%rax)
movups %xmm0,-0xb0(%rbx,%rax,4)
ff
movups %xmm0,-0xa0(%rbx,%rax,4)
ff
movups %xmm0,-0x90(%rbx,%rax,4)
ff
movups %xmm0,-0x80(%rbx,%rax,4)
movups %xmm0,-0x70(%rbx,%rax,4)
movups %xmm0,-0x60(%rbx,%rax,4)
movups %xmm0,-0x50(%rbx,%rax,4)
movups %xmm0,-0x40(%rbx,%rax,4)
movups %xmm0,-0x30(%rbx,%rax,4)
movups %xmm0,-0x20(%rbx,%rax,4)
movups %xmm0,-0x10(%rbx,%rax,4)
movups %xmm0,(%rbx,%rax,4)
add    $0x30,%rax
cmp    $0x1028,%rax
jne    1210 <main+0xa0>
movups %xmm0,0x3ff0(%rbx)
xor    %eax,%eax
call   1050 <init@plt>
xor    %edi,%edi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    $0xff7,%ecx
call   1090 <read_ints@plt>
xor    %edi,%edi
cmpl   $0xff7,0x3fd8(%r14)
sete   %dil
call   1040 <assert@plt>
movaps 0xd73(%rip),%xmm0
mov    $0x3c,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups %xmm0,-0xf0(%rbx,%rax,4)
ff
movups %xmm0,-0xe0(%rbx,%rax,4)
ff
movups %xmm0,-0xd0(%rbx,%rax,4)
ff
movups %xmm0,-0xc0(%rbx,%rax,4)
ff
movups %xmm0,-0xb0(%rbx,%rax,4)
ff
movups %xmm0,-0xa0(%rbx,%rax,4)
ff
movups %xmm0,-0x90(%rbx,%rax,4)
ff
movups %xmm0,-0x80(%rbx,%rax,4)
movups %xmm0,-0x70(%rbx,%rax,4)
movups %xmm0,-0x60(%rbx,%rax,4)
movups %xmm0,-0x50(%rbx,%rax,4)
movups %xmm0,-0x40(%rbx,%rax,4)
movups %xmm0,-0x30(%rbx,%rax,4)
movups %xmm0,-0x20(%rbx,%rax,4)
movups %xmm0,-0x10(%rbx,%rax,4)
movups %xmm0,(%rbx,%rax,4)
add    $0x40,%rax
cmp    $0x103c,%rax
jne    12b0 <main+0x140>
xor    %edi,%edi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    $0x1000,%ecx
call   1090 <read_ints@plt>
xor    %edi,%edi
cmpl   $0x1000,0x3ffc(%r14)
sete   %dil
call   1040 <assert@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
mov    $0x1,%edi
call   1080 <exit@plt>
mov    $0x2,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@PROT_READ = global i32 0
@PROT_WRITE = global i32 0
@MAP_SHARED = global i32 0
@MAP_ANONYMOUS = global i32 0
@MAP_FAILED = global i32* null
@PROT_NONE = global i32 0
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%11 = load i32, i32* @PROT_READ
%12 = load i32, i32* @PROT_WRITE
%13 = or i32 %11, %12
%14 = load i32, i32* @MAP_SHARED
%15 = load i32, i32* @MAP_ANONYMOUS
%16 = or i32 %14, %15
%17 = call i32* @mmap(i32* null, i32 8192, i32 %13, i32 %16, i32 -1, i32 0)
store i32* %17, i32** %6
%18 = load i32*, i32** %6
%19 = load i32*, i32** @MAP_FAILED
%20 = icmp eq i32* %18, %19
br i1 %20, label %21, label %23
21: ; preds = %2
%22 = call i32 @exit(i32 1)
unreachable
23: ; preds = %2
%24 = load i32*, i32** %6
%25 = getelementptr inbounds i32, i32* %24, i64 4096
%26 = load i32, i32* @PROT_NONE
%27 = call i32 @mprotect(i32* %25, i32 4096, i32 %26)
store i32 %27, i32* %7
%28 = load i32, i32* %7
%29 = icmp ne i32 %28, 0
br i1 %29, label %30, label %32
30: ; preds = %23
%31 = call i32 @exit(i32 2)
unreachable
32: ; preds = %23
%33 = call i32* @malloc(i32 16384)
store i32* %33, i32** %8
%34 = load i32*, i32** %6
%35 = getelementptr inbounds i32, i32* %34, i64 0
store i32 129, i32* %35
%36 = load i32*, i32** %6
%37 = getelementptr inbounds i32, i32* %36, i64 1
store i32 128, i32* %37
%38 = load i32*, i32** %6
%39 = getelementptr inbounds i32, i32* %38, i64 2
store i32 128, i32* %39
%40 = load i32*, i32** %6
%41 = getelementptr inbounds i32, i32* %40, i64 3
store i32 0, i32* %41
%42 = load i32*, i32** %6
%43 = getelementptr inbounds i32, i32* %42, i64 4
store i32 129, i32* %43
%44 = load i32*, i32** %6
%45 = getelementptr inbounds i32, i32* %44, i64 5
store i32 128, i32* %45
%46 = load i32*, i32** %6
%47 = getelementptr inbounds i32, i32* %46, i64 6
store i32 128, i32* %47
%48 = load i32*, i32** %6
%49 = getelementptr inbounds i32, i32* %48, i64 7
store i32 0, i32* %49
%50 = load i32*, i32** %6
%51 = getelementptr inbounds i32, i32* %50, i64 8
store i32 129, i32* %51
%52 = load i32*, i32** %6
%53 = getelementptr inbounds i32, i32* %52, i64 9
store i32 128, i32* %53
%54 = load i32*, i32** %6
%55 = getelementptr inbounds i32, i32* %54, i64 10
store i32 128, i32* %55
%56 = load i32*, i32** %6
%57 = getelementptr inbounds i32, i32* %56, i64 11
store i32 0, i32* %57
store i32 12, i32* %9
br label %58
58: ; preds = %66, %32
%59 = load i32, i32* %9
%60 = icmp slt i32 %59, 4096
br i1 %60, label %61, label %69
61: ; preds = %58
%62 = load i32*, i32** %6
%63 = load i32, i32* %9
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %62, i64 %64
store i32 1, i32* %65
br label %66
66: ; preds = %61
%67 = load i32, i32* %9
%68 = add nsw i32 %67, 1
store i32 %68, i32* %9
br label %58
69: ; preds = %58
%70 = call i32 (...) @init()
%71 = load i32*, i32** %6
%72 = load i32*, i32** %8
%73 = call i32 @read_ints(i32 0, i32* %71, i32* %72, i32 4087)
%74 = load i32*, i32** %8
%75 = getelementptr inbounds i32, i32* %74, i64 4086
%76 = load i32, i32* %75
%77 = icmp eq i32 4087, %76
%78 = zext i1 %77 to i32
%79 = call i32 @assert(i32 %78)
store i32 0, i32* %10
br label %80
80: ; preds = %88, %69
%81 = load i32, i32* %10
%82 = icmp slt i32 %81, 4096
br i1 %82, label %83, label %91
83: ; preds = %80
%84 = load i32*, i32** %6
%85 = load i32, i32* %10
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %84, i64 %86
store i32 1, i32* %87
br label %88
88: ; preds = %83
%89 = load i32, i32* %10
%90 = add nsw i32 %89, 1
store i32 %90, i32* %10
br label %80
91: ; preds = %80
%92 = load i32*, i32** %6
%93 = load i32*, i32** %8
%94 = call i32 @read_ints(i32 0, i32* %92, i32* %93, i32 4096)
%95 = load i32*, i32** %8
%96 = getelementptr inbounds i32, i32* %95, i64 4095
%97 = load i32, i32* %96
%98 = icmp eq i32 4096, %97
%99 = zext i1 %98 to i32
%100 = call i32 @assert(i32 %99)
ret i32 0
}

LLVM IR (-O2):
@PROT_READ = global i32 0
@PROT_WRITE = global i32 0
@MAP_SHARED = global i32 0
@MAP_ANONYMOUS = global i32 0
@MAP_FAILED = global i32* null
@PROT_NONE = global i32 0
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = load i32, i32* @PROT_READ
%4 = load i32, i32* @PROT_WRITE
%5 = or i32 %4, %3
%6 = load i32, i32* @MAP_SHARED
%7 = load i32, i32* @MAP_ANONYMOUS
%8 = or i32 %7, %6
%9 = tail call i32* @mmap(i32* null, i32 8192, i32 %5, i32 %8, i32 -1, i32 0)
%10 = load i32*, i32** @MAP_FAILED
%11 = icmp eq i32* %9, %10
br i1 %11, label %12, label %14
12: ; preds = %2
%13 = tail call i32 @exit(i32 1)
unreachable
14: ; preds = %2
%15 = getelementptr inbounds i32, i32* %9, i64 4096
%16 = load i32, i32* @PROT_NONE
%17 = tail call i32 @mprotect(i32* %15, i32 4096, i32 %16)
%18 = icmp eq i32 %17, 0
br i1 %18, label %21, label %19
19: ; preds = %14
%20 = tail call i32 @exit(i32 2)
unreachable
21: ; preds = %14
%22 = tail call i32* @malloc(i32 16384)
%23 = bitcast i32* %9 to <4 x i32>*
store <4 x i32> <i32 129, i32 128, i32 128, i32 0>, <4 x i32>* %23
%24 = getelementptr inbounds i32, i32* %9, i64 4
%25 = bitcast i32* %24 to <4 x i32>*
store <4 x i32> <i32 129, i32 128, i32 128, i32 0>, <4 x i32>* %25
%26 = getelementptr inbounds i32, i32* %9, i64 8
%27 = bitcast i32* %26 to <4 x i32>*
store <4 x i32> <i32 129, i32 128, i32 128, i32 0>, <4 x i32>* %27
br label %28
28: ; preds = %28, %21
%29 = phi i64 [ 0, %21 ], [ %60, %28 ]
%30 = or i64 %29, 12
%31 = getelementptr inbounds i32, i32* %9, i64 %30
%32 = bitcast i32* %31 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %32
%33 = getelementptr inbounds i32, i32* %31, i64 4
%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 = add nuw nsw i64 %29, 20
%36 = getelementptr inbounds i32, i32* %9, i64 %35
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %37
%38 = getelementptr inbounds i32, i32* %36, i64 4
%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 = add nuw nsw i64 %29, 28
%41 = getelementptr inbounds i32, i32* %9, i64 %40
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %44
%45 = add nuw nsw i64 %29, 36
%46 = getelementptr inbounds i32, i32* %9, i64 %45
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %47
%48 = getelementptr inbounds i32, i32* %46, i64 4
%49 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %49
%50 = add nuw nsw i64 %29, 44
%51 = getelementptr inbounds i32, i32* %9, i64 %50
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %52
%53 = getelementptr inbounds i32, i32* %51, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %54
%55 = add nuw nsw i64 %29, 52
%56 = getelementptr inbounds i32, i32* %9, i64 %55
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %57
%58 = getelementptr inbounds i32, i32* %56, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %59
%60 = add nuw nsw i64 %29, 48
%61 = icmp eq i64 %60, 4080
br i1 %61, label %105, label %28
62: ; preds = %62, %105
%63 = phi i64 [ 0, %105 ], [ %103, %62 ]
%64 = getelementptr inbounds i32, i32* %9, i64 %63
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %65
%66 = getelementptr inbounds i32, i32* %64, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %67
%68 = or i64 %63, 8
%69 = getelementptr inbounds i32, i32* %9, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %72
%73 = or i64 %63, 16
%74 = getelementptr inbounds i32, i32* %9, i64 %73
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %75
%76 = getelementptr inbounds i32, i32* %74, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %77
%78 = or i64 %63, 24
%79 = getelementptr inbounds i32, i32* %9, i64 %78
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %80
%81 = getelementptr inbounds i32, i32* %79, i64 4
%82 = bitcast i32* %81 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %82
%83 = or i64 %63, 32
%84 = getelementptr inbounds i32, i32* %9, i64 %83
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %85
%86 = getelementptr inbounds i32, i32* %84, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %87
%88 = or i64 %63, 40
%89 = getelementptr inbounds i32, i32* %9, i64 %88
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %92
%93 = or i64 %63, 48
%94 = getelementptr inbounds i32, i32* %9, i64 %93
%95 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %95
%96 = getelementptr inbounds i32, i32* %94, i64 4
%97 = bitcast i32* %96 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %97
%98 = or i64 %63, 56
%99 = getelementptr inbounds i32, i32* %9, i64 %98
%100 = bitcast i32* %99 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %100
%101 = getelementptr inbounds i32, i32* %99, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %102
%103 = add nuw nsw i64 %63, 64
%104 = icmp eq i64 %103, 4096
br i1 %104, label %117, label %62
105: ; preds = %28
%106 = getelementptr inbounds i32, i32* %9, i64 4092
store i32 1, i32* %106
%107 = getelementptr inbounds i32, i32* %9, i64 4093
store i32 1, i32* %107
%108 = getelementptr inbounds i32, i32* %9, i64 4094
store i32 1, i32* %108
%109 = getelementptr inbounds i32, i32* %9, i64 4095
store i32 1, i32* %109
%110 = tail call i32 (...) @init()
%111 = tail call i32 @read_ints(i32 0, i32* %9, i32* %22, i32 4087)
%112 = getelementptr inbounds i32, i32* %22, i64 4086
%113 = load i32, i32* %112
%114 = icmp eq i32 %113, 4087
%115 = zext i1 %114 to i32
%116 = tail call i32 @assert(i32 %115)
br label %62
117: ; preds = %62
%118 = tail call i32 @read_ints(i32 0, i32* %9, i32* %22, i32 4096)
%119 = getelementptr inbounds i32, i32* %22, i64 4095
%120 = load i32, i32* %119
%121 = icmp eq i32 %120, 4096
%122 = zext i1 %121 to i32
%123 = tail call i32 @assert(i32 %122)
ret i32 0
}