void flips(int size, double **block, double **flip_block, int iso) {
  register int i, j;
  switch (iso) {
  case 0:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[i][j];
    break;
  case 1:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[j][size - i - 1];
    break;
  case 2:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[size - j - 1][i];
    break;
  case 3:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[size - i - 1][size - j - 1];
    break;
  case 4:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[i][size - j - 1];
    break;
  case 5:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[size - i - 1][j];
    break;
  case 6:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[j][i];
    break;
  case 7:
    for (i = 0; i < size; i++)
      for (j = 0; j < size; j++)
        flip_block[i][j] = block[size - j - 1][size - i - 1];
    break;
  }
}


x86 assembly (clang, -O0):
<flips>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %rax,-0x30(%rbp)
sub    $0x7,%rax
ja     1527 <flips+0x427>
mov    -0x30(%rbp),%rax
lea    0xed2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a8 <flips+0xa8>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1195 <flips+0x95>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <flips+0x51>
jmp    119a <flips+0x9a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113e <flips+0x3e>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1226 <flips+0x126>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1213 <flips+0x113>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c7 <flips+0xc7>
jmp    1218 <flips+0x118>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11b4 <flips+0xb4>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a4 <flips+0x1a4>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1291 <flips+0x191>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1245 <flips+0x145>
jmp    1296 <flips+0x196>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1232 <flips+0x132>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    132a <flips+0x22a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1317 <flips+0x217>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12c3 <flips+0x1c3>
jmp    131c <flips+0x21c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12b0 <flips+0x1b0>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13a8 <flips+0x2a8>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1395 <flips+0x295>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1349 <flips+0x249>
jmp    139a <flips+0x29a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1336 <flips+0x236>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1426 <flips+0x326>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1413 <flips+0x313>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13c7 <flips+0x2c7>
jmp    1418 <flips+0x318>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13b4 <flips+0x2b4>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    149c <flips+0x39c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1489 <flips+0x389>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1445 <flips+0x345>
jmp    148e <flips+0x38e>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1432 <flips+0x332>
jmp    1527 <flips+0x427>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1522 <flips+0x422>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    150f <flips+0x40f>
mov    -0x10(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14bb <flips+0x3bb>
jmp    1514 <flips+0x414>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    14a8 <flips+0x3a8>
jmp    1527 <flips+0x427>
pop    %rbp
ret

x86 assembly (clang, -O2):
<flips>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x7,%ecx
ja     1c35 <flips+0xb35>
mov    %ecx,%eax
lea    0xee4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r13d
mov    %r13d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r9
mov    %r9,-0x38(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%r9
mov    %r13d,%r8d
and    $0x3,%r8d
mov    %r10,%r15
shl    $0x5,%r15
xor    %r12d,%r12d
jmp    117d <flips+0x7d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %r13,%r12
je     1c35 <flips+0xb35>
mov    (%rsi,%r12,8),%rbx
mov    (%rdx,%r12,8),%rbp
cmp    $0x4,%edi
jb     11ab <flips+0xab>
lea    (%rbx,%r13,8),%rax
cmp    %rax,%rbp
jae    1220 <flips+0x120>
lea    0x0(,%r13,8),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1220 <flips+0x120>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r13,%rax
test   %r8,%r8
je     11d5 <flips+0xd5>
mov    %r8,%r14
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r14
jne    11c0 <flips+0xc0>
cmp    $0x3,%rax
jb     1170 <flips+0x70>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    11e0 <flips+0xe0>
jmp    1170 <flips+0x70>
nopl   (%rax)
cmpq   $0xc,-0x38(%rsp)
jae    122c <flips+0x12c>
xor    %ecx,%ecx
jmp    1299 <flips+0x199>
mov    %r9,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rcx,8),%xmm0
movups 0x10(%rbx,%rcx,8),%xmm1
movups %xmm0,0x0(%rbp,%rcx,8)
movups %xmm1,0x10(%rbp,%rcx,8)
movups 0x20(%rbx,%rcx,8),%xmm0
movups 0x30(%rbx,%rcx,8),%xmm1
movups %xmm0,0x20(%rbp,%rcx,8)
movups %xmm1,0x30(%rbp,%rcx,8)
movups 0x40(%rbx,%rcx,8),%xmm0
movups 0x50(%rbx,%rcx,8),%xmm1
movups %xmm0,0x40(%rbp,%rcx,8)
movups %xmm1,0x50(%rbp,%rcx,8)
movups 0x60(%rbx,%rcx,8),%xmm0
movups 0x70(%rbx,%rcx,8),%xmm1
movups %xmm0,0x60(%rbp,%rcx,8)
movups %xmm1,0x70(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1240 <flips+0x140>
test   %r10,%r10
je     12dd <flips+0x1dd>
lea    0x10(,%rcx,8),%r14
add    %rbp,%r14
lea    (%rbx,%rcx,8),%rcx
add    $0x10,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%r14,%rax,1)
movups %xmm1,(%r14,%rax,1)
add    $0x20,%rax
cmp    %rax,%r15
jne    12c0 <flips+0x1c0>
mov    %r11,%rcx
cmp    %r13,%r11
je     1170 <flips+0x70>
jmp    11ad <flips+0xad>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r9d
lea    -0x1(%r9),%r8
mov    %r9d,%r14d
and    $0x3,%r14d
mov    %r9d,%r11d
and    $0xfffffffc,%r11d
xor    %r10d,%r10d
jmp    131d <flips+0x21d>
add    $0x1,%r10
cmp    %r9,%r10
je     1c35 <flips+0xb35>
mov    %r10d,%eax
not    %eax
add    %edi,%eax
movslq %eax,%rbx
mov    (%rdx,%r10,8),%rcx
xor    %ebp,%ebp
cmp    $0x3,%r8
jb     1387 <flips+0x287>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
mov    0x8(%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rbp,8)
mov    0x10(%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rbp,8)
mov    0x18(%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r11
jne    1340 <flips+0x240>
test   %r14,%r14
je     1310 <flips+0x210>
lea    (%rcx,%rbp,8),%r15
lea    (%rsi,%rbp,8),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    13a0 <flips+0x2a0>
jmp    1310 <flips+0x210>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r9d
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
lea    -0x2(%rdi),%r8d
xor    %ebx,%ebx
jmp    13ed <flips+0x2ed>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %r9,%rbx
je     1c35 <flips+0xb35>
mov    (%rdx,%rbx,8),%r11
cmp    $0x1,%edi
jne    1400 <flips+0x300>
xor    %eax,%eax
jmp    1446 <flips+0x346>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rcx),%ebp
movslq %ebp,%rbp
mov    (%rsi,%rbp,8),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movslq %ecx,%rcx
mov    (%rsi,%rcx,8),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r11,%rax,8)
add    $0x2,%rax
add    $0xfffffffe,%ecx
cmp    %rax,%r10
jne    1410 <flips+0x310>
test   $0x1,%r9b
je     13e0 <flips+0x2e0>
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
movslq %ecx,%rcx
mov    (%rsi,%rcx,8),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
jmp    13e0 <flips+0x2e0>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r12d
lea    -0x1(%r12),%rax
lea    -0x1(%rdi),%ecx
mov    %ecx,-0x38(%rsp)
movslq %ecx,%rcx
lea    0x1(%rcx),%r14
mov    %r14,%rbp
sub    %r12,%rbp
mov    %rbp,-0x8(%rsp)
mov    %r12d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,-0x10(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,-0x18(%rsp)
mov    %rbp,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %ecx,%ebp
sub    %eax,%ebp
cmp    %ecx,%ebp
setg   %cl
shr    $0x20,%rax
setne  %r8b
or     %cl,%r8b
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %rbx,%rax
mov    %rbx,-0x20(%rsp)
and    %rbx,%rcx
mov    %rcx,-0x28(%rsp)
mov    %r12,%r15
neg    %r15
lea    -0x5(%rdi),%eax
mov    %eax,-0x2c(%rsp)
xor    %r10d,%r10d
jmp    150d <flips+0x40d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r10
cmp    %r12,%r10
je     1c35 <flips+0xb35>
cmp    $0x4,%edi
setb   %al
mov    %r10d,%ecx
not    %ecx
add    %edi,%ecx
movslq %ecx,%rcx
mov    (%rsi,%rcx,8),%r13
mov    (%rdx,%r10,8),%r11
or     %r8b,%al
jne    155b <flips+0x45b>
lea    0x0(,%r14,8),%rax
add    %r13,%rax
cmp    %rax,%r11
jae    15f0 <flips+0x4f0>
lea    (%r11,%r12,8),%rax
mov    -0x8(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cmp    %rax,%rcx
jae    15f0 <flips+0x4f0>
xor    %eax,%eax
mov    %rax,%rbp
test   $0x1,%r12b
je     1583 <flips+0x483>
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    %r15,%rax
je     1500 <flips+0x400>
mov    %r12,%r9
sub    %rbp,%r9
mov    -0x38(%rsp),%eax
mov    %eax,%ecx
sub    %ebp,%ecx
lea    (%r11,%rbp,8),%rbx
add    $0x8,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
lea    -0x1(%rcx),%eax
cltq
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
add    $0xfffffffe,%ecx
cmp    %rbp,%r9
jne    15b0 <flips+0x4b0>
jmp    1500 <flips+0x400>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15,%rbx
mov    %r14,%rcx
cmpq   $0x0,-0x18(%rsp)
je     16c1 <flips+0x5c1>
mov    -0x28(%rsp),%r14
mov    -0x2c(%rsp),%eax
mov    %eax,%r9d
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x4(%r9),%eax
cltq
movups -0x18(%r13,%rax,8),%xmm0
movups -0x8(%r13,%rax,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%r11,%r15,8)
movups %xmm0,0x10(%r11,%r15,8)
movslq %r9d,%r9
movups -0x18(%r13,%r9,8),%xmm0
movups -0x8(%r13,%r9,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,0x20(%r11,%r15,8)
movups %xmm0,0x30(%r11,%r15,8)
add    $0x8,%r15
add    $0xfffffff8,%r9d
add    $0xfffffffffffffffe,%r14
jne    1620 <flips+0x520>
testb  $0x1,-0x20(%rsp)
je     16a5 <flips+0x5a5>
mov    %r15d,%eax
not    %eax
add    %edi,%eax
cltq
movups -0x18(%r13,%rax,8),%xmm0
movups -0x8(%r13,%rax,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%r11,%r15,8)
movups %xmm0,0x10(%r11,%r15,8)
mov    -0x10(%rsp),%rbp
mov    %rbp,%rax
cmp    %r12,%rbp
mov    %rcx,%r14
mov    %rbx,%r15
je     1500 <flips+0x400>
jmp    155d <flips+0x45d>
xor    %r15d,%r15d
testb  $0x1,-0x20(%rsp)
jne    167d <flips+0x57d>
jmp    16a5 <flips+0x5a5>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r13d
lea    -0x1(%r13),%rax
lea    -0x1(%rdi),%ecx
mov    %ecx,-0x38(%rsp)
movslq %ecx,%rcx
lea    0x1(%rcx),%r11
mov    %r11,%rbp
sub    %r13,%rbp
mov    %rbp,-0x8(%rsp)
mov    %r13d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,-0x10(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,-0x18(%rsp)
mov    %rbp,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %ecx,%ebp
sub    %eax,%ebp
cmp    %ecx,%ebp
setg   %cl
shr    $0x20,%rax
setne  %r8b
or     %cl,%r8b
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %rbx,%rax
mov    %rbx,-0x20(%rsp)
and    %rbx,%rcx
mov    %rcx,-0x28(%rsp)
mov    %r13,%r15
neg    %r15
lea    -0x5(%rdi),%eax
mov    %eax,-0x2c(%rsp)
xor    %r14d,%r14d
jmp    176d <flips+0x66d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %r13,%r14
je     1c35 <flips+0xb35>
cmp    $0x4,%edi
setb   %al
mov    (%rsi,%r14,8),%r12
mov    (%rdx,%r14,8),%r10
or     %r8b,%al
jne    17a3 <flips+0x6a3>
lea    (%r12,%r11,8),%rax
cmp    %rax,%r10
jae    1820 <flips+0x720>
lea    (%r10,%r13,8),%rax
mov    -0x8(%rsp),%rcx
lea    (%r12,%rcx,8),%rcx
cmp    %rax,%rcx
jae    1820 <flips+0x720>
xor    %eax,%eax
mov    %rax,%rcx
test   $0x1,%r13b
je     17ca <flips+0x6ca>
mov    %eax,%ecx
not    %ecx
add    %edi,%ecx
movslq %ecx,%rcx
movsd  (%r12,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
mov    %rax,%rcx
or     $0x1,%rcx
not    %rax
cmp    %r15,%rax
je     1760 <flips+0x660>
mov    %r13,%r9
sub    %rcx,%r9
mov    -0x38(%rsp),%eax
mov    %eax,%ebp
sub    %ecx,%ebp
lea    (%r10,%rcx,8),%rcx
add    $0x8,%rcx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movslq %ebp,%rbp
movsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rbx,8)
lea    -0x1(%rbp),%eax
cltq
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffe,%ebp
cmp    %rbx,%r9
jne    17f0 <flips+0x6f0>
jmp    1760 <flips+0x660>
mov    %r15,%rbx
mov    %r11,%rcx
cmpq   $0x0,-0x18(%rsp)
je     18f1 <flips+0x7f1>
mov    -0x28(%rsp),%r11
mov    -0x2c(%rsp),%eax
mov    %eax,%r9d
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x4(%r9),%eax
cltq
movups -0x18(%r12,%rax,8),%xmm0
movups -0x8(%r12,%rax,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%r10,%r15,8)
movups %xmm0,0x10(%r10,%r15,8)
movslq %r9d,%r9
movups -0x18(%r12,%r9,8),%xmm0
movups -0x8(%r12,%r9,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,0x20(%r10,%r15,8)
movups %xmm0,0x30(%r10,%r15,8)
add    $0x8,%r15
add    $0xfffffff8,%r9d
add    $0xfffffffffffffffe,%r11
jne    1850 <flips+0x750>
testb  $0x1,-0x20(%rsp)
je     18d5 <flips+0x7d5>
mov    %r15d,%eax
not    %eax
add    %edi,%eax
cltq
movups -0x18(%r12,%rax,8),%xmm0
movups -0x8(%r12,%rax,8),%xmm1
shufps $0x4e,%xmm1,%xmm1
shufps $0x4e,%xmm0,%xmm0
movups %xmm1,(%r10,%r15,8)
movups %xmm0,0x10(%r10,%r15,8)
mov    -0x10(%rsp),%rbp
mov    %rbp,%rax
cmp    %r13,%rbp
mov    %rcx,%r11
mov    %rbx,%r15
je     1760 <flips+0x660>
jmp    17a5 <flips+0x6a5>
xor    %r15d,%r15d
testb  $0x1,-0x20(%rsp)
jne    18ad <flips+0x7ad>
jmp    18d5 <flips+0x7d5>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r13d
mov    %r13d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r9
mov    %r9,-0x38(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%r9
mov    %r13d,%r8d
and    $0x3,%r8d
mov    %r10,%r15
shl    $0x5,%r15
xor    %r12d,%r12d
jmp    194d <flips+0x84d>
xchg   %ax,%ax
add    $0x1,%r12
cmp    %r13,%r12
je     1c35 <flips+0xb35>
mov    %r12d,%eax
not    %eax
add    %edi,%eax
cltq
mov    (%rsi,%rax,8),%rbx
mov    (%rdx,%r12,8),%rbp
cmp    $0x4,%edi
jb     1984 <flips+0x884>
lea    (%rbx,%r13,8),%rax
cmp    %rax,%rbp
jae    1a00 <flips+0x900>
lea    0x0(,%r13,8),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1a00 <flips+0x900>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r13,%rax
test   %r8,%r8
je     19b5 <flips+0x8b5>
mov    %r8,%r14
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r14
jne    19a0 <flips+0x8a0>
cmp    $0x3,%rax
jb     1940 <flips+0x840>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbp,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    19c0 <flips+0x8c0>
jmp    1940 <flips+0x840>
nopl   (%rax)
cmpq   $0xc,-0x38(%rsp)
jae    1a0c <flips+0x90c>
xor    %ecx,%ecx
jmp    1a79 <flips+0x979>
mov    %r9,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rcx,8),%xmm0
movups 0x10(%rbx,%rcx,8),%xmm1
movups %xmm0,0x0(%rbp,%rcx,8)
movups %xmm1,0x10(%rbp,%rcx,8)
movups 0x20(%rbx,%rcx,8),%xmm0
movups 0x30(%rbx,%rcx,8),%xmm1
movups %xmm0,0x20(%rbp,%rcx,8)
movups %xmm1,0x30(%rbp,%rcx,8)
movups 0x40(%rbx,%rcx,8),%xmm0
movups 0x50(%rbx,%rcx,8),%xmm1
movups %xmm0,0x40(%rbp,%rcx,8)
movups %xmm1,0x50(%rbp,%rcx,8)
movups 0x60(%rbx,%rcx,8),%xmm0
movups 0x70(%rbx,%rcx,8),%xmm1
movups %xmm0,0x60(%rbp,%rcx,8)
movups %xmm1,0x70(%rbp,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rax
jne    1a20 <flips+0x920>
test   %r10,%r10
je     1abd <flips+0x9bd>
lea    0x10(,%rcx,8),%r14
add    %rbp,%r14
lea    (%rbx,%rcx,8),%rcx
add    $0x10,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rax,1),%xmm0
movups (%rcx,%rax,1),%xmm1
movups %xmm0,-0x10(%r14,%rax,1)
movups %xmm1,(%r14,%rax,1)
add    $0x20,%rax
cmp    %rax,%r15
jne    1aa0 <flips+0x9a0>
mov    %r11,%rcx
cmp    %r13,%r11
je     1940 <flips+0x840>
jmp    1986 <flips+0x886>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r9d
lea    -0x1(%r9),%r8
mov    %r9d,%r11d
and    $0x3,%r11d
mov    %r9d,%r10d
and    $0xfffffffc,%r10d
xor    %ebx,%ebx
jmp    1afd <flips+0x9fd>
nop
add    $0x1,%rbx
cmp    %r9,%rbx
je     1c35 <flips+0xb35>
mov    (%rdx,%rbx,8),%rcx
xor    %ebp,%ebp
cmp    $0x3,%r8
jb     1b57 <flips+0xa57>
nopl   0x0(%rax)
mov    (%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
mov    0x8(%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rbp,8)
mov    0x10(%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rbp,8)
mov    0x18(%rsi,%rbp,8),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r10
jne    1b10 <flips+0xa10>
test   %r11,%r11
je     1af0 <flips+0x9f0>
lea    (%rcx,%rbp,8),%rcx
lea    (%rsi,%rbp,8),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,8),%rdi
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1b70 <flips+0xa70>
jmp    1af0 <flips+0x9f0>
test   %edi,%edi
jle    1c35 <flips+0xb35>
mov    %edi,%r9d
mov    %r9d,%r11d
and    $0xfffffffe,%r11d
lea    -0x2(%rdi),%r8d
xor    %r10d,%r10d
jmp    1bb9 <flips+0xab9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    %r9,%r10
je     1c35 <flips+0xb35>
mov    %r10d,%eax
not    %eax
add    %edi,%eax
movslq %eax,%rbp
mov    (%rdx,%r10,8),%r14
cmp    $0x1,%edi
jne    1bd0 <flips+0xad0>
xor    %ebx,%ebx
jmp    1c13 <flips+0xb13>
mov    %r8d,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rcx),%eax
cltq
mov    (%rsi,%rax,8),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
movslq %ecx,%rcx
mov    (%rsi,%rcx,8),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,0x8(%r14,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffe,%ecx
cmp    %rbx,%r11
jne    1be0 <flips+0xae0>
test   $0x1,%r9b
je     1bb0 <flips+0xab0>
mov    %ebx,%eax
not    %eax
add    %edi,%eax
cltq
mov    (%rsi,%rax,8),%rax
movsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
jmp    1bb0 <flips+0xab0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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