int flip_image(the_image, out_image, type, rows, cols)
int type;
long cols, rows;
short **the_image, **out_image;
{
  int cd2, i, j, rd2;
  if (type != 1 && type != 2 && type != 3 && type != 4 && type != 5)
    type = 1;
  if (type == 1 || type == 2 || type == 3) {
    for (i = 0; i < rows; i++) {
      for (j = 0; j < cols; j++)
        out_image[j][cols - 1 - i] = the_image[i][j];
    }
  }
  if (type == 2 || type == 3) {
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    for (i = 0; i < rows; i++) {
      for (j = 0; j < cols; j++)
        out_image[j][cols - 1 - i] = the_image[i][j];
    }
  }
  if (type == 3) {
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    for (i = 0; i < rows; i++) {
      for (j = 0; j < cols; j++)
        out_image[j][cols - 1 - i] = the_image[i][j];
    }
  }
  if (type == 4) {
    cd2 = cols / 2;
    for (j = 0; j < cd2; j++) {
      for (i = 0; i < rows; i++) {
        out_image[i][cols - 1 - j] = the_image[i][j];
      }
    }
    for (j = cd2; j < cols; j++) {
      for (i = 0; i < rows; i++) {
        out_image[i][cols - 1 - j] = the_image[i][j];
      }
    }
  }
  if (type == 5) {
    rd2 = rows / 2;
    for (i = 0; i < rd2; i++) {
      for (j = 0; j < cols; j++) {
        out_image[rows - 1 - i][j] = the_image[i][j];
      }
    }
    for (i = rd2; i < rows; i++) {
      for (j = 0; j < cols; j++) {
        out_image[rows - 1 - i][j] = the_image[i][j];
      }
    }
  }
  return (1);
}


