#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 uint16_t;

/* Variables and functions */
void tiff_decode_nibble(uint8_t *in, uint8_t *out, uint8_t colors,
                        uint16_t columns, uint16_t rows, uint8_t bpc) {
  int i;
  int j;
  int r;
  uint8_t *in_p = in;
  uint8_t *out_p = out;
  uint8_t mask = (1 << bpc) - 1;
  for (r = 0; r < rows; r++) {
    uint8_t *prev = out_p;
    for (j = 0; j < colors; j++) {
      *out_p++ = *in_p++;
    }
    for (i = 1; i < columns; i++) {
      for (j = 0; j < colors; j++) {
        *out_p++ = ((*in_p++ & mask) + (*prev++ & mask)) & mask;
      }
    }
  }
}


x86 assembly (clang, -O0):
<tiff_decode_nibble>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1230 <tiff_decode_nibble+0x130>
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1198 <tiff_decode_nibble+0x98>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115c <tiff_decode_nibble+0x5c>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    121d <tiff_decode_nibble+0x11d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    120a <tiff_decode_nibble+0x10a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
and    -0x44(%rbp),%ecx
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x50(%rbp)
mov    (%rax),%eax
and    -0x44(%rbp),%eax
add    %eax,%ecx
and    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
mov    %ecx,(%rax)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b2 <tiff_decode_nibble+0xb2>
jmp    120f <tiff_decode_nibble+0x10f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119f <tiff_decode_nibble+0x9f>
jmp    1222 <tiff_decode_nibble+0x122>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1141 <tiff_decode_nibble+0x41>
pop    %rbp
ret

