int CalculateLiveNeighbours(unsigned char *grid, unsigned int dim_x,
                            unsigned int dim_y, unsigned int x,
                            unsigned int y) {
  unsigned char(*c_grid)[dim_x] = (unsigned char(*)[dim_x])grid;
  int live_neighbors = 0;
  live_neighbors += ((y + 1) < dim_y) ? c_grid[y + 1][x] : 0;
  live_neighbors +=
      ((x + 1) < dim_x && (y + 1) < dim_y) ? c_grid[y + 1][x + 1] : 0;
  live_neighbors += ((x + 1) < dim_x) ? c_grid[y][x + 1] : 0;
  live_neighbors += ((x + 1) < dim_x && y != 0) ? c_grid[y - 1][x + 1] : 0;
  live_neighbors += (y != 0) ? c_grid[y - 1][x] : 0;
  live_neighbors += (x != 0 && y != 0) ? c_grid[y - 1][x - 1] : 0;
  live_neighbors += (x != 0) ? c_grid[y][x - 1] : 0;
  live_neighbors += (x != 0 && y + 1 < dim_y) ? c_grid[y + 1][x - 1] : 0;
  return live_neighbors;
}


x86 assembly (clang, -O0):
<CalculateLiveNeighbours>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cmp    -0x10(%rbp),%eax
jae    1160 <CalculateLiveNeighbours+0x60>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
jmp    116a <CalculateLiveNeighbours+0x6a>
xor    %eax,%eax
mov    %eax,-0x34(%rbp)
jmp    116a <CalculateLiveNeighbours+0x6a>
mov    -0x34(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0xc(%rbp),%eax
jae    11bc <CalculateLiveNeighbours+0xbc>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cmp    -0x10(%rbp),%eax
jae    11bc <CalculateLiveNeighbours+0xbc>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
jmp    11c6 <CalculateLiveNeighbours+0xc6>
xor    %eax,%eax
mov    %eax,-0x38(%rbp)
jmp    11c6 <CalculateLiveNeighbours+0xc6>
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0xc(%rbp),%eax
jae    1204 <CalculateLiveNeighbours+0x104>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
jmp    120e <CalculateLiveNeighbours+0x10e>
xor    %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    120e <CalculateLiveNeighbours+0x10e>
mov    -0x3c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cmp    -0xc(%rbp),%eax
jae    125b <CalculateLiveNeighbours+0x15b>
cmpl   $0x0,-0x18(%rbp)
je     125b <CalculateLiveNeighbours+0x15b>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
jmp    1265 <CalculateLiveNeighbours+0x165>
xor    %eax,%eax
mov    %eax,-0x40(%rbp)
jmp    1265 <CalculateLiveNeighbours+0x165>
mov    -0x40(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     129e <CalculateLiveNeighbours+0x19e>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x44(%rbp)
jmp    12a8 <CalculateLiveNeighbours+0x1a8>
xor    %eax,%eax
mov    %eax,-0x44(%rbp)
jmp    12a8 <CalculateLiveNeighbours+0x1a8>
mov    -0x44(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     12f0 <CalculateLiveNeighbours+0x1f0>
cmpl   $0x0,-0x18(%rbp)
je     12f0 <CalculateLiveNeighbours+0x1f0>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
jmp    12fa <CalculateLiveNeighbours+0x1fa>
xor    %eax,%eax
mov    %eax,-0x48(%rbp)
jmp    12fa <CalculateLiveNeighbours+0x1fa>
mov    -0x48(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     1333 <CalculateLiveNeighbours+0x233>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
jmp    133d <CalculateLiveNeighbours+0x23d>
xor    %eax,%eax
mov    %eax,-0x4c(%rbp)
jmp    133d <CalculateLiveNeighbours+0x23d>
mov    -0x4c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     138a <CalculateLiveNeighbours+0x28a>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cmp    -0x10(%rbp),%eax
jae    138a <CalculateLiveNeighbours+0x28a>
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
imul   %rdx,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
jmp    1394 <CalculateLiveNeighbours+0x294>
xor    %eax,%eax
mov    %eax,-0x50(%rbp)
jmp    1394 <CalculateLiveNeighbours+0x294>
mov    -0x50(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<CalculateLiveNeighbours>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%r11d
lea    0x1(%r8),%eax
mov    %ecx,%r13d
cmp    %edx,%eax
jae    1138 <CalculateLiveNeighbours+0x38>
mov    %eax,%ebp
imul   %r11,%rbp
add    %rdi,%rbp
movzbl 0x0(%r13,%rbp,1),%r9d
lea    0x1(%rcx),%ebx
cmp    %esi,%ebx
jae    1177 <CalculateLiveNeighbours+0x77>
mov    %ebx,%esi
movzbl 0x0(%rbp,%rsi,1),%r10d
jmp    1148 <CalculateLiveNeighbours+0x48>
lea    0x1(%rcx),%ebx
xor    %r9d,%r9d
mov    $0x0,%r10d
cmp    %esi,%ebx
jae    1177 <CalculateLiveNeighbours+0x77>
cmp    %edx,%eax
setae  %r15b
mov    %r8d,%edx
imul   %r11,%rdx
add    %rdi,%rdx
mov    %ebx,%esi
movzbl (%rsi,%rdx,1),%r14d
test   %r8d,%r8d
je     11c9 <CalculateLiveNeighbours+0xc9>
lea    -0x1(%r8),%edx
imul   %r11,%rdx
lea    (%rdi,%rdx,1),%rbx
movzbl (%rsi,%rbx,1),%r12d
jmp    1193 <CalculateLiveNeighbours+0x93>
cmp    %edx,%eax
setae  %r15b
test   %r8d,%r8d
je     11c3 <CalculateLiveNeighbours+0xc3>
lea    -0x1(%r8),%edx
imul   %r11,%rdx
xor    %r12d,%r12d
xor    %r10d,%r10d
xor    %r14d,%r14d
add    %rdi,%rdx
movzbl 0x0(%r13,%rdx,1),%ebp
xor    %esi,%esi
test   %ecx,%ecx
je     11bd <CalculateLiveNeighbours+0xbd>
add    $0xffffffff,%ecx
movzbl (%rdx,%rcx,1),%ebx
mov    %r8d,%edx
imul   %r11,%rdx
add    %rdi,%rdx
mov    (%rcx,%rdx,1),%dl
test   %r15b,%r15b
je     11f4 <CalculateLiveNeighbours+0xf4>
jmp    120e <CalculateLiveNeighbours+0x10e>
xor    %edx,%edx
xor    %ebx,%ebx
jmp    120e <CalculateLiveNeighbours+0x10e>
xor    %r10d,%r10d
xor    %r14d,%r14d
test   %ecx,%ecx
je     1203 <CalculateLiveNeighbours+0x103>
mov    %r8d,%edx
imul   %r11,%rdx
add    %rdi,%rdx
add    $0xffffffff,%ecx
mov    (%rcx,%rdx,1),%dl
xor    %ebp,%ebp
mov    $0x0,%r12d
mov    $0x0,%ebx
mov    $0x0,%esi
test   %r15b,%r15b
jne    120e <CalculateLiveNeighbours+0x10e>
mov    %eax,%eax
imul   %r11,%rax
add    %rax,%rdi
movzbl (%rcx,%rdi,1),%esi
jmp    120e <CalculateLiveNeighbours+0x10e>
xor    %edx,%edx
xor    %ebp,%ebp
xor    %r12d,%r12d
xor    %ebx,%ebx
xor    %esi,%esi
movzbl %dl,%eax
add    %ebp,%eax
add    %r14d,%eax
add    %r9d,%eax
add    %r10d,%eax
add    %r12d,%eax
add    %ebx,%eax
add    %esi,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @CalculateLiveNeighbours(i8* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = zext i32 %1 to i64
%7 = add i32 %4, 1
%8 = icmp ult i32 %7, %2
br i1 %8, label %12, label %9
9: ; preds = %5
%10 = add i32 %3, 1
%11 = icmp ult i32 %10, %1
br i1 %11, label %35, label %27
12: ; preds = %5
%13 = zext i32 %7 to i64
%14 = mul nuw nsw i64 %13, %6
%15 = getelementptr inbounds i8, i8* %0, i64 %14
%16 = zext i32 %3 to i64
%17 = getelementptr inbounds i8, i8* %15, i64 %16
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
%20 = add i32 %3, 1
%21 = icmp ult i32 %20, %1
br i1 %21, label %22, label %27
22: ; preds = %12
%23 = zext i32 %20 to i64
%24 = getelementptr inbounds i8, i8* %15, i64 %23
%25 = load i8, i8* %24
%26 = zext i8 %25 to i32
br label %35
27: ; preds = %12, %9
%28 = phi i32 [ 0, %9 ], [ %19, %12 ]
%29 = xor i1 %8, true
%30 = icmp eq i32 %4, 0
br i1 %30, label %56, label %31
31: ; preds = %27
%32 = add i32 %4, -1
%33 = zext i32 %32 to i64
%34 = mul nuw nsw i64 %33, %6
br label %62
35: ; preds = %22, %9
%36 = phi i32 [ %26, %22 ], [ 0, %9 ]
%37 = phi i32 [ %19, %22 ], [ 0, %9 ]
%38 = phi i32 [ %20, %22 ], [ %10, %9 ]
%39 = xor i1 %8, true
%40 = zext i32 %4 to i64
%41 = mul nuw nsw i64 %40, %6
%42 = getelementptr inbounds i8, i8* %0, i64 %41
%43 = zext i32 %38 to i64
%44 = getelementptr inbounds i8, i8* %42, i64 %43
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = icmp eq i32 %4, 0
br i1 %47, label %56, label %48
48: ; preds = %35
%49 = add i32 %4, -1
%50 = zext i32 %49 to i64
%51 = mul nuw nsw i64 %50, %6
%52 = getelementptr inbounds i8, i8* %0, i64 %51
%53 = getelementptr inbounds i8, i8* %52, i64 %43
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
br label %62
56: ; preds = %35, %27
%57 = phi i32 [ 0, %27 ], [ %36, %35 ]
%58 = phi i32 [ %28, %27 ], [ %37, %35 ]
%59 = phi i1 [ %29, %27 ], [ %39, %35 ]
%60 = phi i32 [ 0, %27 ], [ %46, %35 ]
%61 = icmp eq i32 %3, 0
br i1 %61, label %111, label %88
62: ; preds = %31, %48
%63 = phi i64 [ %34, %31 ], [ %51, %48 ]
%64 = phi i32 [ 0, %31 ], [ %55, %48 ]
%65 = phi i32 [ 0, %31 ], [ %36, %48 ]
%66 = phi i32 [ %28, %31 ], [ %37, %48 ]
%67 = phi i1 [ %29, %31 ], [ %39, %48 ]
%68 = phi i32 [ 0, %31 ], [ %46, %48 ]
%69 = getelementptr inbounds i8, i8* %0, i64 %63
%70 = zext i32 %3 to i64
%71 = getelementptr inbounds i8, i8* %69, i64 %70
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = icmp eq i32 %3, 0
br i1 %74, label %111, label %75
75: ; preds = %62
%76 = add i32 %3, -1
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %69, i64 %77
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = zext i32 %4 to i64
%82 = mul nuw nsw i64 %81, %6
%83 = getelementptr inbounds i8, i8* %0, i64 %82
%84 = add i32 %3, -1
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
%87 = load i8, i8* %86
br i1 %67, label %111, label %96
88: ; preds = %56
%89 = zext i32 %4 to i64
%90 = mul nuw nsw i64 %89, %6
%91 = getelementptr inbounds i8, i8* %0, i64 %90
%92 = add i32 %3, -1
%93 = zext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = load i8, i8* %94
br i1 %59, label %111, label %96
96: ; preds = %75, %88
%97 = phi i8 [ %87, %75 ], [ %95, %88 ]
%98 = phi i64 [ %85, %75 ], [ %93, %88 ]
%99 = phi i32 [ %73, %75 ], [ 0, %88 ]
%100 = phi i32 [ %68, %75 ], [ %60, %88 ]
%101 = phi i32 [ %66, %75 ], [ %58, %88 ]
%102 = phi i32 [ %65, %75 ], [ %57, %88 ]
%103 = phi i32 [ %64, %75 ], [ 0, %88 ]
%104 = phi i32 [ %80, %75 ], [ 0, %88 ]
%105 = zext i32 %7 to i64
%106 = mul nuw nsw i64 %105, %6
%107 = getelementptr inbounds i8, i8* %0, i64 %106
%108 = getelementptr inbounds i8, i8* %107, i64 %98
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
br label %111
111: ; preds = %75, %62, %56, %88, %96
%112 = phi i8 [ %97, %96 ], [ %95, %88 ], [ 0, %56 ], [ 0, %62 ], [ %87, %75 ]
%113 = phi i32 [ %99, %96 ], [ 0, %88 ], [ 0, %56 ], [ %73, %62 ], [ %73, %75 ]
%114 = phi i32 [ %100, %96 ], [ %60, %88 ], [ %60, %56 ], [ %68, %62 ], [ %68, %75 ]
%115 = phi i32 [ %101, %96 ], [ %58, %88 ], [ %58, %56 ], [ %66, %62 ], [ %66, %75 ]
%116 = phi i32 [ %102, %96 ], [ %57, %88 ], [ %57, %56 ], [ %65, %62 ], [ %65, %75 ]
%117 = phi i32 [ %103, %96 ], [ 0, %88 ], [ 0, %56 ], [ %64, %62 ], [ %64, %75 ]
%118 = phi i32 [ %104, %96 ], [ 0, %88 ], [ 0, %56 ], [ 0, %62 ], [ %80, %75 ]
%119 = phi i32 [ %110, %96 ], [ 0, %88 ], [ 0, %56 ], [ 0, %62 ], [ 0, %75 ]
%120 = zext i8 %112 to i32
%121 = add nuw nsw i32 %113, %120
%122 = add nuw nsw i32 %121, %114
%123 = add nuw nsw i32 %122, %115
%124 = add nuw nsw i32 %123, %116
%125 = add nuw nsw i32 %124, %117
%126 = add nuw nsw i32 %125, %118
%127 = add nuw nsw i32 %126, %119
ret i32 %127
}