x86 assembly (clang, -O0):
<flip_image>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
cmpl   $0x1,-0x14(%rbp)
je     1150 <flip_image+0x50>
cmpl   $0x2,-0x14(%rbp)
je     1150 <flip_image+0x50>
cmpl   $0x3,-0x14(%rbp)
je     1150 <flip_image+0x50>
cmpl   $0x4,-0x14(%rbp)
je     1150 <flip_image+0x50>
cmpl   $0x5,-0x14(%rbp)
je     1150 <flip_image+0x50>
movl   $0x1,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
je     116e <flip_image+0x6e>
cmpl   $0x2,-0x14(%rbp)
je     116e <flip_image+0x6e>
cmpl   $0x3,-0x14(%rbp)
jne    11f1 <flip_image+0xf1>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    11ec <flip_image+0xec>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    11d9 <flip_image+0xd9>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x30(%rbp),%rsi
sub    %rsi,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    118a <flip_image+0x8a>
jmp    11de <flip_image+0xde>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1175 <flip_image+0x75>
jmp    11f1 <flip_image+0xf1>
cmpl   $0x2,-0x14(%rbp)
je     1205 <flip_image+0x105>
cmpl   $0x3,-0x14(%rbp)
jne    12fb <flip_image+0x1fb>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1278 <flip_image+0x178>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1265 <flip_image+0x165>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1221 <flip_image+0x121>
jmp    126a <flip_image+0x16a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    120c <flip_image+0x10c>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    12f6 <flip_image+0x1f6>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    12e3 <flip_image+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x30(%rbp),%rsi
sub    %rsi,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1294 <flip_image+0x194>
jmp    12e8 <flip_image+0x1e8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    127f <flip_image+0x17f>
jmp    12fb <flip_image+0x1fb>
cmpl   $0x3,-0x14(%rbp)
jne    13fb <flip_image+0x2fb>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1378 <flip_image+0x278>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1365 <flip_image+0x265>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1321 <flip_image+0x221>
jmp    136a <flip_image+0x26a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    130c <flip_image+0x20c>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    13f6 <flip_image+0x2f6>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    13e3 <flip_image+0x2e3>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x30(%rbp),%rsi
sub    %rsi,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1394 <flip_image+0x294>
jmp    13e8 <flip_image+0x2e8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    137f <flip_image+0x27f>
jmp    13fb <flip_image+0x2fb>
cmpl   $0x4,-0x14(%rbp)
jne    1514 <flip_image+0x414>
mov    -0x28(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1492 <flip_image+0x392>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    147f <flip_image+0x37f>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x34(%rbp),%rsi
sub    %rsi,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1430 <flip_image+0x330>
jmp    1484 <flip_image+0x384>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    141d <flip_image+0x31d>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    150f <flip_image+0x40f>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    14fc <flip_image+0x3fc>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x34(%rbp),%rsi
sub    %rsi,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14ad <flip_image+0x3ad>
jmp    1501 <flip_image+0x401>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1498 <flip_image+0x398>
jmp    1514 <flip_image+0x414>
cmpl   $0x5,-0x14(%rbp)
jne    162d <flip_image+0x52d>
mov    -0x20(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    15ab <flip_image+0x4ab>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1598 <flip_image+0x498>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x30(%rbp),%rsi
sub    %rsi,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1549 <flip_image+0x449>
jmp    159d <flip_image+0x49d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1536 <flip_image+0x436>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1628 <flip_image+0x528>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1615 <flip_image+0x515>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
movslq -0x30(%rbp),%rsi
sub    %rsi,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15c6 <flip_image+0x4c6>
jmp    161a <flip_image+0x51a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15b1 <flip_image+0x4b1>
jmp    162d <flip_image+0x52d>
mov    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<flip_image>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    -0x6(%rdx),%eax
cmp    $0xfffffffb,%eax
mov    $0x1,%eax
cmovae %edx,%eax
mov    %rax,-0x18(%rsp)
add    $0xffffffff,%eax
cmp    $0x2,%eax
ja     11fb <flip_image+0xfb>
test   %rcx,%rcx
jle    11fb <flip_image+0xfb>
lea    -0x1(%r8),%r9
mov    %r8d,%r14d
and    $0x3,%r14d
mov    %r8,%r11
and    $0xfffffffffffffffc,%r11
xor    %r10d,%r10d
jmp    115d <flip_image+0x5d>
nopl   0x0(%rax)
add    $0x1,%r10
cmp    %rcx,%r10
je     11fb <flip_image+0xfb>
test   %r8,%r8
jle    1150 <flip_image+0x50>
mov    %r10,%rbx
not    %rbx
add    %r8,%rbx
mov    (%rdi,%r10,8),%r15
xor    %ebp,%ebp
cmp    $0x3,%r9
jb     11c3 <flip_image+0xc3>
nopw   0x0(%rax,%rax,1)
movzwl (%r15,%rbp,2),%edx
mov    (%rsi,%rbp,8),%rax
mov    %dx,(%rax,%rbx,2)
movzwl 0x2(%r15,%rbp,2),%eax
mov    0x8(%rsi,%rbp,8),%rdx
mov    %ax,(%rdx,%rbx,2)
movzwl 0x4(%r15,%rbp,2),%eax
mov    0x10(%rsi,%rbp,8),%rdx
mov    %ax,(%rdx,%rbx,2)
movzwl 0x6(%r15,%rbp,2),%eax
mov    0x18(%rsi,%rbp,8),%rdx
mov    %ax,(%rdx,%rbx,2)
add    $0x4,%rbp
cmp    %rbp,%r11
jne    1180 <flip_image+0x80>
test   %r14,%r14
je     1150 <flip_image+0x50>
lea    (%rsi,%rbp,8),%r12
lea    (%r15,%rbp,2),%r15
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzwl (%r15,%rbp,2),%edx
mov    (%r12,%rbp,8),%rax
mov    %dx,(%rax,%rbx,2)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    11e0 <flip_image+0xe0>
jmp    1150 <flip_image+0x50>
test   %rcx,%rcx
mov    -0x18(%rsp),%r12
jle    14ab <flip_image+0x3ab>
mov    %r12d,%eax
and    $0xfffffffe,%eax
cmp    $0x2,%eax
jne    14ab <flip_image+0x3ab>
lea    -0x10(%r8),%rax
mov    %rax,-0x20(%rsp)
mov    %rax,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
lea    -0x1(%r8),%r13
mov    %r8,%r10
and    $0xfffffffffffffff0,%r10
mov    %edx,%r14d
and    $0x3,%r14d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%rdx
mov    %rdx,-0x8(%rsp)
mov    %r8d,%r9d
and    $0x3,%r9d
mov    %r14,-0x10(%rsp)
shl    $0x5,%r14
xor    %r11d,%r11d
jmp    127d <flip_image+0x17d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11
cmp    %rcx,%r11
je     13de <flip_image+0x2de>
test   %r8,%r8
jle    1270 <flip_image+0x170>
mov    (%rsi,%r11,8),%rbp
mov    (%rdi,%r11,8),%rax
cmp    $0x10,%r8
jb     12a9 <flip_image+0x1a9>
lea    0x0(,%r8,2),%rdx
add    %rbp,%rdx
cmp    %rdx,%rax
jae    131d <flip_image+0x21d>
lea    (%rax,%r8,2),%rdx
cmp    %rdx,%rbp
jae    131d <flip_image+0x21d>
xor    %r12d,%r12d
mov    %r13,%rdx
sub    %r12,%rdx
test   %r9,%r9
je     12d5 <flip_image+0x1d5>
mov    %r9,%rbx
nopw   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%r12,2),%r15d
mov    %r15w,(%rax,%r12,2)
add    $0x1,%r12
add    $0xffffffffffffffff,%rbx
jne    12c0 <flip_image+0x1c0>
cmp    $0x3,%rdx
jb     1270 <flip_image+0x170>
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%r12,2),%edx
mov    %dx,(%rax,%r12,2)
movzwl 0x2(%rbp,%r12,2),%edx
mov    %dx,0x2(%rax,%r12,2)
movzwl 0x4(%rbp,%r12,2),%edx
mov    %dx,0x4(%rax,%r12,2)
movzwl 0x6(%rbp,%r12,2),%edx
mov    %dx,0x6(%rax,%r12,2)
add    $0x4,%r12
cmp    %r12,%r8
jne    12e0 <flip_image+0x1e0>
jmp    1270 <flip_image+0x170>
cmpq   $0x30,-0x20(%rsp)
jae    1329 <flip_image+0x229>
xor    %ebx,%ebx
jmp    1389 <flip_image+0x289>
mov    -0x8(%rsp),%rdx
xor    %ebx,%ebx
movups 0x0(%rbp,%rbx,2),%xmm0
movups 0x10(%rbp,%rbx,2),%xmm1
movups %xmm0,(%rax,%rbx,2)
movups %xmm1,0x10(%rax,%rbx,2)
movups 0x20(%rbp,%rbx,2),%xmm0
movups 0x30(%rbp,%rbx,2),%xmm1
movups %xmm0,0x20(%rax,%rbx,2)
movups %xmm1,0x30(%rax,%rbx,2)
movups 0x40(%rbp,%rbx,2),%xmm0
movups 0x50(%rbp,%rbx,2),%xmm1
movups %xmm0,0x40(%rax,%rbx,2)
movups %xmm1,0x50(%rax,%rbx,2)
movups 0x60(%rbp,%rbx,2),%xmm0
movups 0x70(%rbp,%rbx,2),%xmm1
movups %xmm0,0x60(%rax,%rbx,2)
movups %xmm1,0x70(%rax,%rbx,2)
add    $0x40,%rbx
add    $0xfffffffffffffffc,%rdx
jne    1330 <flip_image+0x230>
cmpq   $0x0,-0x10(%rsp)
je     13cd <flip_image+0x2cd>
lea    (%rax,%rbx,2),%r12
add    $0x10,%r12
lea    0x10(,%rbx,2),%rbx
add    %rbp,%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,-0x10(%r12,%rdx,1)
movups %xmm1,(%r12,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r14
jne    13b0 <flip_image+0x2b0>
mov    %r10,%r12
cmp    %r8,%r10
je     1270 <flip_image+0x170>
jmp    12ac <flip_image+0x1ac>
test   %rcx,%rcx
mov    -0x18(%rsp),%r12
jle    14ab <flip_image+0x3ab>
mov    %r8d,%r11d
and    $0x3,%r11d
mov    %r8,%r10
and    $0xfffffffffffffffc,%r10
xor    %r9d,%r9d
jmp    140d <flip_image+0x30d>
nop
add    $0x1,%r9
cmp    %rcx,%r9
je     14ab <flip_image+0x3ab>
test   %r8,%r8
jle    1400 <flip_image+0x300>
mov    %r9,%rbp
not    %rbp
add    %r8,%rbp
mov    (%rdi,%r9,8),%r14
xor    %edx,%edx
cmp    $0x3,%r13
jb     1473 <flip_image+0x373>
nopw   0x0(%rax,%rax,1)
movzwl (%r14,%rdx,2),%eax
mov    (%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
movzwl 0x2(%r14,%rdx,2),%eax
mov    0x8(%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
movzwl 0x4(%r14,%rdx,2),%eax
mov    0x10(%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
movzwl 0x6(%r14,%rdx,2),%eax
mov    0x18(%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    1430 <flip_image+0x330>
test   %r11,%r11
je     1400 <flip_image+0x300>
lea    (%rsi,%rdx,8),%r15
lea    (%r14,%rdx,2),%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzwl (%r14,%rbx,2),%eax
mov    (%r15,%rbx,8),%rdx
mov    %ax,(%rdx,%rbp,2)
add    $0x1,%rbx
cmp    %rbx,%r11
jne    1490 <flip_image+0x390>
jmp    1400 <flip_image+0x300>
cmp    $0x5,%r12d
je     188a <flip_image+0x78a>
cmp    $0x4,%r12d
je     168e <flip_image+0x58e>
cmp    $0x3,%r12d
jne    1d1b <flip_image+0xc1b>
test   %rcx,%rcx
jle    1d1b <flip_image+0xc1b>
lea    -0x10(%r8),%rax
mov    %rax,-0x20(%rsp)
mov    %rax,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
lea    -0x1(%r8),%r12
mov    %r8,%r15
and    $0xfffffffffffffff0,%r15
mov    %edx,%r13d
and    $0x3,%r13d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%rdx
mov    %rdx,-0x18(%rsp)
mov    %r8d,%r9d
and    $0x3,%r9d
mov    %r13,-0x10(%rsp)
shl    $0x5,%r13
xor    %r11d,%r11d
jmp    152d <flip_image+0x42d>
nop
add    $0x1,%r11
cmp    %rcx,%r11
je     1c4e <flip_image+0xb4e>
test   %r8,%r8
jle    1520 <flip_image+0x420>
mov    (%rsi,%r11,8),%rbp
mov    (%rdi,%r11,8),%rdx
cmp    $0x10,%r8
jb     1559 <flip_image+0x459>
lea    0x0(,%r8,2),%rax
add    %rbp,%rax
cmp    %rax,%rdx
jae    15c5 <flip_image+0x4c5>
lea    (%rdx,%r8,2),%rax
cmp    %rax,%rbp
jae    15c5 <flip_image+0x4c5>
xor    %ebx,%ebx
mov    %r12,%r14
sub    %rbx,%r14
test   %r9,%r9
je     1585 <flip_image+0x485>
mov    %r9,%rax
nopl   0x0(%rax)
movzwl 0x0(%rbp,%rbx,2),%r10d
mov    %r10w,(%rdx,%rbx,2)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1570 <flip_image+0x470>
cmp    $0x3,%r14
jb     1520 <flip_image+0x420>
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%rbx,2),%eax
mov    %ax,(%rdx,%rbx,2)
movzwl 0x2(%rbp,%rbx,2),%eax
mov    %ax,0x2(%rdx,%rbx,2)
movzwl 0x4(%rbp,%rbx,2),%eax
mov    %ax,0x4(%rdx,%rbx,2)
movzwl 0x6(%rbp,%rbx,2),%eax
mov    %ax,0x6(%rdx,%rbx,2)
add    $0x4,%rbx
cmp    %rbx,%r8
jne    1590 <flip_image+0x490>
jmp    1520 <flip_image+0x420>
cmpq   $0x30,-0x20(%rsp)
jae    15d1 <flip_image+0x4d1>
xor    %ebx,%ebx
jmp    1639 <flip_image+0x539>
mov    -0x18(%rsp),%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rbx,2),%xmm0
movups 0x10(%rbp,%rbx,2),%xmm1
movups %xmm0,(%rdx,%rbx,2)
movups %xmm1,0x10(%rdx,%rbx,2)
movups 0x20(%rbp,%rbx,2),%xmm0
movups 0x30(%rbp,%rbx,2),%xmm1
movups %xmm0,0x20(%rdx,%rbx,2)
movups %xmm1,0x30(%rdx,%rbx,2)
movups 0x40(%rbp,%rbx,2),%xmm0
movups 0x50(%rbp,%rbx,2),%xmm1
movups %xmm0,0x40(%rdx,%rbx,2)
movups %xmm1,0x50(%rdx,%rbx,2)
movups 0x60(%rbp,%rbx,2),%xmm0
movups 0x70(%rbp,%rbx,2),%xmm1
movups %xmm0,0x60(%rdx,%rbx,2)
movups %xmm1,0x70(%rdx,%rbx,2)
add    $0x40,%rbx
add    $0xfffffffffffffffc,%r14
jne    15e0 <flip_image+0x4e0>
cmpq   $0x0,-0x10(%rsp)
je     167d <flip_image+0x57d>
lea    (%rdx,%rbx,2),%r14
add    $0x10,%r14
lea    0x10(,%rbx,2),%rbx
add    %rbp,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rbx,%rax,1),%xmm0
movups (%rbx,%rax,1),%xmm1
movups %xmm0,-0x10(%r14,%rax,1)
movups %xmm1,(%r14,%rax,1)
add    $0x20,%rax
cmp    %rax,%r13
jne    1660 <flip_image+0x560>
mov    %r15,%rbx
cmp    %r8,%r15
je     1520 <flip_image+0x420>
jmp    155b <flip_image+0x45b>
mov    %r8,%rax
shr    $0x3f,%rax
add    %r8,%rax
sar    %rax
mov    %rax,-0x20(%rsp)
test   %eax,%eax
jle    1790 <flip_image+0x690>
mov    -0x20(%rsp),%r14d
lea    -0x1(%rcx),%r11
mov    %ecx,%r15d
and    $0x3,%r15d
mov    %rcx,%r10
and    $0xfffffffffffffffc,%r10
xor    %r13d,%r13d
jmp    16dd <flip_image+0x5dd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
cmp    %r14,%r13
je     1790 <flip_image+0x690>
test   %rcx,%rcx
jle    16d0 <flip_image+0x5d0>
mov    %r13,%rbp
not    %rbp
add    %r8,%rbp
xor    %eax,%eax
cmp    $0x3,%r11
jb     1753 <flip_image+0x653>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi,%rax,8),%rbx
movzwl (%rbx,%r13,2),%ebx
mov    (%rsi,%rax,8),%rdx
mov    %bx,(%rdx,%rbp,2)
mov    0x8(%rdi,%rax,8),%rdx
movzwl (%rdx,%r13,2),%edx
mov    0x8(%rsi,%rax,8),%rbx
mov    %dx,(%rbx,%rbp,2)
mov    0x10(%rdi,%rax,8),%rdx
movzwl (%rdx,%r13,2),%edx
mov    0x10(%rsi,%rax,8),%rbx
mov    %dx,(%rbx,%rbp,2)
mov    0x18(%rdi,%rax,8),%rdx
movzwl (%rdx,%r13,2),%edx
mov    0x18(%rsi,%rax,8),%rbx
mov    %dx,(%rbx,%rbp,2)
add    $0x4,%rax
cmp    %rax,%r10
jne    1700 <flip_image+0x600>
test   %r15,%r15
je     16d0 <flip_image+0x5d0>
lea    (%rsi,%rax,8),%r12
lea    (%rdi,%rax,8),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rbx,8),%rdx
movzwl (%rdx,%r13,2),%edx
mov    (%r12,%rbx,8),%r9
mov    %dx,(%r9,%rbp,2)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1770 <flip_image+0x670>
jmp    16d0 <flip_image+0x5d0>
movslq -0x20(%rsp),%r15
cmp    %r8,%r15
jge    187f <flip_image+0x77f>
lea    -0x1(%rcx),%r9
mov    %ecx,%r11d
and    $0x3,%r11d
mov    %rcx,%r10
and    $0xfffffffffffffffc,%r10
jmp    17cd <flip_image+0x6cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
cmp    %r8,%r15
jge    187f <flip_image+0x77f>
test   %rcx,%rcx
jle    17c0 <flip_image+0x6c0>
mov    %r15,%rax
not    %rax
add    %r8,%rax
xor    %ebx,%ebx
cmp    $0x3,%r9
jb     1847 <flip_image+0x747>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi,%rbx,8),%rbp
movzwl 0x0(%rbp,%r15,2),%ebp
mov    (%rsi,%rbx,8),%rdx
mov    %bp,(%rdx,%rax,2)
mov    0x8(%rdi,%rbx,8),%rdx
movzwl (%rdx,%r15,2),%edx
mov    0x8(%rsi,%rbx,8),%rbp
mov    %dx,0x0(%rbp,%rax,2)
mov    0x10(%rdi,%rbx,8),%rdx
movzwl (%rdx,%r15,2),%edx
mov    0x10(%rsi,%rbx,8),%rbp
mov    %dx,0x0(%rbp,%rax,2)
mov    0x18(%rdi,%rbx,8),%rdx
movzwl (%rdx,%r15,2),%edx
mov    0x18(%rsi,%rbx,8),%rbp
mov    %dx,0x0(%rbp,%rax,2)
add    $0x4,%rbx
cmp    %rbx,%r10
jne    17f0 <flip_image+0x6f0>
test   %r11,%r11
je     17c0 <flip_image+0x6c0>
lea    (%rsi,%rbx,8),%r14
lea    (%rdi,%rbx,8),%r12
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbp,8),%rdx
movzwl (%rdx,%r15,2),%edx
mov    (%r14,%rbp,8),%rbx
mov    %dx,(%rbx,%rax,2)
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1860 <flip_image+0x760>
jmp    17c0 <flip_image+0x6c0>
cmpl   $0x5,-0x18(%rsp)
jne    1d1b <flip_image+0xc1b>
mov    %rcx,%r12
shr    $0x3f,%r12
add    %rcx,%r12
sar    %r12
test   %r12d,%r12d
jle    1a81 <flip_image+0x981>
mov    %r12d,%r13d
lea    -0x10(%r8),%rax
mov    %rax,-0x20(%rsp)
mov    %rax,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %r8,%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,-0x10(%rsp)
mov    %edx,%r11d
and    $0x3,%r11d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%rdx
mov    %rdx,-0x8(%rsp)
mov    %r8d,%r14d
and    $0x3,%r14d
mov    %r11,-0x18(%rsp)
shl    $0x5,%r11
xor    %r10d,%r10d
jmp    190d <flip_image+0x80d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    %r13,%r10
je     1a81 <flip_image+0x981>
test   %r8,%r8
jle    1900 <flip_image+0x800>
mov    %r10,%rax
not    %rax
add    %rcx,%rax
mov    (%rdi,%r10,8),%rbp
mov    (%rsi,%rax,8),%r9
cmp    $0x10,%r8
jb     1946 <flip_image+0x846>
lea    0x0(,%r8,2),%rax
add    %rbp,%rax
cmp    %rax,%r9
jae    19bd <flip_image+0x8bd>
lea    (%r9,%r8,2),%rax
cmp    %rax,%rbp
jae    19bd <flip_image+0x8bd>
xor    %r15d,%r15d
mov    %r15,%rax
not    %rax
add    %r8,%rax
test   %r14,%r14
je     1975 <flip_image+0x875>
mov    %r14,%rbx
nopw   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%r15,2),%edx
mov    %dx,(%r9,%r15,2)
add    $0x1,%r15
add    $0xffffffffffffffff,%rbx
jne    1960 <flip_image+0x860>
cmp    $0x3,%rax
jb     1900 <flip_image+0x800>
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%r15,2),%eax
mov    %ax,(%r9,%r15,2)
movzwl 0x2(%rbp,%r15,2),%eax
mov    %ax,0x2(%r9,%r15,2)
movzwl 0x4(%rbp,%r15,2),%eax
mov    %ax,0x4(%r9,%r15,2)
movzwl 0x6(%rbp,%r15,2),%eax
mov    %ax,0x6(%r9,%r15,2)
add    $0x4,%r15
cmp    %r15,%r8
jne    1980 <flip_image+0x880>
jmp    1900 <flip_image+0x800>
cmpq   $0x30,-0x20(%rsp)
jae    19c9 <flip_image+0x8c9>
xor    %ebx,%ebx
jmp    1a31 <flip_image+0x931>
mov    -0x8(%rsp),%rax
xor    %ebx,%ebx
movups 0x0(%rbp,%rbx,2),%xmm0
movups 0x10(%rbp,%rbx,2),%xmm1
movups %xmm0,(%r9,%rbx,2)
movups %xmm1,0x10(%r9,%rbx,2)
movups 0x20(%rbp,%rbx,2),%xmm0
movups 0x30(%rbp,%rbx,2),%xmm1
movups %xmm0,0x20(%r9,%rbx,2)
movups %xmm1,0x30(%r9,%rbx,2)
movups 0x40(%rbp,%rbx,2),%xmm0
movups 0x50(%rbp,%rbx,2),%xmm1
movups %xmm0,0x40(%r9,%rbx,2)
movups %xmm1,0x50(%r9,%rbx,2)
movups 0x60(%rbp,%rbx,2),%xmm0
movups 0x70(%rbp,%rbx,2),%xmm1
movups %xmm0,0x60(%r9,%rbx,2)
movups %xmm1,0x70(%r9,%rbx,2)
add    $0x40,%rbx
add    $0xfffffffffffffffc,%rax
jne    19d0 <flip_image+0x8d0>
cmpq   $0x0,-0x18(%rsp)
je     1a6b <flip_image+0x96b>
lea    (%r9,%rbx,2),%rax
add    $0x10,%rax
lea    0x10(,%rbx,2),%rbx
add    %rbp,%rbx
xor    %edx,%edx
xchg   %ax,%ax
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,-0x10(%rax,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r11
jne    1a50 <flip_image+0x950>
mov    -0x10(%rsp),%rax
mov    %rax,%r15
cmp    %r8,%rax
je     1900 <flip_image+0x800>
jmp    1949 <flip_image+0x849>
movslq %r12d,%r13
cmp    %rcx,%r13
jge    1d1b <flip_image+0xc1b>
lea    -0x10(%r8),%r11
mov    %r11,-0x20(%rsp)
shr    $0x4,%r11
add    $0x1,%r11
mov    %r8,%r15
and    $0xfffffffffffffff0,%r15
mov    %r11d,%r12d
and    $0x3,%r12d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r11
mov    %r8d,%r10d
and    $0x3,%r10d
mov    %r12,-0x10(%rsp)
shl    $0x5,%r12
jmp    1add <flip_image+0x9dd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %rcx,%r13
jge    1d1b <flip_image+0xc1b>
test   %r8,%r8
jle    1ad0 <flip_image+0x9d0>
mov    %r13,%rax
not    %rax
add    %rcx,%rax
mov    (%rdi,%r13,8),%rbx
mov    (%rsi,%rax,8),%rbp
cmp    $0x10,%r8
jb     1b16 <flip_image+0xa16>
lea    (%rbx,%r8,2),%rax
cmp    %rax,%rbp
jae    1b85 <flip_image+0xa85>
lea    0x0(,%r8,2),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1b85 <flip_image+0xa85>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r8,%rax
test   %r10,%r10
je     1b45 <flip_image+0xa45>
mov    %r10,%r9
nopl   0x0(%rax)
movzwl (%rbx,%rdx,2),%r14d
mov    %r14w,0x0(%rbp,%rdx,2)
add    $0x1,%rdx
add    $0xffffffffffffffff,%r9
jne    1b30 <flip_image+0xa30>
cmp    $0x3,%rax
jb     1ad0 <flip_image+0x9d0>
nopl   0x0(%rax,%rax,1)
movzwl (%rbx,%rdx,2),%eax
mov    %ax,0x0(%rbp,%rdx,2)
movzwl 0x2(%rbx,%rdx,2),%eax
mov    %ax,0x2(%rbp,%rdx,2)
movzwl 0x4(%rbx,%rdx,2),%eax
mov    %ax,0x4(%rbp,%rdx,2)
movzwl 0x6(%rbx,%rdx,2),%eax
mov    %ax,0x6(%rbp,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%r8
jne    1b50 <flip_image+0xa50>
jmp    1ad0 <flip_image+0x9d0>
cmpq   $0x30,-0x20(%rsp)
jae    1b91 <flip_image+0xa91>
xor    %edx,%edx
jmp    1bf9 <flip_image+0xaf9>
mov    %r11,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rdx,2),%xmm0
movups 0x10(%rbx,%rdx,2),%xmm1
movups %xmm0,0x0(%rbp,%rdx,2)
movups %xmm1,0x10(%rbp,%rdx,2)
movups 0x20(%rbx,%rdx,2),%xmm0
movups 0x30(%rbx,%rdx,2),%xmm1
movups %xmm0,0x20(%rbp,%rdx,2)
movups %xmm1,0x30(%rbp,%rdx,2)
movups 0x40(%rbx,%rdx,2),%xmm0
movups 0x50(%rbx,%rdx,2),%xmm1
movups %xmm0,0x40(%rbp,%rdx,2)
movups %xmm1,0x50(%rbp,%rdx,2)
movups 0x60(%rbx,%rdx,2),%xmm0
movups 0x70(%rbx,%rdx,2),%xmm1
movups %xmm0,0x60(%rbp,%rdx,2)
movups %xmm1,0x70(%rbp,%rdx,2)
add    $0x40,%rdx
add    $0xfffffffffffffffc,%rax
jne    1ba0 <flip_image+0xaa0>
cmpq   $0x0,-0x10(%rsp)
je     1c3d <flip_image+0xb3d>
lea    0x10(,%rdx,2),%r9
add    %rbp,%r9
lea    (%rbx,%rdx,2),%rdx
add    $0x10,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdx,%rax,1),%xmm0
movups (%rdx,%rax,1),%xmm1
movups %xmm0,-0x10(%r9,%rax,1)
movups %xmm1,(%r9,%rax,1)
add    $0x20,%rax
cmp    %rax,%r12
jne    1c20 <flip_image+0xb20>
mov    %r15,%rdx
cmp    %r8,%r15
je     1ad0 <flip_image+0x9d0>
jmp    1b18 <flip_image+0xa18>
test   %rcx,%rcx
jle    1d1b <flip_image+0xc1b>
mov    %r8d,%r11d
and    $0x3,%r11d
mov    %r8,%r10
and    $0xfffffffffffffffc,%r10
xor    %r9d,%r9d
jmp    1c7d <flip_image+0xb7d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
cmp    %rcx,%r9
je     1d1b <flip_image+0xc1b>
test   %r8,%r8
jle    1c70 <flip_image+0xb70>
mov    %r9,%rbp
not    %rbp
add    %r8,%rbp
mov    (%rdi,%r9,8),%r14
xor    %edx,%edx
cmp    $0x3,%r12
jb     1ce3 <flip_image+0xbe3>
nopw   0x0(%rax,%rax,1)
movzwl (%r14,%rdx,2),%eax
mov    (%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
movzwl 0x2(%r14,%rdx,2),%eax
mov    0x8(%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
movzwl 0x4(%r14,%rdx,2),%eax
mov    0x10(%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
movzwl 0x6(%r14,%rdx,2),%eax
mov    0x18(%rsi,%rdx,8),%rbx
mov    %ax,(%rbx,%rbp,2)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    1ca0 <flip_image+0xba0>
test   %r11,%r11
je     1c70 <flip_image+0xb70>
lea    (%rsi,%rdx,8),%r15
lea    (%r14,%rdx,2),%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzwl (%r14,%rbx,2),%eax
mov    (%r15,%rbx,8),%rdx
mov    %ax,(%rdx,%rbp,2)
add    $0x1,%rbx
cmp    %rbx,%r11
jne    1d00 <flip_image+0xc00>
jmp    1c70 <flip_image+0xb70>
mov    $0x1,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @flip_image(i16** %0, i16** %1, i32 %2, i64 %3, i64 %4) {
%6 = alloca i16**
%7 = alloca i16**
%8 = alloca i32
%9 = alloca i64
%10 = alloca i64
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store i16** %0, i16*** %6
store i16** %1, i16*** %7
store i32 %2, i32* %8
store i64 %3, i64* %9
store i64 %4, i64* %10
%15 = load i32, i32* %8
%16 = icmp ne i32 %15, 1
br i1 %16, label %17, label %30
17: ; preds = %5
%18 = load i32, i32* %8
%19 = icmp ne i32 %18, 2
br i1 %19, label %20, label %30
20: ; preds = %17
%21 = load i32, i32* %8
%22 = icmp ne i32 %21, 3
br i1 %22, label %23, label %30
23: ; preds = %20
%24 = load i32, i32* %8
%25 = icmp ne i32 %24, 4
br i1 %25, label %26, label %30
26: ; preds = %23
%27 = load i32, i32* %8
%28 = icmp ne i32 %27, 5
br i1 %28, label %29, label %30
29: ; preds = %26
store i32 1, i32* %8
br label %30
30: ; preds = %29, %26, %23, %20, %17, %5
%31 = load i32, i32* %8
%32 = icmp eq i32 %31, 1
br i1 %32, label %39, label %33
33: ; preds = %30
%34 = load i32, i32* %8
%35 = icmp eq i32 %34, 2
br i1 %35, label %39, label %36
36: ; preds = %33
%37 = load i32, i32* %8
%38 = icmp eq i32 %37, 3
br i1 %38, label %39, label %80
39: ; preds = %36, %33, %30
store i32 0, i32* %12
br label %40
40: ; preds = %76, %39
%41 = load i32, i32* %12
%42 = sext i32 %41 to i64
%43 = load i64, i64* %9
%44 = icmp slt i64 %42, %43
br i1 %44, label %45, label %79
45: ; preds = %40
store i32 0, i32* %13
br label %46
46: ; preds = %72, %45
%47 = load i32, i32* %13
%48 = sext i32 %47 to i64
%49 = load i64, i64* %10
%50 = icmp slt i64 %48, %49
br i1 %50, label %51, label %75
51: ; preds = %46
%52 = load i16**, i16*** %6
%53 = load i32, i32* %12
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i16*, i16** %52, i64 %54
%56 = load i16*, i16** %55
%57 = load i32, i32* %13
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i16, i16* %56, i64 %58
%60 = load i16, i16* %59
%61 = load i16**, i16*** %7
%62 = load i32, i32* %13
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i16*, i16** %61, i64 %63
%65 = load i16*, i16** %64
%66 = load i64, i64* %10
%67 = sub nsw i64 %66, 1
%68 = load i32, i32* %12
%69 = sext i32 %68 to i64
%70 = sub nsw i64 %67, %69
%71 = getelementptr inbounds i16, i16* %65, i64 %70
store i16 %60, i16* %71
br label %72
72: ; preds = %51
%73 = load i32, i32* %13
%74 = add nsw i32 %73, 1
store i32 %74, i32* %13
br label %46
75: ; preds = %46
br label %76
76: ; preds = %75
%77 = load i32, i32* %12
%78 = add nsw i32 %77, 1
store i32 %78, i32* %12
br label %40
79: ; preds = %40
br label %80
80: ; preds = %79, %36
%81 = load i32, i32* %8
%82 = icmp eq i32 %81, 2
br i1 %82, label %86, label %83
83: ; preds = %80
%84 = load i32, i32* %8
%85 = icmp eq i32 %84, 3
br i1 %85, label %86, label %164
86: ; preds = %83, %80
store i32 0, i32* %12
br label %87
87: ; preds = %120, %86
%88 = load i32, i32* %12
%89 = sext i32 %88 to i64
%90 = load i64, i64* %9
%91 = icmp slt i64 %89, %90
br i1 %91, label %92, label %123
92: ; preds = %87
store i32 0, i32* %13
br label %93
93: ; preds = %116, %92
%94 = load i32, i32* %13
%95 = sext i32 %94 to i64
%96 = load i64, i64* %10
%97 = icmp slt i64 %95, %96
br i1 %97, label %98, label %119
98: ; preds = %93
%99 = load i16**, i16*** %7
%100 = load i32, i32* %12
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i16*, i16** %99, i64 %101
%103 = load i16*, i16** %102
%104 = load i32, i32* %13
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i16, i16* %103, i64 %105
%107 = load i16, i16* %106
%108 = load i16**, i16*** %6
%109 = load i32, i32* %12
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i16*, i16** %108, i64 %110
%112 = load i16*, i16** %111
%113 = load i32, i32* %13
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i16, i16* %112, i64 %114
store i16 %107, i16* %115
br label %116
116: ; preds = %98
%117 = load i32, i32* %13
%118 = add nsw i32 %117, 1
store i32 %118, i32* %13
br label %93
119: ; preds = %93
br label %120
120: ; preds = %119
%121 = load i32, i32* %12
%122 = add nsw i32 %121, 1
store i32 %122, i32* %12
br label %87
123: ; preds = %87
store i32 0, i32* %12
br label %124
124: ; preds = %160, %123
%125 = load i32, i32* %12
%126 = sext i32 %125 to i64
%127 = load i64, i64* %9
%128 = icmp slt i64 %126, %127
br i1 %128, label %129, label %163
129: ; preds = %124
store i32 0, i32* %13
br label %130
130: ; preds = %156, %129
%131 = load i32, i32* %13
%132 = sext i32 %131 to i64
%133 = load i64, i64* %10
%134 = icmp slt i64 %132, %133
br i1 %134, label %135, label %159
135: ; preds = %130
%136 = load i16**, i16*** %6
%137 = load i32, i32* %12
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i16*, i16** %136, i64 %138
%140 = load i16*, i16** %139
%141 = load i32, i32* %13
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i16, i16* %140, i64 %142
%144 = load i16, i16* %143
%145 = load i16**, i16*** %7
%146 = load i32, i32* %13
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i16*, i16** %145, i64 %147
%149 = load i16*, i16** %148
%150 = load i64, i64* %10
%151 = sub nsw i64 %150, 1
%152 = load i32, i32* %12
%153 = sext i32 %152 to i64
%154 = sub nsw i64 %151, %153
%155 = getelementptr inbounds i16, i16* %149, i64 %154
store i16 %144, i16* %155
br label %156
156: ; preds = %135
%157 = load i32, i32* %13
%158 = add nsw i32 %157, 1
store i32 %158, i32* %13
br label %130
159: ; preds = %130
br label %160
160: ; preds = %159
%161 = load i32, i32* %12
%162 = add nsw i32 %161, 1
store i32 %162, i32* %12
br label %124
163: ; preds = %124
br label %164
164: ; preds = %163, %83
%165 = load i32, i32* %8
%166 = icmp eq i32 %165, 3
br i1 %166, label %167, label %245
167: ; preds = %164
store i32 0, i32* %12
br label %168
168: ; preds = %201, %167
%169 = load i32, i32* %12
%170 = sext i32 %169 to i64
%171 = load i64, i64* %9
%172 = icmp slt i64 %170, %171
br i1 %172, label %173, label %204
173: ; preds = %168
store i32 0, i32* %13
br label %174
174: ; preds = %197, %173
%175 = load i32, i32* %13
%176 = sext i32 %175 to i64
%177 = load i64, i64* %10
%178 = icmp slt i64 %176, %177
br i1 %178, label %179, label %200
179: ; preds = %174
%180 = load i16**, i16*** %7
%181 = load i32, i32* %12
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i16*, i16** %180, i64 %182
%184 = load i16*, i16** %183
%185 = load i32, i32* %13
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i16, i16* %184, i64 %186
%188 = load i16, i16* %187
%189 = load i16**, i16*** %6
%190 = load i32, i32* %12
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i16*, i16** %189, i64 %191
%193 = load i16*, i16** %192
%194 = load i32, i32* %13
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i16, i16* %193, i64 %195
store i16 %188, i16* %196
br label %197
197: ; preds = %179
%198 = load i32, i32* %13
%199 = add nsw i32 %198, 1
store i32 %199, i32* %13
br label %174
200: ; preds = %174
br label %201
201: ; preds = %200
%202 = load i32, i32* %12
%203 = add nsw i32 %202, 1
store i32 %203, i32* %12
br label %168
204: ; preds = %168
store i32 0, i32* %12
br label %205
205: ; preds = %241, %204
%206 = load i32, i32* %12
%207 = sext i32 %206 to i64
%208 = load i64, i64* %9
%209 = icmp slt i64 %207, %208
br i1 %209, label %210, label %244
210: ; preds = %205
store i32 0, i32* %13
br label %211
211: ; preds = %237, %210
%212 = load i32, i32* %13
%213 = sext i32 %212 to i64
%214 = load i64, i64* %10
%215 = icmp slt i64 %213, %214
br i1 %215, label %216, label %240
216: ; preds = %211
%217 = load i16**, i16*** %6
%218 = load i32, i32* %12
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i16*, i16** %217, i64 %219
%221 = load i16*, i16** %220
%222 = load i32, i32* %13
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i16, i16* %221, i64 %223
%225 = load i16, i16* %224
%226 = load i16**, i16*** %7
%227 = load i32, i32* %13
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i16*, i16** %226, i64 %228
%230 = load i16*, i16** %229
%231 = load i64, i64* %10
%232 = sub nsw i64 %231, 1
%233 = load i32, i32* %12
%234 = sext i32 %233 to i64
%235 = sub nsw i64 %232, %234
%236 = getelementptr inbounds i16, i16* %230, i64 %235
store i16 %225, i16* %236
br label %237
237: ; preds = %216
%238 = load i32, i32* %13
%239 = add nsw i32 %238, 1
store i32 %239, i32* %13
br label %211
240: ; preds = %211
br label %241
241: ; preds = %240
%242 = load i32, i32* %12
%243 = add nsw i32 %242, 1
store i32 %243, i32* %12
br label %205
244: ; preds = %205
br label %245
245: ; preds = %244, %164
%246 = load i32, i32* %8
%247 = icmp eq i32 %246, 4
br i1 %247, label %248, label %332
248: ; preds = %245
%249 = load i64, i64* %10
%250 = sdiv i64 %249, 2
%251 = trunc i64 %250 to i32
store i32 %251, i32* %11
store i32 0, i32* %13
br label %252
252: ; preds = %287, %248
%253 = load i32, i32* %13
%254 = load i32, i32* %11
%255 = icmp slt i32 %253, %254
br i1 %255, label %256, label %290
256: ; preds = %252
store i32 0, i32* %12
br label %257
257: ; preds = %283, %256
%258 = load i32, i32* %12
%259 = sext i32 %258 to i64
%260 = load i64, i64* %9
%261 = icmp slt i64 %259, %260
br i1 %261, label %262, label %286
262: ; preds = %257
%263 = load i16**, i16*** %6
%264 = load i32, i32* %12
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i16*, i16** %263, i64 %265
%267 = load i16*, i16** %266
%268 = load i32, i32* %13
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i16, i16* %267, i64 %269
%271 = load i16, i16* %270
%272 = load i16**, i16*** %7
%273 = load i32, i32* %12
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i16*, i16** %272, i64 %274
%276 = load i16*, i16** %275
%277 = load i64, i64* %10
%278 = sub nsw i64 %277, 1
%279 = load i32, i32* %13
%280 = sext i32 %279 to i64
%281 = sub nsw i64 %278, %280
%282 = getelementptr inbounds i16, i16* %276, i64 %281
store i16 %271, i16* %282
br label %283
283: ; preds = %262
%284 = load i32, i32* %12
%285 = add nsw i32 %284, 1
store i32 %285, i32* %12
br label %257
286: ; preds = %257
br label %287
287: ; preds = %286
%288 = load i32, i32* %13
%289 = add nsw i32 %288, 1
store i32 %289, i32* %13
br label %252
290: ; preds = %252
%291 = load i32, i32* %11
store i32 %291, i32* %13
br label %292
292: ; preds = %328, %290
%293 = load i32, i32* %13
%294 = sext i32 %293 to i64
%295 = load i64, i64* %10
%296 = icmp slt i64 %294, %295
br i1 %296, label %297, label %331
297: ; preds = %292
store i32 0, i32* %12
br label %298
298: ; preds = %324, %297
%299 = load i32, i32* %12
%300 = sext i32 %299 to i64
%301 = load i64, i64* %9
%302 = icmp slt i64 %300, %301
br i1 %302, label %303, label %327
303: ; preds = %298
%304 = load i16**, i16*** %6
%305 = load i32, i32* %12
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds i16*, i16** %304, i64 %306
%308 = load i16*, i16** %307
%309 = load i32, i32* %13
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds i16, i16* %308, i64 %310
%312 = load i16, i16* %311
%313 = load i16**, i16*** %7
%314 = load i32, i32* %12
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i16*, i16** %313, i64 %315
%317 = load i16*, i16** %316
%318 = load i64, i64* %10
%319 = sub nsw i64 %318, 1
%320 = load i32, i32* %13
%321 = sext i32 %320 to i64
%322 = sub nsw i64 %319, %321
%323 = getelementptr inbounds i16, i16* %317, i64 %322
store i16 %312, i16* %323
br label %324
324: ; preds = %303
%325 = load i32, i32* %12
%326 = add nsw i32 %325, 1
store i32 %326, i32* %12
br label %298
327: ; preds = %298
br label %328
328: ; preds = %327
%329 = load i32, i32* %13
%330 = add nsw i32 %329, 1
store i32 %330, i32* %13
br label %292
331: ; preds = %292
br label %332
332: ; preds = %331, %245
%333 = load i32, i32* %8
%334 = icmp eq i32 %333, 5
br i1 %334, label %335, label %419
335: ; preds = %332
%336 = load i64, i64* %9
%337 = sdiv i64 %336, 2
%338 = trunc i64 %337 to i32
store i32 %338, i32* %14
store i32 0, i32* %12
br label %339
339: ; preds = %374, %335
%340 = load i32, i32* %12
%341 = load i32, i32* %14
%342 = icmp slt i32 %340, %341
br i1 %342, label %343, label %377
343: ; preds = %339
store i32 0, i32* %13
br label %344
344: ; preds = %370, %343
%345 = load i32, i32* %13
%346 = sext i32 %345 to i64
%347 = load i64, i64* %10
%348 = icmp slt i64 %346, %347
br i1 %348, label %349, label %373
349: ; preds = %344
%350 = load i16**, i16*** %6
%351 = load i32, i32* %12
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i16*, i16** %350, i64 %352
%354 = load i16*, i16** %353
%355 = load i32, i32* %13
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i16, i16* %354, i64 %356
%358 = load i16, i16* %357
%359 = load i16**, i16*** %7
%360 = load i64, i64* %9
%361 = sub nsw i64 %360, 1
%362 = load i32, i32* %12
%363 = sext i32 %362 to i64
%364 = sub nsw i64 %361, %363
%365 = getelementptr inbounds i16*, i16** %359, i64 %364
%366 = load i16*, i16** %365
%367 = load i32, i32* %13
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds i16, i16* %366, i64 %368
store i16 %358, i16* %369
br label %370
370: ; preds = %349
%371 = load i32, i32* %13
%372 = add nsw i32 %371, 1
store i32 %372, i32* %13
br label %344
373: ; preds = %344
br label %374
374: ; preds = %373
%375 = load i32, i32* %12
%376 = add nsw i32 %375, 1
store i32 %376, i32* %12
br label %339
377: ; preds = %339
%378 = load i32, i32* %14
store i32 %378, i32* %12
br label %379
379: ; preds = %415, %377
%380 = load i32, i32* %12
%381 = sext i32 %380 to i64
%382 = load i64, i64* %9
%383 = icmp slt i64 %381, %382
br i1 %383, label %384, label %418
384: ; preds = %379
store i32 0, i32* %13
br label %385
385: ; preds = %411, %384
%386 = load i32, i32* %13
%387 = sext i32 %386 to i64
%388 = load i64, i64* %10
%389 = icmp slt i64 %387, %388
br i1 %389, label %390, label %414
390: ; preds = %385
%391 = load i16**, i16*** %6
%392 = load i32, i32* %12
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds i16*, i16** %391, i64 %393
%395 = load i16*, i16** %394
%396 = load i32, i32* %13
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i16, i16* %395, i64 %397
%399 = load i16, i16* %398
%400 = load i16**, i16*** %7
%401 = load i64, i64* %9
%402 = sub nsw i64 %401, 1
%403 = load i32, i32* %12
%404 = sext i32 %403 to i64
%405 = sub nsw i64 %402, %404
%406 = getelementptr inbounds i16*, i16** %400, i64 %405
%407 = load i16*, i16** %406
%408 = load i32, i32* %13
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i16, i16* %407, i64 %409
store i16 %399, i16* %410
br label %411
411: ; preds = %390
%412 = load i32, i32* %13
%413 = add nsw i32 %412, 1
store i32 %413, i32* %13
br label %385
414: ; preds = %385
br label %415
415: ; preds = %414
%416 = load i32, i32* %12
%417 = add nsw i32 %416, 1
store i32 %417, i32* %12
br label %379
418: ; preds = %379
br label %419
419: ; preds = %418, %332
ret i32 1
}

LLVM IR (-O2):
define i32 @flip_image(i16** nocapture %0, i16** nocapture %1, i32 %2, i64 %3, i64 %4) {
%6 = add i32 %2, -6
%7 = icmp ult i32 %6, -5
%8 = select i1 %7, i32 1, i32 %2
%9 = add nsw i32 %8, -1
%10 = icmp ult i32 %9, 3
%11 = icmp sgt i64 %3, 0
%12 = and i1 %10, %11
br i1 %12, label %13, label %72
13: ; preds = %5
%14 = icmp sgt i64 %4, 0
%15 = add i64 %4, -1
%16 = and i64 %4, 3
%17 = icmp ult i64 %15, 3
%18 = and i64 %4, -4
%19 = icmp eq i64 %16, 0
br label %20
20: ; preds = %13, %69
%21 = phi i64 [ 0, %13 ], [ %70, %69 ]
br i1 %14, label %22, label %69
22: ; preds = %20
%23 = getelementptr inbounds i16*, i16** %0, i64 %21
%24 = load i16*, i16** %23
%25 = xor i64 %21, -1
%26 = add i64 %25, %4
br i1 %17, label %56, label %27
27: ; preds = %22, %27
%28 = phi i64 [ %53, %27 ], [ 0, %22 ]
%29 = phi i64 [ %54, %27 ], [ 0, %22 ]
%30 = getelementptr inbounds i16, i16* %24, i64 %28
%31 = load i16, i16* %30
%32 = getelementptr inbounds i16*, i16** %1, i64 %28
%33 = load i16*, i16** %32
%34 = getelementptr inbounds i16, i16* %33, i64 %26
store i16 %31, i16* %34
%35 = or i64 %28, 1
%36 = getelementptr inbounds i16, i16* %24, i64 %35
%37 = load i16, i16* %36
%38 = getelementptr inbounds i16*, i16** %1, i64 %35
%39 = load i16*, i16** %38
%40 = getelementptr inbounds i16, i16* %39, i64 %26
store i16 %37, i16* %40
%41 = or i64 %28, 2
%42 = getelementptr inbounds i16, i16* %24, i64 %41
%43 = load i16, i16* %42
%44 = getelementptr inbounds i16*, i16** %1, i64 %41
%45 = load i16*, i16** %44
%46 = getelementptr inbounds i16, i16* %45, i64 %26
store i16 %43, i16* %46
%47 = or i64 %28, 3
%48 = getelementptr inbounds i16, i16* %24, i64 %47
%49 = load i16, i16* %48
%50 = getelementptr inbounds i16*, i16** %1, i64 %47
%51 = load i16*, i16** %50
%52 = getelementptr inbounds i16, i16* %51, i64 %26
store i16 %49, i16* %52
%53 = add nuw nsw i64 %28, 4
%54 = add i64 %29, 4
%55 = icmp eq i64 %54, %18
br i1 %55, label %56, label %27
56: ; preds = %27, %22
%57 = phi i64 [ 0, %22 ], [ %53, %27 ]
br i1 %19, label %69, label %58
58: ; preds = %56, %58
%59 = phi i64 [ %66, %58 ], [ %57, %56 ]
%60 = phi i64 [ %67, %58 ], [ 0, %56 ]
%61 = getelementptr inbounds i16, i16* %24, i64 %59
%62 = load i16, i16* %61
%63 = getelementptr inbounds i16*, i16** %1, i64 %59
%64 = load i16*, i16** %63
%65 = getelementptr inbounds i16, i16* %64, i64 %26
store i16 %62, i16* %65
%66 = add nuw nsw i64 %59, 1
%67 = add i64 %60, 1
%68 = icmp eq i64 %67, %16
br i1 %68, label %69, label %58
69: ; preds = %56, %58, %20
%70 = add nuw nsw i64 %21, 1
%71 = icmp eq i64 %70, %3
br i1 %71, label %72, label %20
72: ; preds = %69, %5
%73 = and i32 %8, -2
%74 = icmp eq i32 %73, 2
%75 = and i1 %11, %74
br i1 %75, label %76, label %269
76: ; preds = %72
%77 = icmp sgt i64 %4, 0
%78 = add i64 %4, -16
%79 = lshr i64 %78, 4
%80 = add nuw nsw i64 %79, 1
%81 = add i64 %4, -1
%82 = icmp ult i64 %4, 16
%83 = and i64 %4, -16
%84 = and i64 %80, 3
%85 = icmp ult i64 %78, 48
%86 = and i64 %80, 2305843009213693948
%87 = icmp eq i64 %84, 0
%88 = icmp eq i64 %83, %4
%89 = and i64 %4, 3
%90 = icmp eq i64 %89, 0
br label %91
91: ; preds = %76, %214
%92 = phi i64 [ 0, %76 ], [ %215, %214 ]
br i1 %77, label %93, label %214
93: ; preds = %91
%94 = getelementptr inbounds i16*, i16** %1, i64 %92
%95 = load i16*, i16** %94
%96 = getelementptr inbounds i16*, i16** %0, i64 %92
%97 = load i16*, i16** %96
br i1 %82, label %173, label %98
98: ; preds = %93
%99 = getelementptr i16, i16* %97, i64 %4
%100 = getelementptr i16, i16* %95, i64 %4
%101 = icmp ult i16* %97, %100
%102 = icmp ult i16* %95, %99
%103 = and i1 %101, %102
br i1 %103, label %173, label %104
104: ; preds = %98
br i1 %85, label %154, label %105
105: ; preds = %104, %105
%106 = phi i64 [ %151, %105 ], [ 0, %104 ]
%107 = phi i64 [ %152, %105 ], [ 0, %104 ]
%108 = getelementptr inbounds i16, i16* %95, i64 %106
%109 = bitcast i16* %108 to <8 x i16>*
%110 = load <8 x i16>, <8 x i16>* %109
%111 = getelementptr inbounds i16, i16* %108, i64 8
%112 = bitcast i16* %111 to <8 x i16>*
%113 = load <8 x i16>, <8 x i16>* %112
%114 = getelementptr inbounds i16, i16* %97, i64 %106
%115 = bitcast i16* %114 to <8 x i16>*
store <8 x i16> %110, <8 x i16>* %115
%116 = getelementptr inbounds i16, i16* %114, i64 8
%117 = bitcast i16* %116 to <8 x i16>*
store <8 x i16> %113, <8 x i16>* %117
%118 = or i64 %106, 16
%119 = getelementptr inbounds i16, i16* %95, i64 %118
%120 = bitcast i16* %119 to <8 x i16>*
%121 = load <8 x i16>, <8 x i16>* %120
%122 = getelementptr inbounds i16, i16* %119, i64 8
%123 = bitcast i16* %122 to <8 x i16>*
%124 = load <8 x i16>, <8 x i16>* %123
%125 = getelementptr inbounds i16, i16* %97, i64 %118
%126 = bitcast i16* %125 to <8 x i16>*
store <8 x i16> %121, <8 x i16>* %126
%127 = getelementptr inbounds i16, i16* %125, i64 8
%128 = bitcast i16* %127 to <8 x i16>*
store <8 x i16> %124, <8 x i16>* %128
%129 = or i64 %106, 32
%130 = getelementptr inbounds i16, i16* %95, i64 %129
%131 = bitcast i16* %130 to <8 x i16>*
%132 = load <8 x i16>, <8 x i16>* %131
%133 = getelementptr inbounds i16, i16* %130, i64 8
%134 = bitcast i16* %133 to <8 x i16>*
%135 = load <8 x i16>, <8 x i16>* %134
%136 = getelementptr inbounds i16, i16* %97, i64 %129
%137 = bitcast i16* %136 to <8 x i16>*
store <8 x i16> %132, <8 x i16>* %137
%138 = getelementptr inbounds i16, i16* %136, i64 8
%139 = bitcast i16* %138 to <8 x i16>*
store <8 x i16> %135, <8 x i16>* %139
%140 = or i64 %106, 48
%141 = getelementptr inbounds i16, i16* %95, i64 %140
%142 = bitcast i16* %141 to <8 x i16>*
%143 = load <8 x i16>, <8 x i16>* %142
%144 = getelementptr inbounds i16, i16* %141, i64 8
%145 = bitcast i16* %144 to <8 x i16>*
%146 = load <8 x i16>, <8 x i16>* %145
%147 = getelementptr inbounds i16, i16* %97, i64 %140
%148 = bitcast i16* %147 to <8 x i16>*
store <8 x i16> %143, <8 x i16>* %148
%149 = getelementptr inbounds i16, i16* %147, i64 8
%150 = bitcast i16* %149 to <8 x i16>*
store <8 x i16> %146, <8 x i16>* %150
%151 = add nuw i64 %106, 64
%152 = add i64 %107, 4
%153 = icmp eq i64 %152, %86
br i1 %153, label %154, label %105
154: ; preds = %105, %104
%155 = phi i64 [ 0, %104 ], [ %151, %105 ]
br i1 %87, label %172, label %156
156: ; preds = %154, %156
%157 = phi i64 [ %169, %156 ], [ %155, %154 ]
%158 = phi i64 [ %170, %156 ], [ 0, %154 ]
%159 = getelementptr inbounds i16, i16* %95, i64 %157
%160 = bitcast i16* %159 to <8 x i16>*
%161 = load <8 x i16>, <8 x i16>* %160
%162 = getelementptr inbounds i16, i16* %159, i64 8
%163 = bitcast i16* %162 to <8 x i16>*
%164 = load <8 x i16>, <8 x i16>* %163
%165 = getelementptr inbounds i16, i16* %97, i64 %157
%166 = bitcast i16* %165 to <8 x i16>*
store <8 x i16> %161, <8 x i16>* %166
%167 = getelementptr inbounds i16, i16* %165, i64 8
%168 = bitcast i16* %167 to <8 x i16>*
store <8 x i16> %164, <8 x i16>* %168
%169 = add nuw i64 %157, 16
%170 = add i64 %158, 1
%171 = icmp eq i64 %170, %84
br i1 %171, label %172, label %156
172: ; preds = %156, %154
br i1 %88, label %214, label %173
173: ; preds = %98, %93, %172
%174 = phi i64 [ 0, %98 ], [ 0, %93 ], [ %83, %172 ]
%175 = sub i64 %81, %174
br i1 %90, label %185, label %176
176: ; preds = %173, %176
%177 = phi i64 [ %182, %176 ], [ %174, %173 ]
%178 = phi i64 [ %183, %176 ], [ 0, %173 ]
%179 = getelementptr inbounds i16, i16* %95, i64 %177
%180 = load i16, i16* %179
%181 = getelementptr inbounds i16, i16* %97, i64 %177
store i16 %180, i16* %181
%182 = add nuw nsw i64 %177, 1
%183 = add i64 %178, 1
%184 = icmp eq i64 %183, %89
br i1 %184, label %185, label %176
185: ; preds = %176, %173
%186 = phi i64 [ %174, %173 ], [ %182, %176 ]
%187 = icmp ult i64 %175, 3
br i1 %187, label %214, label %195
188: ; preds = %214
br i1 %11, label %189, label %269
189: ; preds = %188
%190 = icmp sgt i64 %4, 0
%191 = and i64 %4, 3
%192 = icmp ult i64 %81, 3
%193 = and i64 %4, -4
%194 = icmp eq i64 %191, 0
br label %217
195: ; preds = %185, %195
%196 = phi i64 [ %212, %195 ], [ %186, %185 ]
%197 = getelementptr inbounds i16, i16* %95, i64 %196
%198 = load i16, i16* %197
%199 = getelementptr inbounds i16, i16* %97, i64 %196
store i16 %198, i16* %199
%200 = add nuw nsw i64 %196, 1
%201 = getelementptr inbounds i16, i16* %95, i64 %200
%202 = load i16, i16* %201
%203 = getelementptr inbounds i16, i16* %97, i64 %200
store i16 %202, i16* %203
%204 = add nuw nsw i64 %196, 2
%205 = getelementptr inbounds i16, i16* %95, i64 %204
%206 = load i16, i16* %205
%207 = getelementptr inbounds i16, i16* %97, i64 %204
store i16 %206, i16* %207
%208 = add nuw nsw i64 %196, 3
%209 = getelementptr inbounds i16, i16* %95, i64 %208
%210 = load i16, i16* %209
%211 = getelementptr inbounds i16, i16* %97, i64 %208
store i16 %210, i16* %211
%212 = add nuw nsw i64 %196, 4
%213 = icmp eq i64 %212, %4
br i1 %213, label %214, label %195
214: ; preds = %185, %195, %172, %91
%215 = add nuw nsw i64 %92, 1
%216 = icmp eq i64 %215, %3
br i1 %216, label %188, label %91
217: ; preds = %189, %266
%218 = phi i64 [ 0, %189 ], [ %267, %266 ]
br i1 %190, label %219, label %266
219: ; preds = %217
%220 = getelementptr inbounds i16*, i16** %0, i64 %218
%221 = load i16*, i16** %220
%222 = xor i64 %218, -1
%223 = add i64 %222, %4
br i1 %192, label %253, label %224
224: ; preds = %219, %224
%225 = phi i64 [ %250, %224 ], [ 0, %219 ]
%226 = phi i64 [ %251, %224 ], [ 0, %219 ]
%227 = getelementptr inbounds i16, i16* %221, i64 %225
%228 = load i16, i16* %227
%229 = getelementptr inbounds i16*, i16** %1, i64 %225
%230 = load i16*, i16** %229
%231 = getelementptr inbounds i16, i16* %230, i64 %223
store i16 %228, i16* %231
%232 = or i64 %225, 1
%233 = getelementptr inbounds i16, i16* %221, i64 %232
%234 = load i16, i16* %233
%235 = getelementptr inbounds i16*, i16** %1, i64 %232
%236 = load i16*, i16** %235
%237 = getelementptr inbounds i16, i16* %236, i64 %223
store i16 %234, i16* %237
%238 = or i64 %225, 2
%239 = getelementptr inbounds i16, i16* %221, i64 %238
%240 = load i16, i16* %239
%241 = getelementptr inbounds i16*, i16** %1, i64 %238
%242 = load i16*, i16** %241
%243 = getelementptr inbounds i16, i16* %242, i64 %223
store i16 %240, i16* %243
%244 = or i64 %225, 3
%245 = getelementptr inbounds i16, i16* %221, i64 %244
%246 = load i16, i16* %245
%247 = getelementptr inbounds i16*, i16** %1, i64 %244
%248 = load i16*, i16** %247
%249 = getelementptr inbounds i16, i16* %248, i64 %223
store i16 %246, i16* %249
%250 = add nuw nsw i64 %225, 4
%251 = add i64 %226, 4
%252 = icmp eq i64 %251, %193
br i1 %252, label %253, label %224
253: ; preds = %224, %219
%254 = phi i64 [ 0, %219 ], [ %250, %224 ]
br i1 %194, label %266, label %255
255: ; preds = %253, %255
%256 = phi i64 [ %263, %255 ], [ %254, %253 ]
%257 = phi i64 [ %264, %255 ], [ 0, %253 ]
%258 = getelementptr inbounds i16, i16* %221, i64 %256
%259 = load i16, i16* %258
%260 = getelementptr inbounds i16*, i16** %1, i64 %256
%261 = load i16*, i16** %260
%262 = getelementptr inbounds i16, i16* %261, i64 %223
store i16 %259, i16* %262
%263 = add nuw nsw i64 %256, 1
%264 = add i64 %257, 1
%265 = icmp eq i64 %264, %191
br i1 %265, label %266, label %255
266: ; preds = %253, %255, %217
%267 = add nuw nsw i64 %218, 1
%268 = icmp eq i64 %267, %3
br i1 %268, label %269, label %217
269: ; preds = %266, %72, %188
switch i32 %8, label %888 [
i32 3, label %270
i32 4, label %464
i32 5, label %607
]
270: ; preds = %269
br i1 %11, label %271, label %888
271: ; preds = %270
%272 = icmp sgt i64 %4, 0
%273 = add i64 %4, -16
%274 = lshr i64 %273, 4
%275 = add nuw nsw i64 %274, 1
%276 = add i64 %4, -1
%277 = icmp ult i64 %4, 16
%278 = and i64 %4, -16
%279 = and i64 %275, 3
%280 = icmp ult i64 %273, 48
%281 = and i64 %275, 2305843009213693948
%282 = icmp eq i64 %279, 0
%283 = icmp eq i64 %278, %4
%284 = and i64 %4, 3
%285 = icmp eq i64 %284, 0
br label %286
286: ; preds = %271, %409
%287 = phi i64 [ 0, %271 ], [ %410, %409 ]
br i1 %272, label %288, label %409
288: ; preds = %286
%289 = getelementptr inbounds i16*, i16** %1, i64 %287
%290 = load i16*, i16** %289
%291 = getelementptr inbounds i16*, i16** %0, i64 %287
%292 = load i16*, i16** %291
br i1 %277, label %368, label %293
293: ; preds = %288
%294 = getelementptr i16, i16* %292, i64 %4
%295 = getelementptr i16, i16* %290, i64 %4
%296 = icmp ult i16* %292, %295
%297 = icmp ult i16* %290, %294
%298 = and i1 %296, %297
br i1 %298, label %368, label %299
299: ; preds = %293
br i1 %280, label %349, label %300
300: ; preds = %299, %300
%301 = phi i64 [ %346, %300 ], [ 0, %299 ]
%302 = phi i64 [ %347, %300 ], [ 0, %299 ]
%303 = getelementptr inbounds i16, i16* %290, i64 %301
%304 = bitcast i16* %303 to <8 x i16>*
%305 = load <8 x i16>, <8 x i16>* %304
%306 = getelementptr inbounds i16, i16* %303, i64 8
%307 = bitcast i16* %306 to <8 x i16>*
%308 = load <8 x i16>, <8 x i16>* %307
%309 = getelementptr inbounds i16, i16* %292, i64 %301
%310 = bitcast i16* %309 to <8 x i16>*
store <8 x i16> %305, <8 x i16>* %310
%311 = getelementptr inbounds i16, i16* %309, i64 8
%312 = bitcast i16* %311 to <8 x i16>*
store <8 x i16> %308, <8 x i16>* %312
%313 = or i64 %301, 16
%314 = getelementptr inbounds i16, i16* %290, i64 %313
%315 = bitcast i16* %314 to <8 x i16>*
%316 = load <8 x i16>, <8 x i16>* %315
%317 = getelementptr inbounds i16, i16* %314, i64 8
%318 = bitcast i16* %317 to <8 x i16>*
%319 = load <8 x i16>, <8 x i16>* %318
%320 = getelementptr inbounds i16, i16* %292, i64 %313
%321 = bitcast i16* %320 to <8 x i16>*
store <8 x i16> %316, <8 x i16>* %321
%322 = getelementptr inbounds i16, i16* %320, i64 8
%323 = bitcast i16* %322 to <8 x i16>*
store <8 x i16> %319, <8 x i16>* %323
%324 = or i64 %301, 32
%325 = getelementptr inbounds i16, i16* %290, i64 %324
%326 = bitcast i16* %325 to <8 x i16>*
%327 = load <8 x i16>, <8 x i16>* %326
%328 = getelementptr inbounds i16, i16* %325, i64 8
%329 = bitcast i16* %328 to <8 x i16>*
%330 = load <8 x i16>, <8 x i16>* %329
%331 = getelementptr inbounds i16, i16* %292, i64 %324
%332 = bitcast i16* %331 to <8 x i16>*
store <8 x i16> %327, <8 x i16>* %332
%333 = getelementptr inbounds i16, i16* %331, i64 8
%334 = bitcast i16* %333 to <8 x i16>*
store <8 x i16> %330, <8 x i16>* %334
%335 = or i64 %301, 48
%336 = getelementptr inbounds i16, i16* %290, i64 %335
%337 = bitcast i16* %336 to <8 x i16>*
%338 = load <8 x i16>, <8 x i16>* %337
%339 = getelementptr inbounds i16, i16* %336, i64 8
%340 = bitcast i16* %339 to <8 x i16>*
%341 = load <8 x i16>, <8 x i16>* %340
%342 = getelementptr inbounds i16, i16* %292, i64 %335
%343 = bitcast i16* %342 to <8 x i16>*
store <8 x i16> %338, <8 x i16>* %343
%344 = getelementptr inbounds i16, i16* %342, i64 8
%345 = bitcast i16* %344 to <8 x i16>*
store <8 x i16> %341, <8 x i16>* %345
%346 = add nuw i64 %301, 64
%347 = add i64 %302, 4
%348 = icmp eq i64 %347, %281
br i1 %348, label %349, label %300
349: ; preds = %300, %299
%350 = phi i64 [ 0, %299 ], [ %346, %300 ]
br i1 %282, label %367, label %351
351: ; preds = %349, %351
%352 = phi i64 [ %364, %351 ], [ %350, %349 ]
%353 = phi i64 [ %365, %351 ], [ 0, %349 ]
%354 = getelementptr inbounds i16, i16* %290, i64 %352
%355 = bitcast i16* %354 to <8 x i16>*
%356 = load <8 x i16>, <8 x i16>* %355
%357 = getelementptr inbounds i16, i16* %354, i64 8
%358 = bitcast i16* %357 to <8 x i16>*
%359 = load <8 x i16>, <8 x i16>* %358
%360 = getelementptr inbounds i16, i16* %292, i64 %352
%361 = bitcast i16* %360 to <8 x i16>*
store <8 x i16> %356, <8 x i16>* %361
%362 = getelementptr inbounds i16, i16* %360, i64 8
%363 = bitcast i16* %362 to <8 x i16>*
store <8 x i16> %359, <8 x i16>* %363
%364 = add nuw i64 %352, 16
%365 = add i64 %353, 1
%366 = icmp eq i64 %365, %279
br i1 %366, label %367, label %351
367: ; preds = %351, %349
br i1 %283, label %409, label %368
368: ; preds = %293, %288, %367
%369 = phi i64 [ 0, %293 ], [ 0, %288 ], [ %278, %367 ]
%370 = sub i64 %276, %369
br i1 %285, label %380, label %371
371: ; preds = %368, %371
%372 = phi i64 [ %377, %371 ], [ %369, %368 ]
%373 = phi i64 [ %378, %371 ], [ 0, %368 ]
%374 = getelementptr inbounds i16, i16* %290, i64 %372
%375 = load i16, i16* %374
%376 = getelementptr inbounds i16, i16* %292, i64 %372
store i16 %375, i16* %376
%377 = add nuw nsw i64 %372, 1
%378 = add i64 %373, 1
%379 = icmp eq i64 %378, %284
br i1 %379, label %380, label %371
380: ; preds = %371, %368
%381 = phi i64 [ %369, %368 ], [ %377, %371 ]
%382 = icmp ult i64 %370, 3
br i1 %382, label %409, label %390
383: ; preds = %409
br i1 %11, label %384, label %888
384: ; preds = %383
%385 = icmp sgt i64 %4, 0
%386 = and i64 %4, 3
%387 = icmp ult i64 %276, 3
%388 = and i64 %4, -4
%389 = icmp eq i64 %386, 0
br label %412
390: ; preds = %380, %390
%391 = phi i64 [ %407, %390 ], [ %381, %380 ]
%392 = getelementptr inbounds i16, i16* %290, i64 %391
%393 = load i16, i16* %392
%394 = getelementptr inbounds i16, i16* %292, i64 %391
store i16 %393, i16* %394
%395 = add nuw nsw i64 %391, 1
%396 = getelementptr inbounds i16, i16* %290, i64 %395
%397 = load i16, i16* %396
%398 = getelementptr inbounds i16, i16* %292, i64 %395
store i16 %397, i16* %398
%399 = add nuw nsw i64 %391, 2
%400 = getelementptr inbounds i16, i16* %290, i64 %399
%401 = load i16, i16* %400
%402 = getelementptr inbounds i16, i16* %292, i64 %399
store i16 %401, i16* %402
%403 = add nuw nsw i64 %391, 3
%404 = getelementptr inbounds i16, i16* %290, i64 %403
%405 = load i16, i16* %404
%406 = getelementptr inbounds i16, i16* %292, i64 %403
store i16 %405, i16* %406
%407 = add nuw nsw i64 %391, 4
%408 = icmp eq i64 %407, %4
br i1 %408, label %409, label %390
409: ; preds = %380, %390, %367, %286
%410 = add nuw nsw i64 %287, 1
%411 = icmp eq i64 %410, %3
br i1 %411, label %383, label %286
412: ; preds = %384, %461
%413 = phi i64 [ 0, %384 ], [ %462, %461 ]
br i1 %385, label %414, label %461
414: ; preds = %412
%415 = getelementptr inbounds i16*, i16** %0, i64 %413
%416 = load i16*, i16** %415
%417 = xor i64 %413, -1
%418 = add i64 %417, %4
br i1 %387, label %448, label %419
419: ; preds = %414, %419
%420 = phi i64 [ %445, %419 ], [ 0, %414 ]
%421 = phi i64 [ %446, %419 ], [ 0, %414 ]
%422 = getelementptr inbounds i16, i16* %416, i64 %420
%423 = load i16, i16* %422
%424 = getelementptr inbounds i16*, i16** %1, i64 %420
%425 = load i16*, i16** %424
%426 = getelementptr inbounds i16, i16* %425, i64 %418
store i16 %423, i16* %426
%427 = or i64 %420, 1
%428 = getelementptr inbounds i16, i16* %416, i64 %427
%429 = load i16, i16* %428
%430 = getelementptr inbounds i16*, i16** %1, i64 %427
%431 = load i16*, i16** %430
%432 = getelementptr inbounds i16, i16* %431, i64 %418
store i16 %429, i16* %432
%433 = or i64 %420, 2
%434 = getelementptr inbounds i16, i16* %416, i64 %433
%435 = load i16, i16* %434
%436 = getelementptr inbounds i16*, i16** %1, i64 %433
%437 = load i16*, i16** %436
%438 = getelementptr inbounds i16, i16* %437, i64 %418
store i16 %435, i16* %438
%439 = or i64 %420, 3
%440 = getelementptr inbounds i16, i16* %416, i64 %439
%441 = load i16, i16* %440
%442 = getelementptr inbounds i16*, i16** %1, i64 %439
%443 = load i16*, i16** %442
%444 = getelementptr inbounds i16, i16* %443, i64 %418
store i16 %441, i16* %444
%445 = add nuw nsw i64 %420, 4
%446 = add i64 %421, 4
%447 = icmp eq i64 %446, %388
br i1 %447, label %448, label %419
448: ; preds = %419, %414
%449 = phi i64 [ 0, %414 ], [ %445, %419 ]
br i1 %389, label %461, label %450
450: ; preds = %448, %450
%451 = phi i64 [ %458, %450 ], [ %449, %448 ]
%452 = phi i64 [ %459, %450 ], [ 0, %448 ]
%453 = getelementptr inbounds i16, i16* %416, i64 %451
%454 = load i16, i16* %453
%455 = getelementptr inbounds i16*, i16** %1, i64 %451
%456 = load i16*, i16** %455
%457 = getelementptr inbounds i16, i16* %456, i64 %418
store i16 %454, i16* %457
%458 = add nuw nsw i64 %451, 1
%459 = add i64 %452, 1
%460 = icmp eq i64 %459, %386
br i1 %460, label %461, label %450
461: ; preds = %448, %450, %412
%462 = add nuw nsw i64 %413, 1
%463 = icmp eq i64 %462, %3
br i1 %463, label %888, label %412
464: ; preds = %269
%465 = sdiv i64 %4, 2
%466 = trunc i64 %465 to i32
%467 = icmp sgt i32 %466, 0
br i1 %467, label %468, label %480
468: ; preds = %464
%469 = and i64 %465, 4294967295
%470 = add i64 %3, -1
%471 = and i64 %3, 3
%472 = icmp ult i64 %470, 3
%473 = and i64 %3, -4
%474 = icmp eq i64 %471, 0
br label %475
475: ; preds = %468, %542
%476 = phi i64 [ 0, %468 ], [ %543, %542 ]
br i1 %11, label %477, label %542
477: ; preds = %475
%478 = xor i64 %476, -1
%479 = add i64 %478, %4
br i1 %472, label %527, label %490
480: ; preds = %542, %464
%481 = shl i64 %465, 32
%482 = ashr exact i64 %481, 32
%483 = icmp slt i64 %482, %4
br i1 %483, label %484, label %605
484: ; preds = %480
%485 = add i64 %3, -1
%486 = and i64 %3, 3
%487 = icmp ult i64 %485, 3
%488 = and i64 %3, -4
%489 = icmp eq i64 %486, 0
br label %545
490: ; preds = %477, %490
%491 = phi i64 [ %524, %490 ], [ 0, %477 ]
%492 = phi i64 [ %525, %490 ], [ 0, %477 ]
%493 = getelementptr inbounds i16*, i16** %0, i64 %491
%494 = load i16*, i16** %493
%495 = getelementptr inbounds i16, i16* %494, i64 %476
%496 = load i16, i16* %495
%497 = getelementptr inbounds i16*, i16** %1, i64 %491
%498 = load i16*, i16** %497
%499 = getelementptr inbounds i16, i16* %498, i64 %479
store i16 %496, i16* %499
%500 = or i64 %491, 1
%501 = getelementptr inbounds i16*, i16** %0, i64 %500
%502 = load i16*, i16** %501
%503 = getelementptr inbounds i16, i16* %502, i64 %476
%504 = load i16, i16* %503
%505 = getelementptr inbounds i16*, i16** %1, i64 %500
%506 = load i16*, i16** %505
%507 = getelementptr inbounds i16, i16* %506, i64 %479
store i16 %504, i16* %507
%508 = or i64 %491, 2
%509 = getelementptr inbounds i16*, i16** %0, i64 %508
%510 = load i16*, i16** %509
%511 = getelementptr inbounds i16, i16* %510, i64 %476
%512 = load i16, i16* %511
%513 = getelementptr inbounds i16*, i16** %1, i64 %508
%514 = load i16*, i16** %513
%515 = getelementptr inbounds i16, i16* %514, i64 %479
store i16 %512, i16* %515
%516 = or i64 %491, 3
%517 = getelementptr inbounds i16*, i16** %0, i64 %516
%518 = load i16*, i16** %517
%519 = getelementptr inbounds i16, i16* %518, i64 %476
%520 = load i16, i16* %519
%521 = getelementptr inbounds i16*, i16** %1, i64 %516
%522 = load i16*, i16** %521
%523 = getelementptr inbounds i16, i16* %522, i64 %479
store i16 %520, i16* %523
%524 = add nuw nsw i64 %491, 4
%525 = add i64 %492, 4
%526 = icmp eq i64 %525, %473
br i1 %526, label %527, label %490
527: ; preds = %490, %477
%528 = phi i64 [ 0, %477 ], [ %524, %490 ]
br i1 %474, label %542, label %529
529: ; preds = %527, %529
%530 = phi i64 [ %539, %529 ], [ %528, %527 ]
%531 = phi i64 [ %540, %529 ], [ 0, %527 ]
%532 = getelementptr inbounds i16*, i16** %0, i64 %530
%533 = load i16*, i16** %532
%534 = getelementptr inbounds i16, i16* %533, i64 %476
%535 = load i16, i16* %534
%536 = getelementptr inbounds i16*, i16** %1, i64 %530
%537 = load i16*, i16** %536
%538 = getelementptr inbounds i16, i16* %537, i64 %479
store i16 %535, i16* %538
%539 = add nuw nsw i64 %530, 1
%540 = add i64 %531, 1
%541 = icmp eq i64 %540, %471
br i1 %541, label %542, label %529
542: ; preds = %527, %529, %475
%543 = add nuw nsw i64 %476, 1
%544 = icmp eq i64 %543, %469
br i1 %544, label %480, label %475
545: ; preds = %484, %602
%546 = phi i64 [ %603, %602 ], [ %482, %484 ]
br i1 %11, label %547, label %602
547: ; preds = %545
%548 = xor i64 %546, -1
%549 = add i64 %548, %4
br i1 %487, label %587, label %550
550: ; preds = %547, %550
%551 = phi i64 [ %584, %550 ], [ 0, %547 ]
%552 = phi i64 [ %585, %550 ], [ 0, %547 ]
%553 = getelementptr inbounds i16*, i16** %0, i64 %551
%554 = load i16*, i16** %553
%555 = getelementptr inbounds i16, i16* %554, i64 %546
%556 = load i16, i16* %555
%557 = getelementptr inbounds i16*, i16** %1, i64 %551
%558 = load i16*, i16** %557
%559 = getelementptr inbounds i16, i16* %558, i64 %549
store i16 %556, i16* %559
%560 = or i64 %551, 1
%561 = getelementptr inbounds i16*, i16** %0, i64 %560
%562 = load i16*, i16** %561
%563 = getelementptr inbounds i16, i16* %562, i64 %546
%564 = load i16, i16* %563
%565 = getelementptr inbounds i16*, i16** %1, i64 %560
%566 = load i16*, i16** %565
%567 = getelementptr inbounds i16, i16* %566, i64 %549
store i16 %564, i16* %567
%568 = or i64 %551, 2
%569 = getelementptr inbounds i16*, i16** %0, i64 %568
%570 = load i16*, i16** %569
%571 = getelementptr inbounds i16, i16* %570, i64 %546
%572 = load i16, i16* %571
%573 = getelementptr inbounds i16*, i16** %1, i64 %568
%574 = load i16*, i16** %573
%575 = getelementptr inbounds i16, i16* %574, i64 %549
store i16 %572, i16* %575
%576 = or i64 %551, 3
%577 = getelementptr inbounds i16*, i16** %0, i64 %576
%578 = load i16*, i16** %577
%579 = getelementptr inbounds i16, i16* %578, i64 %546
%580 = load i16, i16* %579
%581 = getelementptr inbounds i16*, i16** %1, i64 %576
%582 = load i16*, i16** %581
%583 = getelementptr inbounds i16, i16* %582, i64 %549
store i16 %580, i16* %583
%584 = add nuw nsw i64 %551, 4
%585 = add i64 %552, 4
%586 = icmp eq i64 %585, %488
br i1 %586, label %587, label %550
587: ; preds = %550, %547
%588 = phi i64 [ 0, %547 ], [ %584, %550 ]
br i1 %489, label %602, label %589
589: ; preds = %587, %589
%590 = phi i64 [ %599, %589 ], [ %588, %587 ]
%591 = phi i64 [ %600, %589 ], [ 0, %587 ]
%592 = getelementptr inbounds i16*, i16** %0, i64 %590
%593 = load i16*, i16** %592
%594 = getelementptr inbounds i16, i16* %593, i64 %546
%595 = load i16, i16* %594
%596 = getelementptr inbounds i16*, i16** %1, i64 %590
%597 = load i16*, i16** %596
%598 = getelementptr inbounds i16, i16* %597, i64 %549
store i16 %595, i16* %598
%599 = add nuw nsw i64 %590, 1
%600 = add i64 %591, 1
%601 = icmp eq i64 %600, %486
br i1 %601, label %602, label %589
602: ; preds = %587, %589, %545
%603 = add i64 %546, 1
%604 = icmp slt i64 %603, %4
br i1 %604, label %545, label %605
605: ; preds = %602, %480
%606 = icmp eq i32 %8, 5
br i1 %606, label %607, label %888
607: ; preds = %269, %605
%608 = sdiv i64 %3, 2
%609 = trunc i64 %608 to i32
%610 = icmp sgt i32 %609, 0
br i1 %610, label %611, label %726
611: ; preds = %607
%612 = icmp sgt i64 %4, 0
%613 = and i64 %608, 4294967295
%614 = add i64 %4, -16
%615 = lshr i64 %614, 4
%616 = add nuw nsw i64 %615, 1
%617 = icmp ult i64 %4, 16
%618 = and i64 %4, -16
%619 = and i64 %616, 3
%620 = icmp ult i64 %614, 48
%621 = and i64 %616, 2305843009213693948
%622 = icmp eq i64 %619, 0
%623 = icmp eq i64 %618, %4
%624 = and i64 %4, 3
%625 = icmp eq i64 %624, 0
br label %626
626: ; preds = %611, %763
%627 = phi i64 [ 0, %611 ], [ %764, %763 ]
br i1 %612, label %628, label %763
628: ; preds = %626
%629 = getelementptr inbounds i16*, i16** %0, i64 %627
%630 = load i16*, i16** %629
%631 = xor i64 %627, -1
%632 = add i64 %631, %3
%633 = getelementptr inbounds i16*, i16** %1, i64 %632
%634 = load i16*, i16** %633
br i1 %617, label %710, label %635
635: ; preds = %628
%636 = getelementptr i16, i16* %634, i64 %4
%637 = getelementptr i16, i16* %630, i64 %4
%638 = icmp ult i16* %634, %637
%639 = icmp ult i16* %630, %636
%640 = and i1 %638, %639
br i1 %640, label %710, label %641
641: ; preds = %635
br i1 %620, label %691, label %642
642: ; preds = %641, %642
%643 = phi i64 [ %688, %642 ], [ 0, %641 ]
%644 = phi i64 [ %689, %642 ], [ 0, %641 ]
%645 = getelementptr inbounds i16, i16* %630, i64 %643
%646 = bitcast i16* %645 to <8 x i16>*
%647 = load <8 x i16>, <8 x i16>* %646
%648 = getelementptr inbounds i16, i16* %645, i64 8
%649 = bitcast i16* %648 to <8 x i16>*
%650 = load <8 x i16>, <8 x i16>* %649
%651 = getelementptr inbounds i16, i16* %634, i64 %643
%652 = bitcast i16* %651 to <8 x i16>*
store <8 x i16> %647, <8 x i16>* %652
%653 = getelementptr inbounds i16, i16* %651, i64 8
%654 = bitcast i16* %653 to <8 x i16>*
store <8 x i16> %650, <8 x i16>* %654
%655 = or i64 %643, 16
%656 = getelementptr inbounds i16, i16* %630, i64 %655
%657 = bitcast i16* %656 to <8 x i16>*
%658 = load <8 x i16>, <8 x i16>* %657
%659 = getelementptr inbounds i16, i16* %656, i64 8
%660 = bitcast i16* %659 to <8 x i16>*
%661 = load <8 x i16>, <8 x i16>* %660
%662 = getelementptr inbounds i16, i16* %634, i64 %655
%663 = bitcast i16* %662 to <8 x i16>*
store <8 x i16> %658, <8 x i16>* %663
%664 = getelementptr inbounds i16, i16* %662, i64 8
%665 = bitcast i16* %664 to <8 x i16>*
store <8 x i16> %661, <8 x i16>* %665
%666 = or i64 %643, 32
%667 = getelementptr inbounds i16, i16* %630, i64 %666
%668 = bitcast i16* %667 to <8 x i16>*
%669 = load <8 x i16>, <8 x i16>* %668
%670 = getelementptr inbounds i16, i16* %667, i64 8
%671 = bitcast i16* %670 to <8 x i16>*
%672 = load <8 x i16>, <8 x i16>* %671
%673 = getelementptr inbounds i16, i16* %634, i64 %666
%674 = bitcast i16* %673 to <8 x i16>*
store <8 x i16> %669, <8 x i16>* %674
%675 = getelementptr inbounds i16, i16* %673, i64 8
%676 = bitcast i16* %675 to <8 x i16>*
store <8 x i16> %672, <8 x i16>* %676
%677 = or i64 %643, 48
%678 = getelementptr inbounds i16, i16* %630, i64 %677
%679 = bitcast i16* %678 to <8 x i16>*
%680 = load <8 x i16>, <8 x i16>* %679
%681 = getelementptr inbounds i16, i16* %678, i64 8
%682 = bitcast i16* %681 to <8 x i16>*
%683 = load <8 x i16>, <8 x i16>* %682
%684 = getelementptr inbounds i16, i16* %634, i64 %677
%685 = bitcast i16* %684 to <8 x i16>*
store <8 x i16> %680, <8 x i16>* %685
%686 = getelementptr inbounds i16, i16* %684, i64 8
%687 = bitcast i16* %686 to <8 x i16>*
store <8 x i16> %683, <8 x i16>* %687
%688 = add nuw i64 %643, 64
%689 = add i64 %644, 4
%690 = icmp eq i64 %689, %621
br i1 %690, label %691, label %642
691: ; preds = %642, %641
%692 = phi i64 [ 0, %641 ], [ %688, %642 ]
br i1 %622, label %709, label %693
693: ; preds = %691, %693
%694 = phi i64 [ %706, %693 ], [ %692, %691 ]
%695 = phi i64 [ %707, %693 ], [ 0, %691 ]
%696 = getelementptr inbounds i16, i16* %630, i64 %694
%697 = bitcast i16* %696 to <8 x i16>*
%698 = load <8 x i16>, <8 x i16>* %697
%699 = getelementptr inbounds i16, i16* %696, i64 8
%700 = bitcast i16* %699 to <8 x i16>*
%701 = load <8 x i16>, <8 x i16>* %700
%702 = getelementptr inbounds i16, i16* %634, i64 %694
%703 = bitcast i16* %702 to <8 x i16>*
store <8 x i16> %698, <8 x i16>* %703
%704 = getelementptr inbounds i16, i16* %702, i64 8
%705 = bitcast i16* %704 to <8 x i16>*
store <8 x i16> %701, <8 x i16>* %705
%706 = add nuw i64 %694, 16
%707 = add i64 %695, 1
%708 = icmp eq i64 %707, %619
br i1 %708, label %709, label %693
709: ; preds = %693, %691
br i1 %623, label %763, label %710
710: ; preds = %635, %628, %709
%711 = phi i64 [ 0, %635 ], [ 0, %628 ], [ %618, %709 ]
%712 = xor i64 %711, -1
%713 = add i64 %712, %4
br i1 %625, label %723, label %714
714: ; preds = %710, %714
%715 = phi i64 [ %720, %714 ], [ %711, %710 ]
%716 = phi i64 [ %721, %714 ], [ 0, %710 ]
%717 = getelementptr inbounds i16, i16* %630, i64 %715
%718 = load i16, i16* %717
%719 = getelementptr inbounds i16, i16* %634, i64 %715
store i16 %718, i16* %719
%720 = add nuw nsw i64 %715, 1
%721 = add i64 %716, 1
%722 = icmp eq i64 %721, %624
br i1 %722, label %723, label %714
723: ; preds = %714, %710
%724 = phi i64 [ %711, %710 ], [ %720, %714 ]
%725 = icmp ult i64 %713, 3
br i1 %725, label %763, label %744
726: ; preds = %763, %607
%727 = shl i64 %608, 32
%728 = ashr exact i64 %727, 32
%729 = icmp slt i64 %728, %3
br i1 %729, label %730, label %888
730: ; preds = %726
%731 = icmp sgt i64 %4, 0
%732 = add i64 %4, -16
%733 = lshr i64 %732, 4
%734 = add nuw nsw i64 %733, 1
%735 = icmp ult i64 %4, 16
%736 = and i64 %4, -16
%737 = and i64 %734, 3
%738 = icmp ult i64 %732, 48
%739 = and i64 %734, 2305843009213693948
%740 = icmp eq i64 %737, 0
%741 = icmp eq i64 %736, %4
%742 = and i64 %4, 3
%743 = icmp eq i64 %742, 0
br label %766
744: ; preds = %723, %744
%745 = phi i64 [ %761, %744 ], [ %724, %723 ]
%746 = getelementptr inbounds i16, i16* %630, i64 %745
%747 = load i16, i16* %746
%748 = getelementptr inbounds i16, i16* %634, i64 %745
store i16 %747, i16* %748
%749 = add nuw nsw i64 %745, 1
%750 = getelementptr inbounds i16, i16* %630, i64 %749
%751 = load i16, i16* %750
%752 = getelementptr inbounds i16, i16* %634, i64 %749
store i16 %751, i16* %752
%753 = add nuw nsw i64 %745, 2
%754 = getelementptr inbounds i16, i16* %630, i64 %753
%755 = load i16, i16* %754
%756 = getelementptr inbounds i16, i16* %634, i64 %753
store i16 %755, i16* %756
%757 = add nuw nsw i64 %745, 3
%758 = getelementptr inbounds i16, i16* %630, i64 %757
%759 = load i16, i16* %758
%760 = getelementptr inbounds i16, i16* %634, i64 %757
store i16 %759, i16* %760
%761 = add nuw nsw i64 %745, 4
%762 = icmp eq i64 %761, %4
br i1 %762, label %763, label %744
763: ; preds = %723, %744, %709, %626
%764 = add nuw nsw i64 %627, 1
%765 = icmp eq i64 %764, %613
br i1 %765, label %726, label %626
766: ; preds = %730, %885
%767 = phi i64 [ %728, %730 ], [ %886, %885 ]
br i1 %731, label %768, label %885
768: ; preds = %766
%769 = getelementptr inbounds i16*, i16** %0, i64 %767
%770 = load i16*, i16** %769
%771 = xor i64 %767, -1
%772 = add i64 %771, %3
%773 = getelementptr inbounds i16*, i16** %1, i64 %772
%774 = load i16*, i16** %773
br i1 %735, label %850, label %775
775: ; preds = %768
%776 = getelementptr i16, i16* %774, i64 %4
%777 = getelementptr i16, i16* %770, i64 %4
%778 = icmp ult i16* %774, %777
%779 = icmp ult i16* %770, %776
%780 = and i1 %778, %779
br i1 %780, label %850, label %781
781: ; preds = %775
br i1 %738, label %831, label %782
782: ; preds = %781, %782
%783 = phi i64 [ %828, %782 ], [ 0, %781 ]
%784 = phi i64 [ %829, %782 ], [ 0, %781 ]
%785 = getelementptr inbounds i16, i16* %770, i64 %783
%786 = bitcast i16* %785 to <8 x i16>*
%787 = load <8 x i16>, <8 x i16>* %786
%788 = getelementptr inbounds i16, i16* %785, i64 8
%789 = bitcast i16* %788 to <8 x i16>*
%790 = load <8 x i16>, <8 x i16>* %789
%791 = getelementptr inbounds i16, i16* %774, i64 %783
%792 = bitcast i16* %791 to <8 x i16>*
store <8 x i16> %787, <8 x i16>* %792
%793 = getelementptr inbounds i16, i16* %791, i64 8
%794 = bitcast i16* %793 to <8 x i16>*
store <8 x i16> %790, <8 x i16>* %794
%795 = or i64 %783, 16
%796 = getelementptr inbounds i16, i16* %770, i64 %795
%797 = bitcast i16* %796 to <8 x i16>*
%798 = load <8 x i16>, <8 x i16>* %797
%799 = getelementptr inbounds i16, i16* %796, i64 8
%800 = bitcast i16* %799 to <8 x i16>*
%801 = load <8 x i16>, <8 x i16>* %800
%802 = getelementptr inbounds i16, i16* %774, i64 %795
%803 = bitcast i16* %802 to <8 x i16>*
store <8 x i16> %798, <8 x i16>* %803
%804 = getelementptr inbounds i16, i16* %802, i64 8
%805 = bitcast i16* %804 to <8 x i16>*
store <8 x i16> %801, <8 x i16>* %805
%806 = or i64 %783, 32
%807 = getelementptr inbounds i16, i16* %770, i64 %806
%808 = bitcast i16* %807 to <8 x i16>*
%809 = load <8 x i16>, <8 x i16>* %808
%810 = getelementptr inbounds i16, i16* %807, i64 8
%811 = bitcast i16* %810 to <8 x i16>*
%812 = load <8 x i16>, <8 x i16>* %811
%813 = getelementptr inbounds i16, i16* %774, i64 %806
%814 = bitcast i16* %813 to <8 x i16>*
store <8 x i16> %809, <8 x i16>* %814
%815 = getelementptr inbounds i16, i16* %813, i64 8
%816 = bitcast i16* %815 to <8 x i16>*
store <8 x i16> %812, <8 x i16>* %816
%817 = or i64 %783, 48
%818 = getelementptr inbounds i16, i16* %770, i64 %817
%819 = bitcast i16* %818 to <8 x i16>*
%820 = load <8 x i16>, <8 x i16>* %819
%821 = getelementptr inbounds i16, i16* %818, i64 8
%822 = bitcast i16* %821 to <8 x i16>*
%823 = load <8 x i16>, <8 x i16>* %822
%824 = getelementptr inbounds i16, i16* %774, i64 %817
%825 = bitcast i16* %824 to <8 x i16>*
store <8 x i16> %820, <8 x i16>* %825
%826 = getelementptr inbounds i16, i16* %824, i64 8
%827 = bitcast i16* %826 to <8 x i16>*
store <8 x i16> %823, <8 x i16>* %827
%828 = add nuw i64 %783, 64
%829 = add i64 %784, 4
%830 = icmp eq i64 %829, %739
br i1 %830, label %831, label %782
831: ; preds = %782, %781
%832 = phi i64 [ 0, %781 ], [ %828, %782 ]
br i1 %740, label %849, label %833
833: ; preds = %831, %833
%834 = phi i64 [ %846, %833 ], [ %832, %831 ]
%835 = phi i64 [ %847, %833 ], [ 0, %831 ]
%836 = getelementptr inbounds i16, i16* %770, i64 %834
%837 = bitcast i16* %836 to <8 x i16>*
%838 = load <8 x i16>, <8 x i16>* %837
%839 = getelementptr inbounds i16, i16* %836, i64 8
%840 = bitcast i16* %839 to <8 x i16>*
%841 = load <8 x i16>, <8 x i16>* %840
%842 = getelementptr inbounds i16, i16* %774, i64 %834
%843 = bitcast i16* %842 to <8 x i16>*
store <8 x i16> %838, <8 x i16>* %843
%844 = getelementptr inbounds i16, i16* %842, i64 8
%845 = bitcast i16* %844 to <8 x i16>*
store <8 x i16> %841, <8 x i16>* %845
%846 = add nuw i64 %834, 16
%847 = add i64 %835, 1
%848 = icmp eq i64 %847, %737
br i1 %848, label %849, label %833
849: ; preds = %833, %831
br i1 %741, label %885, label %850
850: ; preds = %775, %768, %849
%851 = phi i64 [ 0, %775 ], [ 0, %768 ], [ %736, %849 ]
%852 = xor i64 %851, -1
%853 = add i64 %852, %4
br i1 %743, label %863, label %854
854: ; preds = %850, %854
%855 = phi i64 [ %860, %854 ], [ %851, %850 ]
%856 = phi i64 [ %861, %854 ], [ 0, %850 ]
%857 = getelementptr inbounds i16, i16* %770, i64 %855
%858 = load i16, i16* %857
%859 = getelementptr inbounds i16, i16* %774, i64 %855
store i16 %858, i16* %859
%860 = add nuw nsw i64 %855, 1
%861 = add i64 %856, 1
%862 = icmp eq i64 %861, %742
br i1 %862, label %863, label %854
863: ; preds = %854, %850
%864 = phi i64 [ %851, %850 ], [ %860, %854 ]
%865 = icmp ult i64 %853, 3
br i1 %865, label %885, label %866
866: ; preds = %863, %866
%867 = phi i64 [ %883, %866 ], [ %864, %863 ]
%868 = getelementptr inbounds i16, i16* %770, i64 %867
%869 = load i16, i16* %868
%870 = getelementptr inbounds i16, i16* %774, i64 %867
store i16 %869, i16* %870
%871 = add nuw nsw i64 %867, 1
%872 = getelementptr inbounds i16, i16* %770, i64 %871
%873 = load i16, i16* %872
%874 = getelementptr inbounds i16, i16* %774, i64 %871
store i16 %873, i16* %874
%875 = add nuw nsw i64 %867, 2
%876 = getelementptr inbounds i16, i16* %770, i64 %875
%877 = load i16, i16* %876
%878 = getelementptr inbounds i16, i16* %774, i64 %875
store i16 %877, i16* %878
%879 = add nuw nsw i64 %867, 3
%880 = getelementptr inbounds i16, i16* %770, i64 %879
%881 = load i16, i16* %880
%882 = getelementptr inbounds i16, i16* %774, i64 %879
store i16 %881, i16* %882
%883 = add nuw nsw i64 %867, 4
%884 = icmp eq i64 %883, %4
br i1 %884, label %885, label %866
885: ; preds = %863, %866, %849, %766
%886 = add i64 %767, 1
%887 = icmp slt i64 %886, %3
br i1 %887, label %766, label %888
888: ; preds = %885, %461, %270, %383, %726, %269, %605
ret i32 1
}