x86 assembly (clang, -O2):
<tiff_decode_nibble>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,%ebp
mov    $0xffffffff,%eax
mov    %r9d,%ecx
shl    %cl,%eax
mov    %r8d,-0x38(%rsp)
test   %r8d,%r8d
jle    14f8 <tiff_decode_nibble+0x3f8>
mov    %rsi,%r10
mov    %ebp,%r8d
not    %eax
lea    -0x1(%rdx),%ecx
mov    %rcx,-0x30(%rsp)
lea    0x1(%rcx),%r9
mov    %r9,%r11
and    $0xfffffffffffffff8,%r11
lea    -0x8(%r11),%rcx
mov    %rcx,-0x18(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x28(%rsp)
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %edx,%ecx
neg    %ecx
mov    %ecx,-0x34(%rsp)
mov    %rsi,-0x20(%rsp)
mov    %rsi,%rbp
shl    $0x5,%rbp
xor    %esi,%esi
mov    %rbp,-0x10(%rsp)
jmp    11b3 <tiff_decode_nibble+0xb3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdi,%r13
mov    %rsi,%r15
mov    -0x8(%rsp),%rsi
add    $0x1,%esi
mov    %r15,%r10
mov    %r13,%rdi
cmp    -0x38(%rsp),%esi
mov    -0x10(%rsp),%rbp
je     14f8 <tiff_decode_nibble+0x3f8>
test   %edx,%edx
mov    %rsi,-0x8(%rsp)
jle    1290 <tiff_decode_nibble+0x190>
xor    %r14d,%r14d
cmpl   $0x7,-0x30(%rsp)
jb     11e4 <tiff_decode_nibble+0xe4>
lea    (%rdi,%r9,4),%rcx
cmp    %rcx,%r10
jae    1426 <tiff_decode_nibble+0x326>
lea    (%r10,%r9,4),%rcx
cmp    %rcx,%rdi
jae    1426 <tiff_decode_nibble+0x326>
mov    %r10,%rsi
mov    %edx,%ebp
sub    %r14d,%ebp
mov    %r14d,%r15d
not    %r15d
add    %edx,%r15d
and    $0x7,%ebp
je     1216 <tiff_decode_nibble+0x116>
neg    %ebp
xor    %ecx,%ecx
xchg   %ax,%ax
mov    (%rdi),%ebx
add    $0x4,%rdi
mov    %ebx,(%rsi)
add    $0x4,%rsi
add    $0xffffffff,%ecx
cmp    %ecx,%ebp
jne    1200 <tiff_decode_nibble+0x100>
sub    %ecx,%r14d
cmp    $0x7,%r15d
jb     1293 <tiff_decode_nibble+0x193>
mov    %edx,%r15d
sub    %r14d,%r15d
xor    %ebp,%ebp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rbp,4),%ebx
mov    %ebx,(%rsi,%rbp,4)
mov    0x4(%rdi,%rbp,4),%ebx
mov    %ebx,0x4(%rsi,%rbp,4)
mov    0x8(%rdi,%rbp,4),%ebx
mov    %ebx,0x8(%rsi,%rbp,4)
mov    0xc(%rdi,%rbp,4),%ebx
mov    %ebx,0xc(%rsi,%rbp,4)
mov    0x10(%rdi,%rbp,4),%ebx
mov    %ebx,0x10(%rsi,%rbp,4)
mov    0x14(%rdi,%rbp,4),%ebx
mov    %ebx,0x14(%rsi,%rbp,4)
mov    0x18(%rdi,%rbp,4),%ebx
mov    %ebx,0x18(%rsi,%rbp,4)
mov    0x1c(%rdi,%rbp,4),%ebx
mov    %ebx,0x1c(%rsi,%rbp,4)
add    $0xffffffffffffffe0,%rcx
add    $0x8,%rbp
cmp    %ebp,%r15d
jne    1230 <tiff_decode_nibble+0x130>
sub    %rcx,%rsi
sub    %rcx,%rdi
jmp    1293 <tiff_decode_nibble+0x193>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10,%rsi
cmp    $0x2,%r8d
jl     1190 <tiff_decode_nibble+0x90>
mov    $0x1,%r14d
jmp    12cf <tiff_decode_nibble+0x1cf>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rdi,%r13
mov    %rsi,%r15
mov    %r10,%r12
add    $0x1,%r14d
mov    %r12,%r10
mov    %r15,%rsi
mov    %r13,%rdi
cmp    %r8d,%r14d
je     1196 <tiff_decode_nibble+0x96>
test   %edx,%edx
jle    12b0 <tiff_decode_nibble+0x1b0>
xor    %ecx,%ecx
cmpl   $0x7,-0x30(%rsp)
jb     1380 <tiff_decode_nibble+0x280>
lea    (%rsi,%r9,4),%rbp
lea    (%rdi,%r9,4),%rbx
lea    (%r10,%r9,4),%r13
cmp    %rbx,%rsi
setb   %r15b
cmp    %rbp,%rdi
setb   %r12b
cmp    %r13,%rsi
setb   %bl
cmp    %rbp,%r10
setb   %bpl
test   %r12b,%r15b
jne    1380 <tiff_decode_nibble+0x280>
and    %bpl,%bl
jne    1380 <tiff_decode_nibble+0x280>
lea    (%r10,%r11,4),%r12
lea    (%rsi,%r11,4),%r15
lea    (%rdi,%r11,4),%r13
xor    %ecx,%ecx
nop
movdqu (%rdi,%rcx,4),%xmm1
movdqu 0x10(%rdi,%rcx,4),%xmm2
pand   %xmm0,%xmm1
pand   %xmm0,%xmm2
movdqu (%r10,%rcx,4),%xmm3
movdqu 0x10(%r10,%rcx,4),%xmm4
pand   %xmm0,%xmm3
paddd  %xmm1,%xmm3
pand   %xmm0,%xmm4
paddd  %xmm2,%xmm4
pand   %xmm0,%xmm3
pand   %xmm0,%xmm4
movdqu %xmm3,(%rsi,%rcx,4)
movdqu %xmm4,0x10(%rsi,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%r11
jne    1320 <tiff_decode_nibble+0x220>
mov    %r11d,%ecx
cmp    %r11,%r9
je     12b9 <tiff_decode_nibble+0x1b9>
jmp    1389 <tiff_decode_nibble+0x289>
nopw   0x0(%rax,%rax,1)
mov    %r10,%r12
mov    %rsi,%r15
mov    %rdi,%r13
mov    %edx,%esi
sub    %ecx,%esi
test   $0x1,%sil
jne    13a0 <tiff_decode_nibble+0x2a0>
mov    %ecx,%ebp
jmp    13c2 <tiff_decode_nibble+0x2c2>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13),%esi
and    %eax,%esi
add    $0x4,%r13
mov    (%r12),%ebp
and    %eax,%ebp
add    $0x4,%r12
add    %esi,%ebp
and    %eax,%ebp
mov    %ebp,(%r15)
add    $0x4,%r15
lea    0x1(%rcx),%ebp
not    %ecx
cmp    -0x34(%rsp),%ecx
je     12b9 <tiff_decode_nibble+0x1b9>
mov    %edx,%esi
sub    %ebp,%esi
xor    %ebp,%ebp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rbp,4),%ebx
and    %eax,%ebx
mov    (%r12,%rbp,4),%edi
and    %eax,%edi
add    %ebx,%edi
and    %eax,%edi
mov    %edi,(%r15,%rbp,4)
mov    0x4(%r13,%rbp,4),%edi
and    %eax,%edi
mov    0x4(%r12,%rbp,4),%ebx
and    %eax,%ebx
add    %edi,%ebx
and    %eax,%ebx
mov    %ebx,0x4(%r15,%rbp,4)
add    $0xfffffffffffffff8,%rcx
add    $0x2,%rbp
cmp    %ebp,%esi
jne    13e0 <tiff_decode_nibble+0x2e0>
sub    %rcx,%r12
sub    %rcx,%r15
sub    %rcx,%r13
jmp    12b9 <tiff_decode_nibble+0x1b9>
cmpq   $0x18,-0x18(%rsp)
jae    1432 <tiff_decode_nibble+0x332>
xor    %ecx,%ecx
jmp    14a4 <tiff_decode_nibble+0x3a4>
mov    -0x28(%rsp),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rdi,%rcx,4),%xmm1
movups 0x10(%rdi,%rcx,4),%xmm2
movups %xmm1,(%r10,%rcx,4)
movups %xmm2,0x10(%r10,%rcx,4)
movups 0x20(%rdi,%rcx,4),%xmm1
movups 0x30(%rdi,%rcx,4),%xmm2
movups %xmm1,0x20(%r10,%rcx,4)
movups %xmm2,0x30(%r10,%rcx,4)
movups 0x40(%rdi,%rcx,4),%xmm1
movups 0x50(%rdi,%rcx,4),%xmm2
movups %xmm1,0x40(%r10,%rcx,4)
movups %xmm2,0x50(%r10,%rcx,4)
movdqu 0x60(%rdi,%rcx,4),%xmm1
movdqu 0x70(%rdi,%rcx,4),%xmm2
movdqu %xmm1,0x60(%r10,%rcx,4)
movdqu %xmm2,0x70(%r10,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1440 <tiff_decode_nibble+0x340>
cmpq   $0x0,-0x20(%rsp)
je     14df <tiff_decode_nibble+0x3df>
lea    (%rdi,%rcx,4),%rsi
add    $0x10,%rsi
lea    (%r10,%rcx,4),%rcx
add    $0x10,%rcx
xor    %ebx,%ebx
xchg   %ax,%ax
movdqu -0x10(%rsi,%rbx,1),%xmm1
movdqu (%rsi,%rbx,1),%xmm2
movdqu %xmm1,-0x10(%rcx,%rbx,1)
movdqu %xmm2,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rbp
jne    14c0 <tiff_decode_nibble+0x3c0>
lea    (%r10,%r11,4),%rsi
lea    (%rdi,%r11,4),%rdi
mov    %r11d,%r14d
cmp    %r11,%r9
je     1293 <tiff_decode_nibble+0x193>
jmp    11e7 <tiff_decode_nibble+0xe7>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @tiff_decode_nibble(i32* nocapture %0, i32* nocapture %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = shl nsw i32 -1, %5
%8 = xor i32 %7, -1
%9 = icmp sgt i32 %4, 0
br i1 %9, label %10, label %301
10: ; preds = %6
%11 = icmp sgt i32 %2, 0
%12 = icmp sgt i32 %3, 1
%13 = add i32 %2, -1
%14 = zext i32 %13 to i64
%15 = add nuw nsw i64 %14, 1
%16 = zext i32 %13 to i64
%17 = add nuw nsw i64 %16, 1
%18 = zext i32 %13 to i64
%19 = add nuw nsw i64 %18, 1
%20 = add i32 %2, -1
%21 = zext i32 %20 to i64
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 8589934584
%24 = add nsw i64 %23, -8
%25 = lshr exact i64 %24, 3
%26 = add nuw nsw i64 %25, 1
%27 = icmp ult i32 %20, 7
%28 = and i64 %22, 8589934584
%29 = trunc i64 %28 to i32
%30 = and i64 %26, 3
%31 = icmp ult i64 %24, 24
%32 = and i64 %26, 4611686018427387900
%33 = icmp eq i64 %30, 0
%34 = icmp eq i64 %22, %28
%35 = icmp ult i32 %13, 7
%36 = and i64 %17, 8589934584
%37 = trunc i64 %36 to i32
%38 = insertelement <4 x i32> poison, i32 %8, i64 0
%39 = shufflevector <4 x i32> %38, <4 x i32> poison, <4 x i32> zeroinitializer
%40 = insertelement <4 x i32> poison, i32 %8, i64 0
%41 = shufflevector <4 x i32> %40, <4 x i32> poison, <4 x i32> zeroinitializer
%42 = icmp eq i64 %17, %36
%43 = sub i32 0, %2
br label %44
44: ; preds = %10, %296
%45 = phi i32* [ %1, %10 ], [ %298, %296 ]
%46 = phi i32* [ %0, %10 ], [ %297, %296 ]
%47 = phi i32 [ 0, %10 ], [ %299, %296 ]
br i1 %11, label %48, label %153
48: ; preds = %44
br i1 %27, label %126, label %49
49: ; preds = %48
%50 = getelementptr i32, i32* %45, i64 %19
%51 = getelementptr i32, i32* %46, i64 %19
%52 = icmp ult i32* %45, %51
%53 = icmp ult i32* %46, %50
%54 = and i1 %52, %53
br i1 %54, label %126, label %55
55: ; preds = %49
%56 = getelementptr i32, i32* %45, i64 %28
%57 = getelementptr i32, i32* %46, i64 %28
br i1 %31, label %107, label %58
58: ; preds = %55, %58
%59 = phi i64 [ %104, %58 ], [ 0, %55 ]
%60 = phi i64 [ %105, %58 ], [ 0, %55 ]
%61 = getelementptr i32, i32* %45, i64 %59
%62 = getelementptr i32, i32* %46, i64 %59
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr i32, i32* %62, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %68
%69 = getelementptr i32, i32* %61, i64 4
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %70
%71 = or i64 %59, 8
%72 = getelementptr i32, i32* %45, i64 %71
%73 = getelementptr i32, i32* %46, i64 %71
%74 = bitcast i32* %73 to <4 x i32>*
%75 = load <4 x i32>, <4 x i32>* %74
%76 = getelementptr i32, i32* %73, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %75, <4 x i32>* %79
%80 = getelementptr i32, i32* %72, i64 4
%81 = bitcast i32* %80 to <4 x i32>*
store <4 x i32> %78, <4 x i32>* %81
%82 = or i64 %59, 16
%83 = getelementptr i32, i32* %45, i64 %82
%84 = getelementptr i32, i32* %46, i64 %82
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = getelementptr i32, i32* %84, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %86, <4 x i32>* %90
%91 = getelementptr i32, i32* %83, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %92
%93 = or i64 %59, 24
%94 = getelementptr i32, i32* %45, i64 %93
%95 = getelementptr i32, i32* %46, i64 %93
%96 = bitcast i32* %95 to <4 x i32>*
%97 = load <4 x i32>, <4 x i32>* %96
%98 = getelementptr i32, i32* %95, i64 4
%99 = bitcast i32* %98 to <4 x i32>*
%100 = load <4 x i32>, <4 x i32>* %99
%101 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> %97, <4 x i32>* %101
%102 = getelementptr i32, i32* %94, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> %100, <4 x i32>* %103
%104 = add nuw i64 %59, 32
%105 = add i64 %60, 4
%106 = icmp eq i64 %105, %32
br i1 %106, label %107, label %58
107: ; preds = %58, %55
%108 = phi i64 [ 0, %55 ], [ %104, %58 ]
br i1 %33, label %125, label %109
109: ; preds = %107, %109
%110 = phi i64 [ %122, %109 ], [ %108, %107 ]
%111 = phi i64 [ %123, %109 ], [ 0, %107 ]
%112 = getelementptr i32, i32* %45, i64 %110
%113 = getelementptr i32, i32* %46, i64 %110
%114 = bitcast i32* %113 to <4 x i32>*
%115 = load <4 x i32>, <4 x i32>* %114
%116 = getelementptr i32, i32* %113, i64 4
%117 = bitcast i32* %116 to <4 x i32>*
%118 = load <4 x i32>, <4 x i32>* %117
%119 = bitcast i32* %112 to <4 x i32>*
store <4 x i32> %115, <4 x i32>* %119
%120 = getelementptr i32, i32* %112, i64 4
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %118, <4 x i32>* %121
%122 = add nuw i64 %110, 8
%123 = add i64 %111, 1
%124 = icmp eq i64 %123, %30
br i1 %124, label %125, label %109
125: ; preds = %109, %107
br i1 %34, label %153, label %126
126: ; preds = %49, %48, %125
%127 = phi i32* [ %45, %49 ], [ %45, %48 ], [ %56, %125 ]
%128 = phi i32* [ %46, %49 ], [ %46, %48 ], [ %57, %125 ]
%129 = phi i32 [ 0, %49 ], [ 0, %48 ], [ %29, %125 ]
%130 = sub i32 %2, %129
%131 = xor i32 %129, -1
%132 = add i32 %131, %2
%133 = and i32 %130, 7
%134 = icmp eq i32 %133, 0
br i1 %134, label %146, label %135
135: ; preds = %126, %135
%136 = phi i32* [ %142, %135 ], [ %127, %126 ]
%137 = phi i32* [ %140, %135 ], [ %128, %126 ]
%138 = phi i32 [ %143, %135 ], [ %129, %126 ]
%139 = phi i32 [ %144, %135 ], [ 0, %126 ]
%140 = getelementptr inbounds i32, i32* %137, i64 1
%141 = load i32, i32* %137
%142 = getelementptr inbounds i32, i32* %136, i64 1
store i32 %141, i32* %136
%143 = add nuw nsw i32 %138, 1
%144 = add i32 %139, 1
%145 = icmp eq i32 %144, %133
br i1 %145, label %146, label %135
146: ; preds = %135, %126
%147 = phi i32* [ undef, %126 ], [ %140, %135 ]
%148 = phi i32* [ undef, %126 ], [ %142, %135 ]
%149 = phi i32* [ %127, %126 ], [ %142, %135 ]
%150 = phi i32* [ %128, %126 ], [ %140, %135 ]
%151 = phi i32 [ %129, %126 ], [ %143, %135 ]
%152 = icmp ult i32 %132, 7
br i1 %152, label %153, label %156
153: ; preds = %146, %156, %125, %44
%154 = phi i32* [ %46, %44 ], [ %57, %125 ], [ %147, %146 ], [ %181, %156 ]
%155 = phi i32* [ %45, %44 ], [ %56, %125 ], [ %148, %146 ], [ %183, %156 ]
br i1 %12, label %186, label %296
156: ; preds = %146, %156
%157 = phi i32* [ %183, %156 ], [ %149, %146 ]
%158 = phi i32* [ %181, %156 ], [ %150, %146 ]
%159 = phi i32 [ %184, %156 ], [ %151, %146 ]
%160 = getelementptr inbounds i32, i32* %158, i64 1
%161 = load i32, i32* %158
%162 = getelementptr inbounds i32, i32* %157, i64 1
store i32 %161, i32* %157
%163 = getelementptr inbounds i32, i32* %158, i64 2
%164 = load i32, i32* %160
%165 = getelementptr inbounds i32, i32* %157, i64 2
store i32 %164, i32* %162
%166 = getelementptr inbounds i32, i32* %158, i64 3
%167 = load i32, i32* %163
%168 = getelementptr inbounds i32, i32* %157, i64 3
store i32 %167, i32* %165
%169 = getelementptr inbounds i32, i32* %158, i64 4
%170 = load i32, i32* %166
%171 = getelementptr inbounds i32, i32* %157, i64 4
store i32 %170, i32* %168
%172 = getelementptr inbounds i32, i32* %158, i64 5
%173 = load i32, i32* %169
%174 = getelementptr inbounds i32, i32* %157, i64 5
store i32 %173, i32* %171
%175 = getelementptr inbounds i32, i32* %158, i64 6
%176 = load i32, i32* %172
%177 = getelementptr inbounds i32, i32* %157, i64 6
store i32 %176, i32* %174
%178 = getelementptr inbounds i32, i32* %158, i64 7
%179 = load i32, i32* %175
%180 = getelementptr inbounds i32, i32* %157, i64 7
store i32 %179, i32* %177
%181 = getelementptr inbounds i32, i32* %158, i64 8
%182 = load i32, i32* %178
%183 = getelementptr inbounds i32, i32* %157, i64 8
store i32 %182, i32* %180
%184 = add nuw nsw i32 %159, 8
%185 = icmp eq i32 %184, %2
br i1 %185, label %153, label %156
186: ; preds = %153, %290
%187 = phi i32* [ %293, %290 ], [ %45, %153 ]
%188 = phi i32 [ %294, %290 ], [ 1, %153 ]
%189 = phi i32* [ %292, %290 ], [ %155, %153 ]
%190 = phi i32* [ %291, %290 ], [ %154, %153 ]
br i1 %11, label %191, label %290
191: ; preds = %186
br i1 %35, label %236, label %192
192: ; preds = %191
%193 = getelementptr i32, i32* %189, i64 %15
%194 = getelementptr i32, i32* %190, i64 %15
%195 = getelementptr i32, i32* %187, i64 %15
%196 = icmp ult i32* %189, %194
%197 = icmp ult i32* %190, %193
%198 = and i1 %196, %197
%199 = icmp ult i32* %189, %195
%200 = icmp ult i32* %187, %193
%201 = and i1 %199, %200
%202 = or i1 %198, %201
br i1 %202, label %236, label %203
203: ; preds = %192
%204 = getelementptr i32, i32* %187, i64 %36
%205 = getelementptr i32, i32* %189, i64 %36
%206 = getelementptr i32, i32* %190, i64 %36
br label %207
207: ; preds = %207, %203
%208 = phi i64 [ 0, %203 ], [ %233, %207 ]
%209 = getelementptr i32, i32* %187, i64 %208
%210 = getelementptr i32, i32* %189, i64 %208
%211 = getelementptr i32, i32* %190, i64 %208
%212 = bitcast i32* %211 to <4 x i32>*
%213 = load <4 x i32>, <4 x i32>* %212
%214 = getelementptr i32, i32* %211, i64 4
%215 = bitcast i32* %214 to <4 x i32>*
%216 = load <4 x i32>, <4 x i32>* %215
%217 = and <4 x i32> %213, %39
%218 = and <4 x i32> %216, %41
%219 = bitcast i32* %209 to <4 x i32>*
%220 = load <4 x i32>, <4 x i32>* %219
%221 = getelementptr i32, i32* %209, i64 4
%222 = bitcast i32* %221 to <4 x i32>*
%223 = load <4 x i32>, <4 x i32>* %222
%224 = and <4 x i32> %220, %39
%225 = and <4 x i32> %223, %41
%226 = add nsw <4 x i32> %224, %217
%227 = add nsw <4 x i32> %225, %218
%228 = and <4 x i32> %226, %39
%229 = and <4 x i32> %227, %41
%230 = bitcast i32* %210 to <4 x i32>*
store <4 x i32> %228, <4 x i32>* %230
%231 = getelementptr i32, i32* %210, i64 4
%232 = bitcast i32* %231 to <4 x i32>*
store <4 x i32> %229, <4 x i32>* %232
%233 = add nuw i64 %208, 8
%234 = icmp eq i64 %233, %36
br i1 %234, label %235, label %207
235: ; preds = %207
br i1 %42, label %290, label %236
236: ; preds = %192, %191, %235
%237 = phi i32* [ %187, %192 ], [ %187, %191 ], [ %204, %235 ]
%238 = phi i32* [ %189, %192 ], [ %189, %191 ], [ %205, %235 ]
%239 = phi i32* [ %190, %192 ], [ %190, %191 ], [ %206, %235 ]
%240 = phi i32 [ 0, %192 ], [ 0, %191 ], [ %37, %235 ]
%241 = sub i32 %2, %240
%242 = xor i32 %240, -1
%243 = and i32 %241, 1
%244 = icmp eq i32 %243, 0
br i1 %244, label %256, label %245
245: ; preds = %236
%246 = getelementptr inbounds i32, i32* %239, i64 1
%247 = load i32, i32* %239
%248 = and i32 %247, %8
%249 = getelementptr inbounds i32, i32* %237, i64 1
%250 = load i32, i32* %237
%251 = and i32 %250, %8
%252 = add nsw i32 %251, %248
%253 = and i32 %252, %8
%254 = getelementptr inbounds i32, i32* %238, i64 1
store i32 %253, i32* %238
%255 = add nuw nsw i32 %240, 1
br label %256
256: ; preds = %245, %236
%257 = phi i32* [ undef, %236 ], [ %246, %245 ]
%258 = phi i32* [ undef, %236 ], [ %249, %245 ]
%259 = phi i32* [ undef, %236 ], [ %254, %245 ]
%260 = phi i32* [ %237, %236 ], [ %249, %245 ]
%261 = phi i32* [ %238, %236 ], [ %254, %245 ]
%262 = phi i32* [ %239, %236 ], [ %246, %245 ]
%263 = phi i32 [ %240, %236 ], [ %255, %245 ]
%264 = icmp eq i32 %242, %43
br i1 %264, label %290, label %265
265: ; preds = %256, %265
%266 = phi i32* [ %282, %265 ], [ %260, %256 ]
%267 = phi i32* [ %287, %265 ], [ %261, %256 ]
%268 = phi i32* [ %279, %265 ], [ %262, %256 ]
%269 = phi i32 [ %288, %265 ], [ %263, %256 ]
%270 = getelementptr inbounds i32, i32* %268, i64 1
%271 = load i32, i32* %268
%272 = and i32 %271, %8
%273 = getelementptr inbounds i32, i32* %266, i64 1
%274 = load i32, i32* %266
%275 = and i32 %274, %8
%276 = add nsw i32 %275, %272
%277 = and i32 %276, %8
%278 = getelementptr inbounds i32, i32* %267, i64 1
store i32 %277, i32* %267
%279 = getelementptr inbounds i32, i32* %268, i64 2
%280 = load i32, i32* %270
%281 = and i32 %280, %8
%282 = getelementptr inbounds i32, i32* %266, i64 2
%283 = load i32, i32* %273
%284 = and i32 %283, %8
%285 = add nsw i32 %284, %281
%286 = and i32 %285, %8
%287 = getelementptr inbounds i32, i32* %267, i64 2
store i32 %286, i32* %278
%288 = add nuw nsw i32 %269, 2
%289 = icmp eq i32 %288, %2
br i1 %289, label %290, label %265
290: ; preds = %256, %265, %235, %186
%291 = phi i32* [ %190, %186 ], [ %206, %235 ], [ %257, %256 ], [ %279, %265 ]
%292 = phi i32* [ %189, %186 ], [ %205, %235 ], [ %259, %256 ], [ %287, %265 ]
%293 = phi i32* [ %187, %186 ], [ %204, %235 ], [ %258, %256 ], [ %282, %265 ]
%294 = add nuw nsw i32 %188, 1
%295 = icmp eq i32 %294, %3
br i1 %295, label %296, label %186
296: ; preds = %290, %153
%297 = phi i32* [ %154, %153 ], [ %291, %290 ]
%298 = phi i32* [ %155, %153 ], [ %292, %290 ]
%299 = add nuw nsw i32 %47, 1
%300 = icmp eq i32 %299, %4
br i1 %300, label %301, label %44
301: ; preds = %296, %6
ret void
}