void reconstruct(double *x, double *y, int len) {
  double *temp_1, *temp_2;
  double *even, *odd;
  int i, n_half, n_unrol;
  n_half = len >> 1;
  even = x;
  odd = x + n_half;
  temp_1 = y;
  temp_2 = y + n_half;
  n_unrol = n_half & 0xfffffff8;
  for (i = 0; i < n_unrol; i += 8) {
    even[i + 0] /= (1.4142135623730950488016887242097);
    even[i + 1] /= (1.4142135623730950488016887242097);
    even[i + 2] /= (1.4142135623730950488016887242097);
    even[i + 3] /= (1.4142135623730950488016887242097);
    even[i + 4] /= (1.4142135623730950488016887242097);
    even[i + 5] /= (1.4142135623730950488016887242097);
    even[i + 6] /= (1.4142135623730950488016887242097);
    even[i + 7] /= (1.4142135623730950488016887242097);
    odd[i + 0] *= (1.4142135623730950488016887242097);
    odd[i + 1] *= (1.4142135623730950488016887242097);
    odd[i + 2] *= (1.4142135623730950488016887242097);
    odd[i + 3] *= (1.4142135623730950488016887242097);
    odd[i + 4] *= (1.4142135623730950488016887242097);
    odd[i + 5] *= (1.4142135623730950488016887242097);
    odd[i + 6] *= (1.4142135623730950488016887242097);
    odd[i + 7] *= (1.4142135623730950488016887242097);
  }
  for (; i < n_half; i++) {
    even[i] /= (1.4142135623730950488016887242097);
    odd[i] *= (1.4142135623730950488016887242097);
  }
  PHI3(odd, temp_1, temp_2, n_half);
  for (i = 0; i < n_unrol; i += 8) {
    even[i + 0] -= temp_1[i + 0];
    even[i + 1] -= temp_1[i + 1];
    even[i + 2] -= temp_1[i + 2];
    even[i + 3] -= temp_1[i + 3];
    even[i + 4] -= temp_1[i + 4];
    even[i + 5] -= temp_1[i + 5];
    even[i + 6] -= temp_1[i + 6];
    even[i + 7] -= temp_1[i + 7];
  }
  for (; i < n_half; i++)
    even[i] -= temp_1[i];
  F2(even, temp_1, temp_2, n_half);
  for (i = 0; i < n_unrol; i += 8) {
    odd[i + 0] += temp_1[i + 0];
    odd[i + 1] += temp_1[i + 1];
    odd[i + 2] += temp_1[i + 2];
    odd[i + 3] += temp_1[i + 3];
    odd[i + 4] += temp_1[i + 4];
    odd[i + 5] += temp_1[i + 5];
    odd[i + 6] += temp_1[i + 6];
    odd[i + 7] += temp_1[i + 7];
  }
  for (; i < n_half; i++)
    odd[i] += temp_1[i];
  for (i = 0; i < n_unrol; i += 8) {
    y[((i + 0) << 1)] = even[i + 0];
    y[((i + 1) << 1)] = even[i + 1];
    y[((i + 2) << 1)] = even[i + 2];
    y[((i + 3) << 1)] = even[i + 3];
    y[((i + 4) << 1)] = even[i + 4];
    y[((i + 5) << 1)] = even[i + 5];
    y[((i + 6) << 1)] = even[i + 6];
    y[((i + 7) << 1)] = even[i + 7];
    y[((i + 0) << 1) + 1] = odd[i + 0];
    y[((i + 1) << 1) + 1] = odd[i + 1];
    y[((i + 2) << 1) + 1] = odd[i + 2];
    y[((i + 3) << 1) + 1] = odd[i + 3];
    y[((i + 4) << 1) + 1] = odd[i + 4];
    y[((i + 5) << 1) + 1] = odd[i + 5];
    y[((i + 6) << 1) + 1] = odd[i + 6];
    y[((i + 7) << 1) + 1] = odd[i + 7];
  }
  for (; i < n_half; i++) {
    y[(i << 1)] = even[i];
    y[(i << 1) + 1] = odd[i];
  }
}


