void next_generation(int *current, int *next, int length) {
  int i;
  next[0] = 0;
  next[length - 1] = 0;
  for (i = 1; i < length - 1; i++) {
    if (!(current[i + 1] && current[i - 1]) &&
        (current[i + 1] || current[i - 1])) {
      next[i] = 1;
    } else {
      next[i] = 0;
    }
  }
  for (i = 0; i < length; i++) {
    current[i] = next[i];
  }
}


x86 assembly (clang, -O0):
<next_generation>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11d7 <next_generation+0xd7>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1173 <next_generation+0x73>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11b5 <next_generation+0xb5>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    11a1 <next_generation+0xa1>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     11b5 <next_generation+0xb5>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    11c4 <next_generation+0xc4>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    11c9 <next_generation+0xc9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1134 <next_generation+0x34>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    120e <next_generation+0x10e>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11de <next_generation+0xde>
pop    %rbp
ret

x86 assembly (clang, -O2):
<next_generation>:
movl   $0x0,(%rsi)
movslq %edx,%rax
movl   $0x0,-0x4(%rsi,%rax,4)
cmp    $0x3,%edx
jl     11f6 <next_generation+0xf6>
lea    -0x1(%rdx),%eax
mov    %eax,%r9d
lea    -0x1(%r9),%r8
mov    $0x1,%r11d
cmp    $0x8,%r8
jb     11b3 <next_generation+0xb3>
lea    0x4(%rsi),%rax
lea    (%rdi,%r9,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
jae    114e <next_generation+0x4e>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
ja     11b3 <next_generation+0xb3>
mov    %r8,%r10
and    $0xfffffffffffffff8,%r10
lea    0x1(%r10),%r11
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
nop
movdqu (%rdi,%rcx,4),%xmm1
movdqu 0x8(%rdi,%rcx,4),%xmm2
movdqu 0x10(%rdi,%rcx,4),%xmm3
movdqu 0x18(%rdi,%rcx,4),%xmm4
pcmpeqd %xmm0,%xmm2
pcmpeqd %xmm0,%xmm4
pcmpeqd %xmm0,%xmm1
pxor   %xmm2,%xmm1
pcmpeqd %xmm0,%xmm3
pxor   %xmm4,%xmm3
psrld  $0x1f,%xmm1
psrld  $0x1f,%xmm3
movdqu %xmm1,0x4(%rsi,%rcx,4)
movdqu %xmm3,0x14(%rsi,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r10
jne    1160 <next_generation+0x60>
cmp    %r10,%r8
je     11f6 <next_generation+0xf6>
mov    %r11,%rcx
not    %rcx
test   $0x1,%r9b
jne    11ed <next_generation+0xed>
cmpl   $0x0,0x4(%rdi,%r11,4)
mov    -0x4(%rdi,%r11,4),%eax
je     11d8 <next_generation+0xd8>
test   %eax,%eax
jne    11e2 <next_generation+0xe2>
mov    $0x1,%r8d
jmp    11e5 <next_generation+0xe5>
mov    $0x1,%r8d
test   %eax,%eax
jne    11e5 <next_generation+0xe5>
xor    %r8d,%r8d
mov    %r8d,(%rsi,%r11,4)
add    $0x1,%r11
add    %r9,%rcx
jne    12a1 <next_generation+0x1a1>
test   %edx,%edx
jle    13da <next_generation+0x2da>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     1220 <next_generation+0x120>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    12fc <next_generation+0x1fc>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    12fc <next_generation+0x1fc>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rdx
and    $0x3,%rdx
je     1250 <next_generation+0x150>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%rcx,4),%eax
mov    %eax,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1240 <next_generation+0x140>
cmp    $0x3,%r8
jb     13da <next_generation+0x2da>
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,4),%eax
mov    %eax,(%rdi,%rcx,4)
mov    0x4(%rsi,%rcx,4),%eax
mov    %eax,0x4(%rdi,%rcx,4)
mov    0x8(%rsi,%rcx,4),%eax
mov    %eax,0x8(%rdi,%rcx,4)
mov    0xc(%rsi,%rcx,4),%eax
mov    %eax,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1260 <next_generation+0x160>
jmp    13da <next_generation+0x2da>
nopl   0x0(%rax)
xor    %r8d,%r8d
mov    %r8d,0x4(%rsi,%rcx,4)
cmp    %r11,%r9
je     11f6 <next_generation+0xf6>
mov    %r11,%rcx
cmpl   $0x0,0x4(%rdi,%r11,4)
mov    -0x4(%rdi,%r11,4),%eax
je     12c0 <next_generation+0x1c0>
test   %eax,%eax
jne    12ca <next_generation+0x1ca>
mov    $0x1,%r8d
jmp    12cd <next_generation+0x1cd>
nopl   (%rax)
mov    $0x1,%r8d
test   %eax,%eax
jne    12cd <next_generation+0x1cd>
xor    %r8d,%r8d
mov    %r8d,(%rsi,%rcx,4)
lea    0x2(%rcx),%r11
cmpl   $0x0,0x8(%rdi,%rcx,4)
mov    (%rdi,%rcx,4),%eax
je     12f0 <next_generation+0x1f0>
test   %eax,%eax
jne    1290 <next_generation+0x190>
mov    $0x1,%r8d
jmp    1293 <next_generation+0x193>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r8d
test   %eax,%eax
jne    1293 <next_generation+0x193>
jmp    1290 <next_generation+0x190>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rax
jae    1322 <next_generation+0x222>
xor    %eax,%eax
jmp    138c <next_generation+0x28c>
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,(%rdi,%rax,4)
movups %xmm1,0x10(%rdi,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,0x20(%rdi,%rax,4)
movups %xmm1,0x30(%rdi,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,0x40(%rdi,%rax,4)
movups %xmm1,0x50(%rdi,%rax,4)
movdqu 0x60(%rsi,%rax,4),%xmm0
movdqu 0x70(%rsi,%rax,4),%xmm1
movdqu %xmm0,0x60(%rdi,%rax,4)
movdqu %xmm1,0x70(%rdi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdx
jne    1330 <next_generation+0x230>
test   %r8,%r8
je     13d1 <next_generation+0x2d1>
lea    (%rdi,%rax,4),%r10
add    $0x10,%r10
lea    (%rsi,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rax,%rdx,1),%xmm0
movdqu (%rax,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%r10,%rdx,1)
movdqu %xmm1,(%r10,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    13b0 <next_generation+0x2b0>
cmp    %r9,%rcx
jne    1222 <next_generation+0x122>
ret

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

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