#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*/ printf(char *);
void next_generation(int *current, int *next, int lenght) {
  int index, limit_times, printing, check, swap, is_checked = 0;
  for (limit_times = 0; limit_times < 1000; limit_times++) {
    for (index = 0; index < lenght; index++) {
      if ((current[index] == 1 || current[index] == 0) &&
          ((current[index - 1] == 0 && current[index + 1] == 1) ||
           (current[index - 1] == 1 && current[index + 1] == 0))) {
        next[index] = 1;
      } else {
        next[index] = 0;
      }
    }
    for (printing = 0; printing < lenght; printing++) {
      if (current[printing] == 1)
        printf("*");
      else if (current[printing] == 0)
        printf(".");
    }
    is_checked = 0;
    for (check = 0; check < lenght && is_checked != 1; check++) {
      if (current[check] == 1)
        is_checked = 1;
    }
    if (is_checked == 0)
      break;
    for (swap = 0; swap < lenght; swap++) {
      current[swap] = next[swap];
    }
    printf("\n");
  }
}


x86 assembly (clang, -O0):
<next_generation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3e8,-0x1c(%rbp)
jge    1338 <next_generation+0x228>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1207 <next_generation+0xf7>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     1175 <next_generation+0x65>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11e5 <next_generation+0xd5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11a3 <next_generation+0x93>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     11d1 <next_generation+0xc1>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    11e5 <next_generation+0xd5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11e5 <next_generation+0xd5>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    11f4 <next_generation+0xe4>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    11f9 <next_generation+0xe9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1145 <next_generation+0x35>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1273 <next_generation+0x163>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    123d <next_generation+0x12d>
lea    0xdcd(%rip),%rdi
call   1030 <printf@plt>
jmp    1260 <next_generation+0x150>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    125b <next_generation+0x14b>
lea    0xdac(%rip),%rdi
call   1030 <printf@plt>
jmp    1260 <next_generation+0x150>
jmp    1265 <next_generation+0x155>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    120e <next_generation+0xfe>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jge    129c <next_generation+0x18c>
cmpl   $0x1,-0x2c(%rbp)
setne  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    12ac <next_generation+0x19c>
jmp    12d8 <next_generation+0x1c8>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    12c5 <next_generation+0x1b5>
movl   $0x1,-0x2c(%rbp)
jmp    12ca <next_generation+0x1ba>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1281 <next_generation+0x171>
cmpl   $0x0,-0x2c(%rbp)
jne    12e7 <next_generation+0x1d7>
jmp    1338 <next_generation+0x228>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    131e <next_generation+0x20e>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12ee <next_generation+0x1de>
lea    0xcdf(%rip),%rdi
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1131 <next_generation+0x21>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<next_generation>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rsi,%rbx
mov    %rdi,%rbp
movslq %edx,%r15
mov    %r15d,%r12d
lea    (%rsi,%r12,4),%rax
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x38(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x30(%rsp)
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%r12,4),%rcx
cmp    %rbx,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0x3(%rsp)
mov    %esi,%eax
and    $0x3,%eax
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x10(%rsp)
mov    %r12d,%r13d
and    $0x3,%r13d
lea    0x10(%rdi),%rcx
mov    %rcx,0x20(%rsp)
lea    0x10(%rbx),%rcx
mov    %rcx,0x18(%rsp)
mov    %rax,0x28(%rsp)
mov    %rax,%rsi
shl    $0x5,%rsi
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    %rsi,%r14
mov    %r13,0x40(%rsp)
mov    %edx,0x4(%rsp)
jmp    11d8 <next_generation+0xc8>
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r13d,%edx
mov    %r14,%rsi
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
cmp    $0x3e8,%eax
je     13fd <next_generation+0x2ed>
test   %edx,%edx
jle    13fd <next_generation+0x2ed>
xor    %eax,%eax
jmp    11fe <next_generation+0xee>
cmpl   $0x0,0x4(%rbp,%rax,4)
je     1220 <next_generation+0x110>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %ecx,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r12
je     1230 <next_generation+0x120>
cmpl   $0x1,0x0(%rbp,%rax,4)
ja     11f0 <next_generation+0xe0>
mov    -0x4(%rbp,%rax,4),%ecx
cmp    $0x1,%ecx
je     11e4 <next_generation+0xd4>
test   %ecx,%ecx
jne    11f0 <next_generation+0xe0>
mov    $0x1,%ecx
cmpl   $0x1,0x4(%rbp,%rax,4)
jne    11f0 <next_generation+0xe0>
jmp    11f2 <next_generation+0xe2>
mov    $0x1,%ecx
jmp    11f2 <next_generation+0xe2>
nopw   0x0(%rax,%rax,1)
test   %edx,%edx
jle    13fd <next_generation+0x2ed>
xor    %r13d,%r13d
jmp    1256 <next_generation+0x146>
nopl   (%rax)
mov    $0x2a,%edi
call   1030 <putchar@plt>
mov    %r14,%rsi
add    $0x1,%r13
cmp    %r13,%r12
je     1270 <next_generation+0x160>
mov    0x0(%rbp,%r13,4),%eax
cmp    $0x1,%eax
je     1240 <next_generation+0x130>
test   %eax,%eax
jne    124d <next_generation+0x13d>
mov    $0x2e,%edi
jmp    1245 <next_generation+0x135>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsp),%r13d
test   %r13d,%r13d
mov    0x40(%rsp),%rdi
jle    13fd <next_generation+0x2ed>
mov    $0x1,%eax
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rbp,%rax,4),%ecx
cmp    $0x1,%ecx
je     12a5 <next_generation+0x195>
lea    0x1(%rax),%rdx
cmp    %r15,%rax
mov    %rdx,%rax
jl     1290 <next_generation+0x180>
cmp    $0x1,%ecx
jne    13fd <next_generation+0x2ed>
test   %r13d,%r13d
jle    11b0 <next_generation+0xa0>
cmp    $0x8,%r13d
setb   %al
or     0x3(%rsp),%al
je     12d0 <next_generation+0x1c0>
xor    %eax,%eax
jmp    139c <next_generation+0x28c>
nopl   0x0(%rax,%rax,1)
cmpq   $0x18,0x30(%rsp)
jae    12dc <next_generation+0x1cc>
xor    %eax,%eax
jmp    1349 <next_generation+0x239>
mov    0x10(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups %xmm0,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
movups 0x20(%rbx,%rax,4),%xmm0
movups 0x30(%rbx,%rax,4),%xmm1
movups %xmm0,0x20(%rbp,%rax,4)
movups %xmm1,0x30(%rbp,%rax,4)
movups 0x40(%rbx,%rax,4),%xmm0
movups 0x50(%rbx,%rax,4),%xmm1
movups %xmm0,0x40(%rbp,%rax,4)
movups %xmm1,0x50(%rbp,%rax,4)
movups 0x60(%rbx,%rax,4),%xmm0
movups 0x70(%rbx,%rax,4),%xmm1
movups %xmm0,0x60(%rbp,%rax,4)
movups %xmm1,0x70(%rbp,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    12f0 <next_generation+0x1e0>
cmpq   $0x0,0x28(%rsp)
je     138b <next_generation+0x27b>
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1370 <next_generation+0x260>
mov    0x38(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     11b0 <next_generation+0xa0>
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %rdi,%rdi
je     13c1 <next_generation+0x2b1>
mov    %rdi,%rdx
nopl   (%rax)
mov    (%rbx,%rax,4),%esi
mov    %esi,0x0(%rbp,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    13b0 <next_generation+0x2a0>
cmp    $0x3,%rcx
jb     11b0 <next_generation+0xa0>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%ecx
mov    %ecx,0x0(%rbp,%rax,4)
mov    0x4(%rbx,%rax,4),%ecx
mov    %ecx,0x4(%rbp,%rax,4)
mov    0x8(%rbx,%rax,4),%ecx
mov    %ecx,0x8(%rbp,%rax,4)
mov    0xc(%rbx,%rax,4),%ecx
mov    %ecx,0xc(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r12
jne    13d0 <next_generation+0x2c0>
jmp    11b0 <next_generation+0xa0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] c"*\00"
@.str.1 = [2 x i8] c".\00"
@.str.2 = [2 x i8] c"\0A\00"
define void @next_generation(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
store i32 0, i32* %12
store i32 0, i32* %8
br label %13
13: ; preds = %155, %3
%14 = load i32, i32* %8
%15 = icmp slt i32 %14, 1000
br i1 %15, label %16, label %158
16: ; preds = %13
store i32 0, i32* %7
br label %17
17: ; preds = %78, %16
%18 = load i32, i32* %7
%19 = load i32, i32* %6
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %81
21: ; preds = %17
%22 = load i32*, i32** %4
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i32, i32* %22, i64 %24
%26 = load i32, i32* %25
%27 = icmp eq i32 %26, 1
br i1 %27, label %35, label %28
28: ; preds = %21
%29 = load i32*, i32** %4
%30 = load i32, i32* %7
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
%33 = load i32, i32* %32
%34 = icmp eq i32 %33, 0
br i1 %34, label %35, label %72
35: ; preds = %28, %21
%36 = load i32*, i32** %4
%37 = load i32, i32* %7
%38 = sub nsw i32 %37, 1
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %36, i64 %39
%41 = load i32, i32* %40
%42 = icmp eq i32 %41, 0
br i1 %42, label %43, label %51
43: ; preds = %35
%44 = load i32*, i32** %4
%45 = load i32, i32* %7
%46 = add nsw i32 %45, 1
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %44, i64 %47
%49 = load i32, i32* %48
%50 = icmp eq i32 %49, 1
br i1 %50, label %67, label %51
51: ; preds = %43, %35
%52 = load i32*, i32** %4
%53 = load i32, i32* %7
%54 = sub nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %52, i64 %55
%57 = load i32, i32* %56
%58 = icmp eq i32 %57, 1
br i1 %58, label %59, label %72
59: ; preds = %51
%60 = load i32*, i32** %4
%61 = load i32, i32* %7
%62 = add nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %60, i64 %63
%65 = load i32, i32* %64
%66 = icmp eq i32 %65, 0
br i1 %66, label %67, label %72
67: ; preds = %59, %43
%68 = load i32*, i32** %5
%69 = load i32, i32* %7
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %68, i64 %70
store i32 1, i32* %71
br label %77
72: ; preds = %59, %51, %28
%73 = load i32*, i32** %5
%74 = load i32, i32* %7
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %73, i64 %75
store i32 0, i32* %76
br label %77
77: ; preds = %72, %67
br label %78
78: ; preds = %77
%79 = load i32, i32* %7
%80 = add nsw i32 %79, 1
store i32 %80, i32* %7
br label %17
81: ; preds = %17
store i32 0, i32* %9
br label %82
82: ; preds = %106, %81
%83 = load i32, i32* %9
%84 = load i32, i32* %6
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %109
86: ; preds = %82
%87 = load i32*, i32** %4
%88 = load i32, i32* %9
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %87, i64 %89
%91 = load i32, i32* %90
%92 = icmp eq i32 %91, 1
br i1 %92, label %93, label %95
93: ; preds = %86
%94 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %105
95: ; preds = %86
%96 = load i32*, i32** %4
%97 = load i32, i32* %9
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %96, i64 %98
%100 = load i32, i32* %99
%101 = icmp eq i32 %100, 0
br i1 %101, label %102, label %104
102: ; preds = %95
%103 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %104
104: ; preds = %102, %95
br label %105
105: ; preds = %104, %93
br label %106
106: ; preds = %105
%107 = load i32, i32* %9
%108 = add nsw i32 %107, 1
store i32 %108, i32* %9
br label %82
109: ; preds = %82
store i32 0, i32* %12
store i32 0, i32* %10
br label %110
110: ; preds = %128, %109
%111 = load i32, i32* %10
%112 = load i32, i32* %6
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %117
114: ; preds = %110
%115 = load i32, i32* %12
%116 = icmp ne i32 %115, 1
br label %117
117: ; preds = %114, %110
%118 = phi i1 [ false, %110 ], [ %116, %114 ]
br i1 %118, label %119, label %131
119: ; preds = %117
%120 = load i32*, i32** %4
%121 = load i32, i32* %10
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %120, i64 %122
%124 = load i32, i32* %123
%125 = icmp eq i32 %124, 1
br i1 %125, label %126, label %127
126: ; preds = %119
store i32 1, i32* %12
br label %127
127: ; preds = %126, %119
br label %128
128: ; preds = %127
%129 = load i32, i32* %10
%130 = add nsw i32 %129, 1
store i32 %130, i32* %10
br label %110
131: ; preds = %117
%132 = load i32, i32* %12
%133 = icmp eq i32 %132, 0
br i1 %133, label %134, label %135
134: ; preds = %131
br label %158
135: ; preds = %131
store i32 0, i32* %11
br label %136
136: ; preds = %150, %135
%137 = load i32, i32* %11
%138 = load i32, i32* %6
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %153
140: ; preds = %136
%141 = load i32*, i32** %5
%142 = load i32, i32* %11
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %141, i64 %143
%145 = load i32, i32* %144
%146 = load i32*, i32** %4
%147 = load i32, i32* %11
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
store i32 %145, i32* %149
br label %150
150: ; preds = %140
%151 = load i32, i32* %11
%152 = add nsw i32 %151, 1
store i32 %152, i32* %11
br label %136
153: ; preds = %136
%154 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %155
155: ; preds = %153
%156 = load i32, i32* %8
%157 = add nsw i32 %156, 1
store i32 %157, i32* %8
br label %13
158: ; preds = %134, %13
ret void
}

LLVM IR (-O2):
define void @next_generation(i32* nocapture %0, i32* nocapture %1, i32 %2) {
%4 = icmp sgt i32 %2, 0
%5 = sext i32 %2 to i64
%6 = zext i32 %2 to i64
%7 = zext i32 %2 to i64
%8 = zext i32 %2 to i64
%9 = getelementptr i32, i32* %0, i64 %6
%10 = getelementptr i32, i32* %1, i64 %6
%11 = and i64 %6, 4294967288
%12 = add nsw i64 %11, -8
%13 = lshr exact i64 %12, 3
%14 = add nuw nsw i64 %13, 1
%15 = icmp ult i32 %2, 8
%16 = icmp ugt i32* %10, %0
%17 = icmp ugt i32* %9, %1
%18 = and i1 %16, %17
%19 = and i64 %6, 4294967288
%20 = and i64 %14, 3
%21 = icmp ult i64 %12, 24
%22 = and i64 %14, 4611686018427387900
%23 = icmp eq i64 %20, 0
%24 = icmp eq i64 %19, %6
%25 = and i64 %6, 3
%26 = icmp eq i64 %25, 0
br label %27
27: ; preds = %3, %183
%28 = phi i32 [ 0, %3 ], [ %185, %183 ]
br i1 %4, label %30, label %187
29: ; preds = %50
br i1 %4, label %56, label %187
30: ; preds = %27, %50
%31 = phi i64 [ %53, %50 ], [ 0, %27 ]
%32 = getelementptr inbounds i32, i32* %0, i64 %31
%33 = load i32, i32* %32
%34 = icmp ult i32 %33, 2
br i1 %34, label %35, label %49
35: ; preds = %30
%36 = add nsw i64 %31, -1
%37 = getelementptr inbounds i32, i32* %0, i64 %36
%38 = load i32, i32* %37
switch i32 %38, label %49 [
i32 0, label %39
i32 1, label %44
]
39: ; preds = %35
%40 = add nuw nsw i64 %31, 1
%41 = getelementptr inbounds i32, i32* %0, i64 %40
%42 = load i32, i32* %41
%43 = icmp eq i32 %42, 1
br i1 %43, label %50, label %49
44: ; preds = %35
%45 = add nuw nsw i64 %31, 1
%46 = getelementptr inbounds i32, i32* %0, i64 %45
%47 = load i32, i32* %46
%48 = icmp eq i32 %47, 0
br i1 %48, label %50, label %49
49: ; preds = %35, %39, %30, %44
br label %50
50: ; preds = %39, %44, %49
%51 = phi i32 [ 0, %49 ], [ 1, %44 ], [ 1, %39 ]
%52 = getelementptr inbounds i32, i32* %1, i64 %31
store i32 %51, i32* %52
%53 = add nuw nsw i64 %31, 1
%54 = icmp eq i64 %53, %6
br i1 %54, label %29, label %30
55: ; preds = %64
br i1 %4, label %67, label %187
56: ; preds = %29, %64
%57 = phi i64 [ %65, %64 ], [ 0, %29 ]
%58 = getelementptr inbounds i32, i32* %0, i64 %57
%59 = load i32, i32* %58
switch i32 %59, label %64 [
i32 1, label %61
i32 0, label %60
]
60: ; preds = %56
br label %61
61: ; preds = %56, %60
%62 = phi i32 [ 46, %60 ], [ 42, %56 ]
%63 = tail call i32 @putchar(i32 %62)
br label %64
64: ; preds = %61, %56
%65 = add nuw nsw i64 %57, 1
%66 = icmp eq i64 %65, %7
br i1 %66, label %55, label %56
67: ; preds = %55, %67
%68 = phi i64 [ %72, %67 ], [ 0, %55 ]
%69 = getelementptr inbounds i32, i32* %0, i64 %68
%70 = load i32, i32* %69
%71 = icmp eq i32 %70, 1
%72 = add nuw nsw i64 %68, 1
%73 = icmp sge i64 %72, %5
%74 = or i1 %71, %73
br i1 %74, label %75, label %67
75: ; preds = %67
br i1 %71, label %76, label %187
76: ; preds = %75
br i1 %4, label %77, label %183
77: ; preds = %76
%78 = or i1 %15, %18
br i1 %78, label %148, label %79
79: ; preds = %77
br i1 %21, label %129, label %80
80: ; preds = %79, %80
%81 = phi i64 [ %126, %80 ], [ 0, %79 ]
%82 = phi i64 [ %127, %80 ], [ 0, %79 ]
%83 = getelementptr inbounds i32, i32* %1, i64 %81
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = getelementptr inbounds i32, i32* %83, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
%88 = load <4 x i32>, <4 x i32>* %87
%89 = getelementptr inbounds i32, i32* %0, i64 %81
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> %85, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %88, <4 x i32>* %92
%93 = or i64 %81, 8
%94 = getelementptr inbounds i32, i32* %1, i64 %93
%95 = bitcast i32* %94 to <4 x i32>*
%96 = load <4 x i32>, <4 x i32>* %95
%97 = getelementptr inbounds i32, i32* %94, i64 4
%98 = bitcast i32* %97 to <4 x i32>*
%99 = load <4 x i32>, <4 x i32>* %98
%100 = getelementptr inbounds i32, i32* %0, i64 %93
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> %96, <4 x i32>* %101
%102 = getelementptr inbounds i32, i32* %100, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> %99, <4 x i32>* %103
%104 = or i64 %81, 16
%105 = getelementptr inbounds i32, i32* %1, i64 %104
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = getelementptr inbounds i32, i32* %105, i64 4
%109 = bitcast i32* %108 to <4 x i32>*
%110 = load <4 x i32>, <4 x i32>* %109
%111 = getelementptr inbounds i32, i32* %0, i64 %104
%112 = bitcast i32* %111 to <4 x i32>*
store <4 x i32> %107, <4 x i32>* %112
%113 = getelementptr inbounds i32, i32* %111, i64 4
%114 = bitcast i32* %113 to <4 x i32>*
store <4 x i32> %110, <4 x i32>* %114
%115 = or i64 %81, 24
%116 = getelementptr inbounds i32, i32* %1, i64 %115
%117 = bitcast i32* %116 to <4 x i32>*
%118 = load <4 x i32>, <4 x i32>* %117
%119 = getelementptr inbounds i32, i32* %116, i64 4
%120 = bitcast i32* %119 to <4 x i32>*
%121 = load <4 x i32>, <4 x i32>* %120
%122 = getelementptr inbounds i32, i32* %0, i64 %115
%123 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> %118, <4 x i32>* %123
%124 = getelementptr inbounds i32, i32* %122, i64 4
%125 = bitcast i32* %124 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %125
%126 = add nuw i64 %81, 32
%127 = add i64 %82, 4
%128 = icmp eq i64 %127, %22
br i1 %128, label %129, label %80
129: ; preds = %80, %79
%130 = phi i64 [ 0, %79 ], [ %126, %80 ]
br i1 %23, label %147, label %131
131: ; preds = %129, %131
%132 = phi i64 [ %144, %131 ], [ %130, %129 ]
%133 = phi i64 [ %145, %131 ], [ 0, %129 ]
%134 = getelementptr inbounds i32, i32* %1, i64 %132
%135 = bitcast i32* %134 to <4 x i32>*
%136 = load <4 x i32>, <4 x i32>* %135
%137 = getelementptr inbounds i32, i32* %134, i64 4
%138 = bitcast i32* %137 to <4 x i32>*
%139 = load <4 x i32>, <4 x i32>* %138
%140 = getelementptr inbounds i32, i32* %0, i64 %132
%141 = bitcast i32* %140 to <4 x i32>*
store <4 x i32> %136, <4 x i32>* %141
%142 = getelementptr inbounds i32, i32* %140, i64 4
%143 = bitcast i32* %142 to <4 x i32>*
store <4 x i32> %139, <4 x i32>* %143
%144 = add nuw i64 %132, 8
%145 = add i64 %133, 1
%146 = icmp eq i64 %145, %20
br i1 %146, label %147, label %131
147: ; preds = %131, %129
br i1 %24, label %183, label %148
148: ; preds = %77, %147
%149 = phi i64 [ 0, %77 ], [ %19, %147 ]
%150 = xor i64 %149, -1
%151 = add nsw i64 %150, %6
br i1 %26, label %161, label %152
152: ; preds = %148, %152
%153 = phi i64 [ %158, %152 ], [ %149, %148 ]
%154 = phi i64 [ %159, %152 ], [ 0, %148 ]
%155 = getelementptr inbounds i32, i32* %1, i64 %153
%156 = load i32, i32* %155
%157 = getelementptr inbounds i32, i32* %0, i64 %153
store i32 %156, i32* %157
%158 = add nuw nsw i64 %153, 1
%159 = add i64 %154, 1
%160 = icmp eq i64 %159, %25
br i1 %160, label %161, label %152
161: ; preds = %152, %148
%162 = phi i64 [ %149, %148 ], [ %158, %152 ]
%163 = icmp ult i64 %151, 3
br i1 %163, label %183, label %164
164: ; preds = %161, %164
%165 = phi i64 [ %181, %164 ], [ %162, %161 ]
%166 = getelementptr inbounds i32, i32* %1, i64 %165
%167 = load i32, i32* %166
%168 = getelementptr inbounds i32, i32* %0, i64 %165
store i32 %167, i32* %168
%169 = add nuw nsw i64 %165, 1
%170 = getelementptr inbounds i32, i32* %1, i64 %169
%171 = load i32, i32* %170
%172 = getelementptr inbounds i32, i32* %0, i64 %169
store i32 %171, i32* %172
%173 = add nuw nsw i64 %165, 2
%174 = getelementptr inbounds i32, i32* %1, i64 %173
%175 = load i32, i32* %174
%176 = getelementptr inbounds i32, i32* %0, i64 %173
store i32 %175, i32* %176
%177 = add nuw nsw i64 %165, 3
%178 = getelementptr inbounds i32, i32* %1, i64 %177
%179 = load i32, i32* %178
%180 = getelementptr inbounds i32, i32* %0, i64 %177
store i32 %179, i32* %180
%181 = add nuw nsw i64 %165, 4
%182 = icmp eq i64 %181, %8
br i1 %182, label %183, label %164
183: ; preds = %161, %164, %147, %76
%184 = tail call i32 @putchar(i32 10)
%185 = add nuw nsw i32 %28, 1
%186 = icmp eq i32 %185, 1000
br i1 %186, label %187, label %27
187: ; preds = %27, %29, %55, %75, %183
ret void
}