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

/* Variables and functions */
void tiff_decode_32(uint8_t *in, uint8_t *out, uint8_t colors, uint16_t columns,
                    uint16_t rows) {
  int i;
  int j;
  int r;
  uint32_t *in_p = (uint32_t *)in;
  uint32_t *out_p = (uint32_t *)out;
  for (r = 0; r < rows; r++) {
    uint32_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++ + *prev++;
      }
    }
  }
}


x86 assembly (clang, -O0):
<tiff_decode_32>:
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    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1211 <tiff_decode_32+0x111>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1184 <tiff_decode_32+0x84>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1148 <tiff_decode_32+0x48>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11fe <tiff_decode_32+0xfe>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11eb <tiff_decode_32+0xeb>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%ecx
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x40(%rbp)
add    (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119e <tiff_decode_32+0x9e>
jmp    11f0 <tiff_decode_32+0xf0>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    118b <tiff_decode_32+0x8b>
jmp    1203 <tiff_decode_32+0x103>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    112d <tiff_decode_32+0x2d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<tiff_decode_32>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8d,-0x3c(%rsp)
test   %r8d,%r8d
jle    1548 <tiff_decode_32+0x448>
mov    %rsi,%r15
lea    -0x1(%rdx),%r9d
lea    0x1(%r9),%r10
mov    %r10,%r13
and    $0xfffffffffffffff8,%r13
lea    -0x8(%r13),%rax
mov    %rax,-0x30(%rsp)
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
mov    %rsi,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rsp)
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
mov    %rsi,%rax
mov    %rsi,-0x8(%rsp)
and    %rsi,%rbx
mov    %rbx,-0x18(%rsp)
mov    %rbp,-0x20(%rsp)
shl    $0x5,%rbp
mov    %rbp,-0x38(%rsp)
xor    %eax,%eax
jmp    1195 <tiff_decode_32+0x95>
nop
mov    -0x10(%rsp),%rax
add    $0x1,%eax
mov    %rsi,%r15
cmp    -0x3c(%rsp),%eax
je     1548 <tiff_decode_32+0x448>
test   %edx,%edx
mov    %rax,-0x10(%rsp)
jle    1270 <tiff_decode_32+0x170>
xor    %r14d,%r14d
cmp    $0x7,%r9d
jb     11c5 <tiff_decode_32+0xc5>
lea    (%rdi,%r10,4),%rax
cmp    %rax,%r15
jae    146e <tiff_decode_32+0x36e>
lea    (%r15,%r10,4),%rax
cmp    %rax,%rdi
jae    146e <tiff_decode_32+0x36e>
mov    %r15,%rsi
mov    %edx,%ebp
sub    %r14d,%ebp
mov    %r14d,%r12d
not    %r12d
add    %edx,%r12d
and    $0x7,%ebp
je     11f6 <tiff_decode_32+0xf6>
neg    %ebp
xor    %eax,%eax
nop
mov    (%rdi),%ebx
add    $0x4,%rdi
mov    %ebx,(%rsi)
add    $0x4,%rsi
add    $0xffffffff,%eax
cmp    %eax,%ebp
jne    11e0 <tiff_decode_32+0xe0>
sub    %eax,%r14d
cmp    $0x7,%r12d
jb     1273 <tiff_decode_32+0x173>
mov    %edx,%r12d
sub    %r14d,%r12d
xor    %eax,%eax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rax,4),%ebx
mov    %ebx,(%rsi,%rax,4)
mov    0x4(%rdi,%rax,4),%ebx
mov    %ebx,0x4(%rsi,%rax,4)
mov    0x8(%rdi,%rax,4),%ebx
mov    %ebx,0x8(%rsi,%rax,4)
mov    0xc(%rdi,%rax,4),%ebx
mov    %ebx,0xc(%rsi,%rax,4)
mov    0x10(%rdi,%rax,4),%ebx
mov    %ebx,0x10(%rsi,%rax,4)
mov    0x14(%rdi,%rax,4),%ebx
mov    %ebx,0x14(%rsi,%rax,4)
mov    0x18(%rdi,%rax,4),%ebx
mov    %ebx,0x18(%rsi,%rax,4)
mov    0x1c(%rdi,%rax,4),%ebx
mov    %ebx,0x1c(%rsi,%rax,4)
add    $0xffffffffffffffe0,%rbp
add    $0x8,%rax
cmp    %eax,%r12d
jne    1210 <tiff_decode_32+0x110>
sub    %rbp,%rsi
sub    %rbp,%rdi
jmp    1273 <tiff_decode_32+0x173>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15,%rsi
cmp    $0x2,%ecx
jl     1180 <tiff_decode_32+0x80>
mov    $0x1,%r14d
jmp    129d <tiff_decode_32+0x19d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14d
cmp    %ecx,%r14d
je     1180 <tiff_decode_32+0x80>
test   %edx,%edx
jle    1290 <tiff_decode_32+0x190>
xor    %r12d,%r12d
cmp    $0x7,%r9d
jb     13b0 <tiff_decode_32+0x2b0>
lea    (%rsi,%r10,4),%rbx
lea    (%rdi,%r10,4),%rax
lea    (%r15,%r10,4),%rbp
cmp    %rax,%rsi
setb   %r8b
cmp    %rbx,%rdi
setb   %r11b
cmp    %rbp,%rsi
setb   %al
cmp    %rbx,%r15
setb   %bl
test   %r11b,%r8b
jne    13b0 <tiff_decode_32+0x2b0>
and    %bl,%al
jne    13b0 <tiff_decode_32+0x2b0>
cmpq   $0x0,-0x30(%rsp)
je     145c <tiff_decode_32+0x35c>
mov    -0x18(%rsp),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rbx,4),%xmm0
movdqu 0x10(%rdi,%rbx,4),%xmm1
movdqu (%r15,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r15,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rsi,%rbx,4)
movdqu %xmm0,0x10(%rsi,%rbx,4)
movdqu 0x20(%rdi,%rbx,4),%xmm0
movdqu 0x30(%rdi,%rbx,4),%xmm1
movdqu 0x20(%r15,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x30(%r15,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,0x20(%rsi,%rbx,4)
movdqu %xmm0,0x30(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1300 <tiff_decode_32+0x200>
testb  $0x1,-0x8(%rsp)
je     1395 <tiff_decode_32+0x295>
movdqu (%rdi,%rbx,4),%xmm0
movdqu 0x10(%rdi,%rbx,4),%xmm1
movdqu (%r15,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r15,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rsi,%rbx,4)
movdqu %xmm0,0x10(%rsi,%rbx,4)
lea    (%r15,%r13,4),%r15
lea    (%rsi,%r13,4),%rsi
lea    (%rdi,%r13,4),%rdi
mov    %r13d,%r12d
cmp    %r13,%r10
je     1290 <tiff_decode_32+0x190>
nopl   (%rax)
mov    %edx,%ebp
sub    %r12d,%ebp
mov    %r12d,%r8d
not    %r8d
add    %edx,%r8d
and    $0x3,%ebp
je     13ed <tiff_decode_32+0x2ed>
neg    %ebp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r15),%ebx
add    $0x4,%r15
add    (%rdi),%ebx
add    $0x4,%rdi
mov    %ebx,(%rsi)
add    $0x4,%rsi
add    $0xffffffff,%eax
cmp    %eax,%ebp
jne    13d0 <tiff_decode_32+0x2d0>
sub    %eax,%r12d
cmp    $0x3,%r8d
jb     1290 <tiff_decode_32+0x190>
mov    %edx,%r8d
sub    %r12d,%r8d
xor    %eax,%eax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rax,4),%ebp
add    (%rdi,%rax,4),%ebp
mov    %ebp,(%rsi,%rax,4)
mov    0x4(%r15,%rax,4),%ebp
add    0x4(%rdi,%rax,4),%ebp
mov    %ebp,0x4(%rsi,%rax,4)
mov    0x8(%r15,%rax,4),%ebp
add    0x8(%rdi,%rax,4),%ebp
mov    %ebp,0x8(%rsi,%rax,4)
mov    0xc(%r15,%rax,4),%ebp
add    0xc(%rdi,%rax,4),%ebp
mov    %ebp,0xc(%rsi,%rax,4)
add    $0xfffffffffffffff0,%rbx
add    $0x4,%rax
cmp    %eax,%r8d
jne    1410 <tiff_decode_32+0x310>
sub    %rbx,%r15
sub    %rbx,%rsi
sub    %rbx,%rdi
jmp    1290 <tiff_decode_32+0x190>
xor    %ebx,%ebx
testb  $0x1,-0x8(%rsp)
jne    136a <tiff_decode_32+0x26a>
jmp    1395 <tiff_decode_32+0x295>
cmpq   $0x18,-0x30(%rsp)
jae    147f <tiff_decode_32+0x37f>
xor    %esi,%esi
mov    -0x38(%rsp),%rbp
jmp    14f4 <tiff_decode_32+0x3f4>
mov    -0x28(%rsp),%rax
xor    %esi,%esi
mov    -0x38(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rsi,4),%xmm0
movups 0x10(%rdi,%rsi,4),%xmm1
movups %xmm0,(%r15,%rsi,4)
movups %xmm1,0x10(%r15,%rsi,4)
movups 0x20(%rdi,%rsi,4),%xmm0
movups 0x30(%rdi,%rsi,4),%xmm1
movups %xmm0,0x20(%r15,%rsi,4)
movups %xmm1,0x30(%r15,%rsi,4)
movups 0x40(%rdi,%rsi,4),%xmm0
movups 0x50(%rdi,%rsi,4),%xmm1
movups %xmm0,0x40(%r15,%rsi,4)
movups %xmm1,0x50(%r15,%rsi,4)
movdqu 0x60(%rdi,%rsi,4),%xmm0
movdqu 0x70(%rdi,%rsi,4),%xmm1
movdqu %xmm0,0x60(%r15,%rsi,4)
movdqu %xmm1,0x70(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rax
jne    1490 <tiff_decode_32+0x390>
cmpq   $0x0,-0x20(%rsp)
je     152f <tiff_decode_32+0x42f>
lea    (%rdi,%rsi,4),%rax
add    $0x10,%rax
lea    (%r15,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebx,%ebx
xchg   %ax,%ax
movdqu -0x10(%rax,%rbx,1),%xmm0
movdqu (%rax,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rbx,1)
movdqu %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rbp
jne    1510 <tiff_decode_32+0x410>
lea    (%r15,%r13,4),%rsi
lea    (%rdi,%r13,4),%rdi
mov    %r13d,%r14d
cmp    %r13,%r10
je     1273 <tiff_decode_32+0x173>
jmp    11c8 <tiff_decode_32+0xc8>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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