void decompose(double *x, double *y, int len) {
  double *temp_1, *temp_2;
  double *even, *odd;
  int i, n_half, n_unrol;
  n_half = len >> 1;
  temp_1 = x;
  temp_2 = x + n_half;
  even = y;
  odd = y + n_half;
  n_unrol = n_half & 0xfffffff8;
  for (i = 0; i < n_unrol; i += 8) {
    even[i + 0] = x[(i + 0) << 1];
    even[i + 1] = x[(i + 1) << 1];
    even[i + 2] = x[(i + 2) << 1];
    even[i + 3] = x[(i + 3) << 1];
    even[i + 4] = x[(i + 4) << 1];
    even[i + 5] = x[(i + 5) << 1];
    even[i + 6] = x[(i + 6) << 1];
    even[i + 7] = x[(i + 7) << 1];
    odd[i + 0] = x[((i + 0) << 1) + 1];
    odd[i + 1] = x[((i + 1) << 1) + 1];
    odd[i + 2] = x[((i + 2) << 1) + 1];
    odd[i + 3] = x[((i + 3) << 1) + 1];
    odd[i + 4] = x[((i + 4) << 1) + 1];
    odd[i + 5] = x[((i + 5) << 1) + 1];
    odd[i + 6] = x[((i + 6) << 1) + 1];
    odd[i + 7] = x[((i + 7) << 1) + 1];
  }
  for (; i < n_half; i++) {
    even[i] = x[i << 1];
    odd[i] = x[(i << 1) + 1];
  }
  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];
  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];
  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);
  }
}