x86 assembly (clang, -O0):
<reconstruct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x40(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    13ac <reconstruct+0x28c>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe58(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe35(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe12(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xdef(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xdcc(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xda9(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd86(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd63(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  0xd45(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xd26(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  0xd07(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  0xce8(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  0xcc9(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  0xcaa(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  0xc8b(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  0xc6c(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    1182 <reconstruct+0x62>
jmp    13b1 <reconstruct+0x291>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1403 <reconstruct+0x2e3>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc2e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0xc15(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b1 <reconstruct+0x291>
mov    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x40(%rbp),%ecx
mov    $0x0,%al
call   1030 <PHI3@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    15a2 <reconstruct+0x482>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    1420 <reconstruct+0x300>
jmp    15a7 <reconstruct+0x487>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    15e4 <reconstruct+0x4c4>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15a7 <reconstruct+0x487>
mov    -0x30(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x40(%rbp),%ecx
mov    $0x0,%al
call   1040 <F2@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1763 <reconstruct+0x643>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    1601 <reconstruct+0x4e1>
jmp    1768 <reconstruct+0x648>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    17a1 <reconstruct+0x681>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1768 <reconstruct+0x648>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1a4a <reconstruct+0x92a>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    17a8 <reconstruct+0x688>
jmp    1a4f <reconstruct+0x92f>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1aaa <reconstruct+0x98a>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a4f <reconstruct+0x92f>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reconstruct>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%ecx
mov    %rsi,%r14
mov    %rdi,%rbx
sar    %ecx
movslq %ecx,%r13
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %eax,0x10(%rsp)
mov    %eax,%r12d
jle    11eb <reconstruct+0xcb>
lea    (%rbx,%r13,8),%rdx
add    $0x30,%rdx
xor    %eax,%eax
movapd 0xea0(%rip),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd 0x20(%rbx,%rax,8),%xmm3
movupd 0x30(%rbx,%rax,8),%xmm4
divpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rax,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rbx,%rax,8)
divpd  %xmm0,%xmm3
movupd %xmm3,0x20(%rbx,%rax,8)
divpd  %xmm0,%xmm4
movupd %xmm4,0x30(%rbx,%rax,8)
movupd -0x30(%rdx,%rax,8),%xmm1
movupd -0x20(%rdx,%rax,8),%xmm2
movupd -0x10(%rdx,%rax,8),%xmm3
movupd (%rdx,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
movupd %xmm1,-0x30(%rdx,%rax,8)
mulpd  %xmm0,%xmm2
movupd %xmm2,-0x20(%rdx,%rax,8)
mulpd  %xmm0,%xmm3
movupd %xmm3,-0x10(%rdx,%rax,8)
mulpd  %xmm0,%xmm4
movupd %xmm4,(%rdx,%rax,8)
add    $0x8,%rax
cmp    %r12,%rax
jb     1160 <reconstruct+0x40>
jmp    11ed <reconstruct+0xcd>
xor    %eax,%eax
lea    (%rbx,%r13,8),%rdi
lea    (%r14,%r13,8),%rdx
cmp    %ecx,%eax
mov    %ecx,0x18(%rsp)
jge    13a5 <reconstruct+0x285>
mov    %eax,%eax
mov    %ecx,%r11d
mov    %r11,%r10
sub    %rax,%r10
cmp    $0x2,%r10
jb     1308 <reconstruct+0x1e8>
lea    (%rbx,%rax,8),%rsi
lea    (%rax,%r13,1),%r15
lea    (%r11,%r13,1),%rbp
lea    (%rbx,%rbp,8),%rbp
cmp    %rbp,%rsi
jae    123c <reconstruct+0x11c>
lea    (%rbx,%r11,8),%rsi
lea    (%rbx,%r15,8),%rbp
cmp    %rsi,%rbp
jb     1308 <reconstruct+0x1e8>
mov    %rdx,0x8(%rsp)
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rsi
mov    %rsi,%r9
shr    %r9
add    $0x1,%r9
test   %rsi,%rsi
je     1d88 <reconstruct+0xc68>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rbx,%r15,8),%rsi
add    $0x10,%rsi
lea    (%rbx,%rax,8),%rdx
add    $0x10,%rdx
xor    %ecx,%ecx
movapd 0xd80(%rip),%xmm0
movupd -0x10(%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rdx,%rcx,8)
movupd -0x10(%rsi,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rsi,%rcx,8)
movupd (%rdx,%rcx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rcx,8)
movupd (%rsi,%rcx,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1280 <reconstruct+0x160>
test   $0x1,%r9b
je     12f3 <reconstruct+0x1d3>
add    %rax,%rcx
movupd (%rbx,%rcx,8),%xmm0
movapd 0xd24(%rip),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rbx,%rcx,8)
movupd (%rdi,%rcx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rcx,8)
cmp    %r8,%r10
mov    0x18(%rsp),%ecx
mov    0x8(%rsp),%rdx
je     13a5 <reconstruct+0x285>
add    %r8,%rax
mov    %r11d,%esi
sub    %eax,%esi
mov    %rax,%rbp
not    %rbp
test   $0x1,%sil
je     133d <reconstruct+0x21d>
movsd  (%rbx,%rax,8),%xmm0
movsd  0xcea(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rax,8)
mulsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rax
add    %r11,%rbp
je     13a5 <reconstruct+0x285>
lea    (%rbx,%r13,8),%rsi
add    $0x8,%rsi
movsd  0xcbe(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  -0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rsi,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r11
jne    1360 <reconstruct+0x240>
xor    %ebp,%ebp
mov    %rdi,0x8(%rsp)
mov    %r14,%rsi
mov    %rdx,%r15
xor    %eax,%eax
call   1030 <PHI3@plt>
cmpl   $0x0,0x10(%rsp)
jle    1472 <reconstruct+0x352>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rbp,8),%xmm0
subsd  (%r14,%rbp,8),%xmm0
movsd  0x8(%rbx,%rbp,8),%xmm1
movsd  %xmm0,(%rbx,%rbp,8)
subsd  0x8(%r14,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rbp,8)
movsd  0x10(%rbx,%rbp,8),%xmm0
subsd  0x10(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rbp,8)
movsd  0x18(%rbx,%rbp,8),%xmm0
subsd  0x18(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rbp,8)
movsd  0x20(%rbx,%rbp,8),%xmm0
subsd  0x20(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x20(%rbx,%rbp,8)
movsd  0x28(%rbx,%rbp,8),%xmm0
subsd  0x28(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x28(%rbx,%rbp,8)
movsd  0x30(%rbx,%rbp,8),%xmm0
subsd  0x30(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x30(%rbx,%rbp,8)
movsd  0x38(%rbx,%rbp,8),%xmm0
subsd  0x38(%r14,%rbp,8),%xmm0
movsd  %xmm0,0x38(%rbx,%rbp,8)
add    $0x8,%rbp
cmp    %r12,%rbp
jb     13d0 <reconstruct+0x2b0>
mov    0x18(%rsp),%ecx
cmp    %ecx,%ebp
mov    %r15,%rdx
jge    1622 <reconstruct+0x502>
mov    %ebp,%eax
mov    %ecx,%r11d
mov    %r11,%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     1596 <reconstruct+0x476>
lea    (%rbx,%rax,8),%rdi
lea    (%r14,%r11,8),%rsi
cmp    %rsi,%rdi
jae    14b4 <reconstruct+0x394>
lea    (%rbx,%r11,8),%rdi
lea    (%r14,%rax,8),%rsi
cmp    %rdi,%rsi
jb     1596 <reconstruct+0x476>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1d99 <reconstruct+0xc79>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rbx,%rax,8),%rsi
add    $0x30,%rsi
lea    (%r14,%rax,8),%rdx
add    $0x30,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd -0x30(%rsi,%rdi,8),%xmm2
subpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rdi,8),%xmm0
subpd  %xmm1,%xmm0
movupd -0x10(%rsi,%rdi,8),%xmm1
movupd (%rsi,%rdi,8),%xmm3
movupd %xmm2,-0x30(%rsi,%rdi,8)
movupd %xmm0,-0x20(%rsi,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
subpd  %xmm0,%xmm1
movupd (%rdx,%rdi,8),%xmm0
subpd  %xmm0,%xmm3
movupd %xmm1,-0x10(%rsi,%rdi,8)
movupd %xmm3,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    14f0 <reconstruct+0x3d0>
test   $0x1,%r9b
je     1583 <reconstruct+0x463>
add    %rax,%rdi
movupd (%r14,%rdi,8),%xmm0
movupd 0x10(%r14,%rdi,8),%xmm1
movupd (%rbx,%rdi,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rdi,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%rdi,8)
movupd %xmm0,0x10(%rbx,%rdi,8)
cmp    %r8,%r10
mov    0x18(%rsp),%ecx
mov    %r15,%rdx
je     1622 <reconstruct+0x502>
add    %r8,%rax
mov    %r11d,%esi
sub    %eax,%esi
mov    %rax,%rdi
not    %rdi
add    %r11,%rdi
and    $0x3,%rsi
je     15ca <reconstruct+0x4aa>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
subsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    15b0 <reconstruct+0x490>
cmp    $0x3,%rdi
jb     1622 <reconstruct+0x502>
movsd  (%rbx,%rax,8),%xmm0
subsd  (%r14,%rax,8),%xmm0
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm0,(%rbx,%rax,8)
subsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
subsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
subsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    15d0 <reconstruct+0x4b0>
xor    %ebp,%ebp
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <F2@plt>
cmpl   $0x0,0x10(%rsp)
mov    0x8(%rsp),%r11
jle    16f2 <reconstruct+0x5d2>
lea    (%rbx,%r13,8),%rax
add    $0x38,%rax
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rbp,8),%xmm0
addsd  -0x38(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x38(%rax,%rbp,8)
movsd  0x8(%r14,%rbp,8),%xmm0
addsd  -0x30(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x30(%rax,%rbp,8)
movsd  0x10(%r14,%rbp,8),%xmm0
addsd  -0x28(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x28(%rax,%rbp,8)
movsd  0x18(%r14,%rbp,8),%xmm0
addsd  -0x20(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x20(%rax,%rbp,8)
movsd  0x20(%r14,%rbp,8),%xmm0
addsd  -0x18(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rbp,8)
movsd  0x28(%r14,%rbp,8),%xmm0
addsd  -0x10(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rbp,8)
movsd  0x30(%r14,%rbp,8),%xmm0
addsd  -0x8(%rax,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbp,8)
movsd  0x38(%r14,%rbp,8),%xmm0
addsd  (%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x8,%rbp
cmp    %r12,%rbp
jb     1650 <reconstruct+0x530>
mov    0x18(%rsp),%r9d
cmp    %r9d,%ebp
jge    18c2 <reconstruct+0x7a2>
mov    %ebp,%eax
mov    %r9d,%ecx
mov    %rcx,%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     1828 <reconstruct+0x708>
lea    (%rax,%r13,1),%rdx
lea    (%rbx,%rdx,8),%rsi
lea    (%r14,%rcx,8),%rdi
cmp    %rdi,%rsi
jae    173b <reconstruct+0x61b>
lea    (%rcx,%r13,1),%rsi
lea    (%rbx,%rsi,8),%rsi
lea    (%r14,%rax,8),%rdi
cmp    %rsi,%rdi
jb     1828 <reconstruct+0x708>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1daa <reconstruct+0xc8a>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rbx,%rdx,8),%rsi
add    $0x30,%rsi
lea    (%r14,%rax,8),%rdx
add    $0x30,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
movupd -0x30(%rsi,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd -0x20(%rsi,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd -0x10(%rsi,%rdi,8),%xmm1
movupd (%rsi,%rdi,8),%xmm3
movupd %xmm2,-0x30(%rsi,%rdi,8)
movupd %xmm0,-0x20(%rsi,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd (%rdx,%rdi,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rsi,%rdi,8)
movupd %xmm1,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1780 <reconstruct+0x660>
test   $0x1,%r9b
je     1817 <reconstruct+0x6f7>
add    %rax,%rdi
movupd (%r14,%rdi,8),%xmm0
movupd 0x10(%r14,%rdi,8),%xmm1
movupd (%r11,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r11,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r11,%rdi,8)
movupd %xmm0,0x10(%r11,%rdi,8)
cmp    %r8,%r10
mov    0x18(%rsp),%r9d
je     18c2 <reconstruct+0x7a2>
add    %r8,%rax
mov    %ecx,%esi
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
and    $0x3,%rsi
je     185c <reconstruct+0x73c>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
addsd  (%r11,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1840 <reconstruct+0x720>
cmp    $0x3,%rdx
jb     18c2 <reconstruct+0x7a2>
lea    (%rbx,%r13,8),%rdx
add    $0x18,%rdx
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
addsd  -0x18(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rdx,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
addsd  -0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%rax,8)
movsd  0x10(%r14,%rax,8),%xmm0
addsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rax,8)
movsd  0x18(%r14,%rax,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1870 <reconstruct+0x750>
cmpl   $0x0,0x10(%rsp)
jle    1aab <reconstruct+0x98b>
movabs $0x200000000,%r9
mov    %r13,0x10(%rsp)
lea    (%rbx,%r13,8),%rdx
add    $0x38,%rdx
xor    %r8d,%r8d
movabs $0x600000000,%r10
movabs $0x800000000,%r11
movabs $0xa00000000,%rcx
movabs $0xc00000000,%rbp
movabs $0xe00000000,%rax
movabs $0x1000000000,%r13
xor    %r15d,%r15d
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%r15,4),%xmm0
mov    %r8,%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x8(%rbx,%r15,4),%xmm0
lea    (%r8,%r9,1),%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x10(%rbx,%r15,4),%xmm0
movabs $0x400000000,%rsi
add    %r8,%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x18(%rbx,%r15,4),%xmm0
lea    (%r8,%r10,1),%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x20(%rbx,%r15,4),%xmm0
lea    (%r8,%r11,1),%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x28(%rbx,%r15,4),%xmm0
lea    (%r8,%rcx,1),%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x30(%rbx,%r15,4),%xmm0
lea    (%r8,%rbp,1),%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  0x38(%rbx,%r15,4),%xmm0
lea    (%r8,%rax,1),%rsi
sar    $0x1d,%rsi
movsd  %xmm0,(%r14,%rsi,1)
movsd  -0x38(%rdx,%r15,4),%xmm0
lea    0x1(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  -0x30(%rdx,%r15,4),%xmm0
lea    0x3(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  -0x28(%rdx,%r15,4),%xmm0
lea    0x5(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  -0x20(%rdx,%r15,4),%xmm0
lea    0x7(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  -0x18(%rdx,%r15,4),%xmm0
lea    0x9(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  -0x10(%rdx,%r15,4),%xmm0
lea    0xb(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  -0x8(%rdx,%r15,4),%xmm0
lea    0xd(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
movsd  (%rdx,%r15,4),%xmm0
lea    0xf(%r15),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r14,%rsi,8)
add    $0x8,%rdi
add    $0x10,%r15
add    %r13,%r8
cmp    %r12,%rdi
jb     1930 <reconstruct+0x810>
mov    0x10(%rsp),%r13
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%r9d
cmp    %r9d,%edi
jl     1ab6 <reconstruct+0x996>
jmp    1bbd <reconstruct+0xa9d>
xor    %edi,%edi
cmp    %r9d,%edi
jge    1bbd <reconstruct+0xa9d>
mov    %edi,%r15d
mov    %r9d,%esi
mov    %rsi,%r8
sub    %r15,%r8
cmp    $0x2,%r8
jae    1bcc <reconstruct+0xaac>
mov    %esi,%ecx
sub    %r15d,%ecx
mov    %r15,%rax
not    %rax
test   $0x1,%cl
je     1b0d <reconstruct+0x9ed>
movsd  (%rbx,%r15,8),%xmm0
mov    %r15,%rcx
shl    $0x21,%rcx
sar    $0x1d,%rcx
movsd  %xmm0,(%r14,%rcx,1)
movsd  (%r11,%r15,8),%xmm0
lea    (%r15,%r15,1),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%r14,%rcx,8)
add    $0x1,%r15
add    %rsi,%rax
je     1bbd <reconstruct+0xa9d>
movabs $0x400000000,%r8
movabs $0x200000000,%r9
sub    %r15,%rsi
mov    %r15d,%edx
and    $0x7fffffff,%edx
add    %rdx,%rdx
mov    %r15,%rcx
shl    $0x21,%rcx
add    %r15,%r13
lea    (%rbx,%r13,8),%rbp
add    $0x8,%rbp
lea    (%rbx,%r15,8),%rbx
add    $0x8,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbx,%rax,4),%xmm0
mov    %rcx,%rdi
sar    $0x1d,%rdi
movsd  %xmm0,(%r14,%rdi,1)
movsd  -0x8(%rbp,%rax,4),%xmm0
lea    (%rdx,%rax,1),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  %xmm0,(%r14,%rdi,8)
movsd  (%rbx,%rax,4),%xmm0
lea    (%rcx,%r9,1),%rdi
sar    $0x1d,%rdi
movsd  %xmm0,(%r14,%rdi,1)
movsd  0x0(%rbp,%rax,4),%xmm0
lea    (%rdx,%rax,1),%edi
add    $0x3,%edi
movslq %edi,%rdi
movsd  %xmm0,(%r14,%rdi,8)
add    $0x4,%rax
add    %r8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1b60 <reconstruct+0xa40>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,%rcx
not    %rcx
add    %rsi,%rcx
lea    (%rdi,%rdi,1),%r9d
mov    %ecx,%ebp
add    %ebp,%ebp
setb   %r10b
lea    0x0(%rbp,%rdi,2),%r11d
mov    $0x10,%edx
mov    %rcx,%rax
mul    %rdx
seto   %r12b
cmp    %r9d,%r11d
jl     1e30 <reconstruct+0xd10>
test   %r10b,%r10b
mov    0x8(%rsp),%r11
jne    1acc <reconstruct+0x9ac>
shr    $0x20,%rcx
jne    1acc <reconstruct+0x9ac>
lea    (%rdi,%rdi,1),%edx
add    $0x1,%edx
lea    0x1(%rbp,%rdi,2),%ebp
cmp    %edx,%ebp
jl     1acc <reconstruct+0x9ac>
test   %r10b,%r10b
jne    1acc <reconstruct+0x9ac>
test   %rcx,%rcx
jne    1acc <reconstruct+0x9ac>
movslq %r9d,%rbp
lea    (%r14,%rbp,8),%rcx
lea    (%rcx,%rax,1),%rdx
cmp    %rcx,%rdx
jb     1acc <reconstruct+0x9ac>
test   %r12b,%r12b
jne    1acc <reconstruct+0x9ac>
lea    (%r14,%rbp,8),%rdx
add    $0x8,%rdx
add    %rcx,%rax
add    $0x8,%rax
cmp    %rdx,%rax
jb     1acc <reconstruct+0x9ac>
test   %r12b,%r12b
jne    1acc <reconstruct+0x9ac>
lea    (%r15,%r13,1),%r12
lea    (%rbx,%r12,8),%rdx
mov    %r13,0x10(%rsp)
lea    (%rsi,%r13,1),%rax
lea    (%rbx,%rax,8),%r10
lea    0x0(%rbp,%rsi,2),%rbp
sub    %r15,%rbp
sub    %r15,%rbp
lea    (%r14,%rbp,8),%rax
lea    (%rbx,%r15,8),%rbp
lea    (%rbx,%rsi,8),%r11
cmp    %rax,%rdx
setb   %r13b
cmp    %r10,%rcx
setb   %r10b
cmp    %rax,%rbp
setb   %dl
cmp    %r11,%rcx
setb   %cl
test   %r10b,%r13b
jne    1dbb <reconstruct+0xc9b>
and    %cl,%dl
mov    0x8(%rsp),%r11
jne    1dca <reconstruct+0xcaa>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x18(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rax,%rax
mov    %rcx,0x20(%rsp)
je     1dd4 <reconstruct+0xcb4>
and    $0xfffffffffffffffe,%rcx
lea    (%rbx,%r12,8),%r13
add    $0x10,%r13
lea    (%rbx,%r15,8),%r11
add    $0x10,%r11
mov    %r9d,%r9d
lea    0x1(%r9),%r12
xor    %eax,%eax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x10(%r11,%rax,4),%xmm0
movups -0x10(%r13,%rax,4),%xmm1
lea    (%r12,%rax,1),%r10d
movslq %r10d,%rbp
movaps %xmm0,%xmm2
movlhps %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movups %xmm0,0x8(%r14,%rbp,8)
movups %xmm2,-0x8(%r14,%rbp,8)
movupd (%r11,%rax,4),%xmm0
movupd 0x0(%r13,%rax,4),%xmm1
lea    0x5(%r9,%rax,1),%ebp
movslq %ebp,%rbp
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd %xmm0,0x8(%r14,%rbp,8)
movupd %xmm2,-0x8(%r14,%rbp,8)
add    $0x4,%rdx
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d20 <reconstruct+0xc00>
jmp    1dd6 <reconstruct+0xcb6>
xor    %ecx,%ecx
test   $0x1,%r9b
jne    12cc <reconstruct+0x1ac>
jmp    12f3 <reconstruct+0x1d3>
xor    %edi,%edi
test   $0x1,%r9b
jne    1555 <reconstruct+0x435>
jmp    1583 <reconstruct+0x463>
xor    %edi,%edi
test   $0x1,%r9b
jne    17e5 <reconstruct+0x6c5>
jmp    1817 <reconstruct+0x6f7>
mov    0x10(%rsp),%r13
mov    0x8(%rsp),%r11
jmp    1acc <reconstruct+0x9ac>
mov    0x10(%rsp),%r13
jmp    1acc <reconstruct+0x9ac>
xor    %edx,%edx
testb  $0x1,0x20(%rsp)
mov    0x8(%rsp),%r11
je     1e15 <reconstruct+0xcf5>
lea    (%rdx,%r15,1),%rax
add    %edx,%edi
movupd (%rbx,%rax,8),%xmm0
movupd (%r11,%rax,8),%xmm1
lea    (%rdi,%rdi,1),%eax
add    $0x1,%eax
cltq
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd %xmm0,0x8(%r14,%rax,8)
movupd %xmm2,-0x8(%r14,%rax,8)
mov    0x18(%rsp),%rax
cmp    %rax,%r8
mov    0x10(%rsp),%r13
je     1bbd <reconstruct+0xa9d>
add    %rax,%r15
jmp    1acc <reconstruct+0x9ac>
mov    0x8(%rsp),%r11
jmp    1acc <reconstruct+0x9ac>

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

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