x86 assembly (clang, -O0):
<decompose>:
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,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%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    1424 <decompose+0x304>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%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
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    1182 <decompose+0x62>
jmp    1429 <decompose+0x309>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1484 <decompose+0x364>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1429 <decompose+0x309>
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    1623 <decompose+0x503>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%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    -0x38(%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    -0x38(%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    -0x38(%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    -0x38(%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    -0x38(%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    -0x38(%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    -0x38(%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    14a1 <decompose+0x381>
jmp    1628 <decompose+0x508>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1665 <decompose+0x545>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%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    1628 <decompose+0x508>
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    17e4 <decompose+0x6c4>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%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    -0x30(%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    -0x30(%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    -0x30(%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    -0x30(%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    -0x30(%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    -0x30(%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    -0x30(%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    1682 <decompose+0x562>
jmp    17e9 <decompose+0x6c9>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1822 <decompose+0x702>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%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    17e9 <decompose+0x6c9>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1a53 <decompose+0x933>
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  0x7b6(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x797(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  0x778(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  0x759(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  0x73a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  0x71b(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  0x6fc(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  0x6dd(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x6b9(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x696(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x673(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x650(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x62d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x60a(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x5e7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x5c4(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x3c(%rbp)
jmp    1829 <decompose+0x709>
jmp    1a58 <decompose+0x938>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1aaa <decompose+0x98a>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0x58c(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x56d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1a58 <decompose+0x938>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decompose>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edx,%r14d
mov    %rsi,%r12
mov    %rdi,%rbp
sar    %r14d
movslq %r14d,%r13
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %eax,0x1c(%rsp)
mov    %eax,%eax
mov    %rax,0x28(%rsp)
jle    132e <decompose+0x20e>
mov    %r14d,0x8(%rsp)
movabs $0x400000000,%r9
movabs $0x200000000,%r10
mov    %r13,0x10(%rsp)
lea    (%r12,%r13,8),%rsi
add    $0x38,%rsi
xor    %eax,%eax
movabs $0x600000000,%r11
movabs $0xa00000000,%r15
movabs $0xc00000000,%rcx
movabs $0xe00000000,%rdx
movabs $0x1000000000,%r13
xor    %r14d,%r14d
xor    %edi,%edi
mov    0x28(%rsp),%r8
nopl   0x0(%rax,%rax,1)
mov    %rax,%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,(%r12,%r14,4)
lea    (%rax,%r10,1),%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x8(%r12,%r14,4)
lea    (%rax,%r9,1),%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x10(%r12,%r14,4)
lea    (%rax,%r11,1),%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x18(%r12,%r14,4)
movabs $0x800000000,%rbx
add    %rax,%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x20(%r12,%r14,4)
lea    (%rax,%r15,1),%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x28(%r12,%r14,4)
lea    (%rax,%rcx,1),%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x30(%r12,%r14,4)
lea    (%rax,%rdx,1),%rbx
sar    $0x1d,%rbx
movsd  0x0(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x38(%r12,%r14,4)
lea    0x1(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x38(%rsi,%r14,4)
lea    0x3(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x30(%rsi,%r14,4)
lea    0x5(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x28(%rsi,%r14,4)
lea    0x7(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x20(%rsi,%r14,4)
lea    0x9(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x18(%rsi,%r14,4)
lea    0xb(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%r14,4)
lea    0xd(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%r14,4)
lea    0xf(%r14),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rsi,%r14,4)
add    $0x8,%rdi
add    $0x10,%r14
add    %r13,%rax
cmp    %r8,%rdi
jb     11c0 <decompose+0xa0>
mov    0x10(%rsp),%r13
mov    0x8(%rsp),%r14d
jmp    1330 <decompose+0x210>
xor    %edi,%edi
lea    0x0(,%r13,8),%rax
add    %rbp,%rax
mov    %rax,0x30(%rsp)
lea    (%r12,%r13,8),%r15
cmp    %r14d,%edi
jge    171c <decompose+0x5fc>
mov    %edi,%r9d
mov    %r14d,%r8d
mov    %r8,%rsi
sub    %r9,%rsi
cmp    $0x2,%rsi
jb     1627 <decompose+0x507>
mov    %r14d,0x8(%rsp)
mov    %r13,0x10(%rsp)
mov    %r9,%rcx
not    %rcx
add    %r8,%rcx
lea    (%rdi,%rdi,1),%r11d
mov    %ecx,%ebx
add    %ebx,%ebx
setb   %r14b
lea    (%rbx,%rdi,2),%r13d
mov    $0x10,%edx
mov    %rcx,%rax
mul    %rdx
seto   %r10b
cmp    %r11d,%r13d
jl     161d <decompose+0x4fd>
test   %r14b,%r14b
mov    0x10(%rsp),%r13
jne    1622 <decompose+0x502>
shr    $0x20,%rcx
jne    1622 <decompose+0x502>
lea    (%rdi,%rdi,1),%edx
add    $0x1,%edx
lea    (%rbx,%rdi,2),%edi
add    $0x1,%edi
cmp    %edx,%edi
jl     1622 <decompose+0x502>
test   %r14b,%r14b
jne    1622 <decompose+0x502>
test   %rcx,%rcx
mov    0x8(%rsp),%r14d
jne    1627 <decompose+0x507>
movslq %r11d,%rbx
lea    0x0(,%rbx,8),%rdx
add    %rbp,%rdx
lea    (%rdx,%rax,1),%rcx
cmp    %rdx,%rcx
jb     1627 <decompose+0x507>
test   %r10b,%r10b
jne    1627 <decompose+0x507>
lea    0x8(,%rbx,8),%r14
add    %rbp,%r14
add    %rdx,%rax
add    $0x8,%rax
cmp    %r14,%rax
jb     1622 <decompose+0x502>
test   %r10b,%r10b
jne    1622 <decompose+0x502>
mov    %rsi,0x40(%rsp)
lea    (%r12,%r9,8),%rcx
lea    (%r12,%r8,8),%rax
lea    (%r9,%r13,1),%rsi
mov    %r13,%rdi
mov    %rsi,0x38(%rsp)
lea    (%r12,%rsi,8),%r13
add    %r8,%rdi
lea    (%r12,%rdi,8),%r11
lea    (%rbx,%r8,2),%rbx
lea    (%r9,%r9,1),%r10
mov    %r10,%rdi
not    %rdi
add    %rbx,%rdi
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
sub    %r10,%rbx
lea    0x0(,%rbx,8),%rbx
add    %rbp,%rbx
cmp    %r11,%rcx
setb   %sil
cmp    %rax,%r13
setb   0x20(%rsp)
cmp    %rdi,%rcx
setb   %r10b
cmp    %rax,%rdx
setb   0xf(%rsp)
cmp    %rbx,%rcx
setb   %cl
cmp    %rax,%r14
setb   0xe(%rsp)
cmp    %rdi,%r13
setb   %al
cmp    %r11,%rdx
setb   %dil
cmp    %rbx,%r13
setb   %dl
cmp    %r11,%r14
setb   %r14b
test   %sil,0x20(%rsp)
jne    161d <decompose+0x4fd>
and    0xf(%rsp),%r10b
mov    0x10(%rsp),%r13
jne    1622 <decompose+0x502>
and    0xe(%rsp),%cl
jne    1622 <decompose+0x502>
and    %dil,%al
jne    1622 <decompose+0x502>
and    %r14b,%dl
jne    1622 <decompose+0x502>
mov    0x40(%rsp),%rsi
mov    %rsi,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,%r11
shr    %r11
add    $0x1,%r11
test   %rax,%rax
je     1613 <decompose+0x4f3>
movabs $0x800000000,%r14
movabs $0x400000000,%r13
mov    %r11,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x38(%rsp),%rax
lea    (%r12,%rax,8),%r10
add    $0x10,%r10
lea    (%r12,%r9,8),%rdi
add    $0x10,%rdi
mov    %r9,%rax
shl    $0x21,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,%rbx
sar    $0x1d,%rbx
movups 0x0(%rbp,%rbx,1),%xmm0
movups 0x10(%rbp,%rbx,1),%xmm1
movaps %xmm0,%xmm2
movlhps %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movups %xmm2,-0x10(%rdi,%rcx,8)
movups %xmm0,-0x10(%r10,%rcx,8)
lea    (%rax,%r13,1),%rbx
sar    $0x1d,%rbx
movupd 0x0(%rbp,%rbx,1),%xmm0
movupd 0x10(%rbp,%rbx,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,(%r10,%rcx,8)
add    $0x4,%rcx
add    %r14,%rax
add    $0xfffffffffffffffe,%rdx
jne    1560 <decompose+0x440>
test   $0x1,%r11b
je     15f6 <decompose+0x4d6>
add    %r9,%rcx
mov    %rcx,%rax
shl    $0x21,%rax
sar    $0x1d,%rax
movupd 0x0(%rbp,%rax,1),%xmm0
movupd 0x10(%rbp,%rax,1),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm0
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm0,(%r15,%rcx,8)
mov    0x20(%rsp),%rax
cmp    %rax,%rsi
mov    0x10(%rsp),%r13
mov    0x8(%rsp),%r14d
je     171c <decompose+0x5fc>
add    %rax,%r9
jmp    1627 <decompose+0x507>
xor    %ecx,%ecx
test   $0x1,%r11b
jne    15c4 <decompose+0x4a4>
jmp    15f6 <decompose+0x4d6>
mov    0x10(%rsp),%r13
mov    0x8(%rsp),%r14d
mov    %r8d,%ecx
sub    %r9d,%ecx
mov    %r9,%rax
not    %rax
test   $0x1,%cl
je     1669 <decompose+0x549>
mov    %r9,%rcx
shl    $0x21,%rcx
sar    $0x1d,%rcx
movsd  0x0(%rbp,%rcx,1),%xmm0
movsd  %xmm0,(%r12,%r9,8)
lea    (%r9,%r9,1),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%r9,8)
add    $0x1,%r9
add    %r8,%rax
je     171c <decompose+0x5fc>
movabs $0x400000000,%r11
movabs $0x200000000,%r10
sub    %r9,%r8
mov    %r9d,%edx
and    $0x7fffffff,%edx
add    %rdx,%rdx
mov    %r9,%rsi
shl    $0x21,%rsi
lea    (%r9,%r13,1),%rax
lea    (%r12,%rax,8),%rbx
add    $0x8,%rbx
lea    (%r12,%r9,8),%rax
add    $0x8,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,%rdi
sar    $0x1d,%rdi
movsd  0x0(%rbp,%rdi,1),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,4)
lea    (%rdx,%rcx,1),%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rcx,4)
lea    (%rsi,%r10,1),%rdi
sar    $0x1d,%rdi
movsd  0x0(%rbp,%rdi,1),%xmm0
movsd  %xmm0,(%rax,%rcx,4)
lea    (%rdx,%rcx,1),%edi
add    $0x3,%edi
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,4)
add    $0x4,%rcx
add    %r11,%rsi
add    $0xfffffffffffffffe,%r8
jne    16c0 <decompose+0x5a0>
xor    %ebx,%ebx
mov    %r12,%rdi
mov    %rbp,%rsi
mov    0x30(%rsp),%rdx
mov    %r14d,%ecx
xor    %eax,%eax
call   1040 <F2@plt>
cmpl   $0x0,0x1c(%rsp)
mov    0x28(%rsp),%rcx
jle    17eb <decompose+0x6cb>
lea    (%r12,%r13,8),%rax
add    $0x38,%rax
xor    %ebx,%ebx
nopl   (%rax)
movsd  -0x38(%rax,%rbx,8),%xmm0
subsd  0x0(%rbp,%rbx,8),%xmm0
movsd  -0x30(%rax,%rbx,8),%xmm1
movsd  %xmm0,-0x38(%rax,%rbx,8)
subsd  0x8(%rbp,%rbx,8),%xmm1
movsd  %xmm1,-0x30(%rax,%rbx,8)
movsd  -0x28(%rax,%rbx,8),%xmm0
subsd  0x10(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x28(%rax,%rbx,8)
movsd  -0x20(%rax,%rbx,8),%xmm0
subsd  0x18(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x20(%rax,%rbx,8)
movsd  -0x18(%rax,%rbx,8),%xmm0
subsd  0x20(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rbx,8)
movsd  -0x10(%rax,%rbx,8),%xmm0
subsd  0x28(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rbx,8)
movsd  -0x8(%rax,%rbx,8),%xmm0
subsd  0x30(%rbp,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rbx,8)
movsd  (%rax,%rbx,8),%xmm0
subsd  0x38(%rbp,%rbx,8),%xmm0
movsd  %xmm0,(%rax,%rbx,8)
add    $0x8,%rbx
cmp    %rcx,%rbx
jb     1750 <decompose+0x630>
cmp    %r14d,%ebx
jge    19bf <decompose+0x89f>
mov    %ebx,%eax
mov    %r14d,%ecx
mov    %rcx,%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     1922 <decompose+0x802>
lea    (%rax,%r13,1),%rdx
lea    (%r12,%rdx,8),%rsi
lea    0x0(,%rcx,8),%rdi
add    %rbp,%rdi
cmp    %rdi,%rsi
jae    183d <decompose+0x71d>
lea    (%rcx,%r13,1),%rsi
lea    (%r12,%rsi,8),%rsi
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
cmp    %rsi,%rdi
jb     1922 <decompose+0x802>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1ee8 <decompose+0xdc8>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r12,%rdx,8),%rsi
add    $0x30,%rsi
lea    0x30(,%rax,8),%rdx
add    %rbp,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
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,%rbx
jne    1880 <decompose+0x760>
test   $0x1,%r9b
je     1916 <decompose+0x7f6>
add    %rax,%rdi
movupd 0x0(%rbp,%rdi,8),%xmm0
movupd 0x10(%rbp,%rdi,8),%xmm1
movupd (%r15,%rdi,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r15,%rdi,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%r15,%rdi,8)
movupd %xmm0,0x10(%r15,%rdi,8)
cmp    %r8,%r10
je     19bf <decompose+0x89f>
add    %r8,%rax
mov    %ecx,%esi
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
and    $0x3,%rsi
je     195c <decompose+0x83c>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm0
subsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1940 <decompose+0x820>
cmp    $0x3,%rdx
jb     19bf <decompose+0x89f>
lea    (%r12,%r13,8),%rdx
add    $0x18,%rdx
nopw   0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rax,8),%xmm0
subsd  0x0(%rbp,%rax,8),%xmm0
movsd  -0x10(%rdx,%rax,8),%xmm1
movsd  %xmm0,-0x18(%rdx,%rax,8)
subsd  0x8(%rbp,%rax,8),%xmm1
movsd  %xmm1,-0x10(%rdx,%rax,8)
movsd  -0x8(%rdx,%rax,8),%xmm0
subsd  0x10(%rbp,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
subsd  0x18(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1970 <decompose+0x850>
xor    %ebx,%ebx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    0x30(%rsp),%rdx
mov    %r14d,%ecx
xor    %eax,%eax
call   1030 <PHI3@plt>
cmpl   $0x0,0x1c(%rsp)
mov    0x28(%rsp),%r11
jle    1a9b <decompose+0x97b>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rbx,8),%xmm0
addsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
movsd  0x8(%rbp,%rbx,8),%xmm0
addsd  0x8(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rbx,8)
movsd  0x10(%rbp,%rbx,8),%xmm0
addsd  0x10(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x10(%r12,%rbx,8)
movsd  0x18(%rbp,%rbx,8),%xmm0
addsd  0x18(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x18(%r12,%rbx,8)
movsd  0x20(%rbp,%rbx,8),%xmm0
addsd  0x20(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x20(%r12,%rbx,8)
movsd  0x28(%rbp,%rbx,8),%xmm0
addsd  0x28(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x28(%r12,%rbx,8)
movsd  0x30(%rbp,%rbx,8),%xmm0
addsd  0x30(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x30(%r12,%rbx,8)
movsd  0x38(%rbp,%rbx,8),%xmm0
addsd  0x38(%r12,%rbx,8),%xmm0
movsd  %xmm0,0x38(%r12,%rbx,8)
add    $0x8,%rbx
cmp    %r11,%rbx
jb     19f0 <decompose+0x8d0>
cmp    %r14d,%ebx
jge    1c67 <decompose+0xb47>
mov    %ebx,%eax
mov    %r14d,%ecx
mov    %rcx,%r10
sub    %rax,%r10
cmp    $0x4,%r10
jb     1bc2 <decompose+0xaa2>
lea    (%r12,%rax,8),%rdx
lea    0x0(,%rcx,8),%rsi
add    %rbp,%rsi
cmp    %rsi,%rdx
jae    1ae5 <decompose+0x9c5>
lea    (%r12,%rcx,8),%rdx
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
cmp    %rdx,%rsi
jb     1bc2 <decompose+0xaa2>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1ef9 <decompose+0xdd9>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r12,%rax,8),%rsi
add    $0x30,%rsi
lea    0x30(,%rax,8),%rdx
add    %rbp,%rdx
xor    %edi,%edi
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,%rbx
jne    1b20 <decompose+0xa00>
test   $0x1,%r9b
je     1bb6 <decompose+0xa96>
add    %rax,%rdi
movupd 0x0(%rbp,%rdi,8),%xmm0
movupd 0x10(%rbp,%rdi,8),%xmm1
movupd (%r12,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r12,%rdi,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%r12,%rdi,8)
movupd %xmm0,0x10(%r12,%rdi,8)
cmp    %r8,%r10
je     1c67 <decompose+0xb47>
add    %r8,%rax
mov    %ecx,%esi
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
and    $0x3,%rsi
je     1bfc <decompose+0xadc>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1be0 <decompose+0xac0>
cmp    $0x3,%rdx
jb     1c67 <decompose+0xb47>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
addsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
addsd  0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%r12,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
addsd  0x18(%r12,%rax,8),%xmm0
movsd  %xmm0,0x18(%r12,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1c10 <decompose+0xaf0>
cmpl   $0x0,0x1c(%rsp)
jle    1d2b <decompose+0xc0b>
lea    (%r12,%r13,8),%rcx
add    $0x30,%rcx
xor    %eax,%eax
movapd 0x37c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r12,%rax,8),%xmm1
movupd 0x10(%r12,%rax,8),%xmm2
movupd 0x20(%r12,%rax,8),%xmm3
movupd 0x30(%r12,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r12,%rax,8)
mulpd  %xmm0,%xmm2
movupd %xmm2,0x10(%r12,%rax,8)
mulpd  %xmm0,%xmm3
movupd %xmm3,0x20(%r12,%rax,8)
mulpd  %xmm0,%xmm4
movupd %xmm4,0x30(%r12,%rax,8)
movupd -0x30(%rcx,%rax,8),%xmm1
movupd -0x20(%rcx,%rax,8),%xmm2
movupd -0x10(%rcx,%rax,8),%xmm3
movupd (%rcx,%rax,8),%xmm4
divpd  %xmm0,%xmm1
movupd %xmm1,-0x30(%rcx,%rax,8)
divpd  %xmm0,%xmm2
movupd %xmm2,-0x20(%rcx,%rax,8)
divpd  %xmm0,%xmm3
movupd %xmm3,-0x10(%rcx,%rax,8)
divpd  %xmm0,%xmm4
movupd %xmm4,(%rcx,%rax,8)
add    $0x8,%rax
cmp    %r11,%rax
jb     1c90 <decompose+0xb70>
cmp    %r14d,%eax
jl     1d36 <decompose+0xc16>
jmp    1ed9 <decompose+0xdb9>
xor    %eax,%eax
cmp    %r14d,%eax
jge    1ed9 <decompose+0xdb9>
mov    %eax,%eax
mov    %r14d,%ecx
mov    %rcx,%rdx
sub    %rax,%rdx
cmp    $0x2,%rdx
jb     1e33 <decompose+0xd13>
lea    (%r12,%rax,8),%rdi
lea    (%rax,%r13,1),%rsi
lea    (%rcx,%r13,1),%rbp
lea    (%r12,%rbp,8),%rbp
cmp    %rbp,%rdi
jae    1d71 <decompose+0xc51>
lea    (%r12,%rcx,8),%rdi
lea    (%r12,%rsi,8),%rbp
cmp    %rdi,%rbp
jb     1e33 <decompose+0xd13>
mov    %rdx,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rdi
mov    %rdi,%r9
shr    %r9
add    $0x1,%r9
test   %rdi,%rdi
je     1f0a <decompose+0xdea>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r12,%rsi,8),%rsi
add    $0x10,%rsi
lea    (%r12,%rax,8),%rbx
add    $0x10,%rbx
xor    %edi,%edi
movapd 0x250(%rip),%xmm0
movupd -0x10(%rbx,%rdi,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rbx,%rdi,8)
movupd -0x10(%rsi,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%rsi,%rdi,8)
movupd (%rbx,%rdi,8),%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%rbx,%rdi,8)
movupd (%rsi,%rdi,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rsi,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1db0 <decompose+0xc90>
test   $0x1,%r9b
je     1e27 <decompose+0xd07>
add    %rax,%rdi
movupd (%r12,%rdi,8),%xmm0
movapd 0x1f3(%rip),%xmm1
mulpd  %xmm1,%xmm0
movupd %xmm0,(%r12,%rdi,8)
movupd (%r15,%rdi,8),%xmm0
divpd  %xmm1,%xmm0
movupd %xmm0,(%r15,%rdi,8)
cmp    %r8,%rdx
je     1ed9 <decompose+0xdb9>
add    %r8,%rax
mov    %ecx,%esi
sub    %eax,%esi
mov    %rax,%rdx
not    %rdx
test   $0x1,%sil
je     1e6f <decompose+0xd4f>
movsd  0x1c5(%rip),%xmm0
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  (%r15,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rax
add    %rcx,%rdx
je     1ed9 <decompose+0xdb9>
lea    (%r12,%r13,8),%rdx
add    $0x8,%rdx
movsd  0x18c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  -0x8(%rdx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%rdx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
movsd  (%rdx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1e90 <decompose+0xd70>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    18e5 <decompose+0x7c5>
jmp    1916 <decompose+0x7f6>
xor    %edi,%edi
test   $0x1,%r9b
jne    1b85 <decompose+0xa65>
jmp    1bb6 <decompose+0xa96>
xor    %edi,%edi
test   $0x1,%r9b
jne    1dfc <decompose+0xcdc>
jmp    1e27 <decompose+0xd07>

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

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