void BackSubstitute_Complex_Vector(double *H, double eigen_real[],
                                   double eigen_imag[], int row,
                                   double zero_tolerance, int n) {
  double *pH;
  double *pV;
  double x, y;
  double u[4];
  double v[2];
  double w[2];
  int i, j, k;
  k = row - 1;
  pH = H + n * row;
  if (fabs(pH[k]) > fabs(pH[row - n])) {
    pH[k - n] = -(pH[row] - eigen_real[row]) / pH[k];
    pH[row - n] = -eigen_imag[row] / pH[k];
  } else
    Complex_Division(-pH[row - n], 0.0, pH[k - n] - eigen_real[row],
                     eigen_imag[row], &pH[k - n], &pH[row - n]);
  pH[k] = 1.0;
  pH[row] = 0.0;
  for (i = row - 2, pH = H + n * i; i >= 0; pH -= n, i--) {
    u[0] = pH[i] - eigen_real[row];
    w[0] = pH[row];
    w[1] = 0.0;
    pV = H + k * n;
    for (j = k; j < row; j++, pV += n) {
      w[0] += pH[j] * pV[row - 1];
      w[1] += pH[j] * pV[row];
    }
    if (eigen_imag[i] < 0.0) {
      u[3] = u[0];
      v[0] = w[0];
      v[1] = w[1];
    } else {
      k = i;
      if (eigen_imag[i] == 0.0) {
        Complex_Division(-w[0], -w[1], u[0], eigen_imag[row], &pH[row - 1],
                         &pH[row]);
      } else {
        u[1] = pH[i + 1];
        u[2] = pH[n + i];
        x = eigen_real[i] - eigen_real[row];
        y = 2.0 * x * eigen_imag[row];
        x = x * x + eigen_imag[i] * eigen_imag[i] -
            eigen_imag[row] * eigen_imag[row];
        if (x == 0.0 && y == 0.0)
          x = zero_tolerance * (fabs(u[0]) + fabs(u[1]) + fabs(u[2]) +
                                fabs(u[3]) + fabs(eigen_imag[row]));
        Complex_Division(u[1] * v[0] - u[3] * w[0] + w[1] * eigen_imag[row],
                         u[1] * v[1] - u[3] * w[1] - w[0] * eigen_imag[row], x,
                         y, &pH[row - 1], &pH[row]);
        if (fabs(u[1]) > (fabs(u[3]) + fabs(eigen_imag[row]))) {
          pH[n + row - 1] =
              -w[0] - u[0] * pH[row - 1] + eigen_imag[row] * pH[row] / u[1];
          pH[n + row] =
              -w[1] - u[0] * pH[row] - eigen_imag[row] * pH[row - 1] / u[1];
        } else {
          Complex_Division(-v[0] - u[2] * pH[row - 1], -v[1] - u[2] * pH[row],
                           u[3], eigen_imag[row], &pH[n + row - 1],
                           &pH[n + row]);
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<BackSubstitute_Complex_Vector>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe91(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xe74(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    123b <BackSubstitute_Complex_Vector+0x12b>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x9c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x9c(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x9c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    12c6 <BackSubstitute_Complex_Vector+0x1b6>
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x9c(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rdi
mov    -0x9c(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x1c(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
xorps  %xmm1,%xmm1
mov    $0x4,%al
call   1030 <Complex_Division@plt>
mov    -0x38(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  0xd37(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x94(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x94(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x94(%rbp)
jl     1a1e <BackSubstitute_Complex_Vector+0x90e>
mov    -0x38(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x9c(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1434 <BackSubstitute_Complex_Vector+0x324>
mov    -0x38(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    138d <BackSubstitute_Complex_Vector+0x27d>
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1476 <BackSubstitute_Complex_Vector+0x366>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    19eb <BackSubstitute_Complex_Vector+0x8db>
mov    -0x94(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1523 <BackSubstitute_Complex_Vector+0x413>
jp     1523 <BackSubstitute_Complex_Vector+0x413>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x70(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rdi
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x4,%al
call   1030 <Complex_Division@plt>
jmp    19e6 <BackSubstitute_Complex_Vector+0x8d6>
mov    -0x38(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xa97(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16ae <BackSubstitute_Complex_Vector+0x59e>
jp     16ae <BackSubstitute_Complex_Vector+0x59e>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16ae <BackSubstitute_Complex_Vector+0x59e>
jp     16ae <BackSubstitute_Complex_Vector+0x59e>
movsd  -0x28(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movaps 0x9b7(%rip),%xmm2
pand   %xmm2,%xmm1
movsd  -0x68(%rbp),%xmm2
movaps 0x9a7(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x60(%rbp),%xmm2
movaps 0x993(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
movaps 0x97f(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x963(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
movsd  -0x58(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm3
mov    -0x38(%rbp),%rdi
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x4,%al
call   1030 <Complex_Division@plt>
movsd  -0x68(%rbp),%xmm0
movaps 0x856(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x58(%rbp),%xmm1
movaps 0x846(%rip),%xmm2
pand   %xmm2,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movaps 0x82e(%rip),%xmm3
pand   %xmm3,%xmm2
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1900 <BackSubstitute_Complex_Vector+0x7f0>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x68(%rbp),%xmm1
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x68(%rbp),%xmm1
subsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19e1 <BackSubstitute_Complex_Vector+0x8d1>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  -0x58(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rdi
mov    -0x2c(%rbp),%eax
add    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x2c(%rbp),%eax
add    -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x4,%al
call   1030 <Complex_Division@plt>
jmp    19e6 <BackSubstitute_Complex_Vector+0x8d6>
jmp    19eb <BackSubstitute_Complex_Vector+0x8db>
jmp    19f0 <BackSubstitute_Complex_Vector+0x8e0>
mov    -0x2c(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    1316 <BackSubstitute_Complex_Vector+0x206>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BackSubstitute_Complex_Vector>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movsd  %xmm0,0x88(%rsp)
mov    %rsi,%r10
lea    -0x1(%rcx),%r9d
movslq %ecx,%r14
lea    -0x1(%r14),%rax
mov    %rax,0x8(%rsp)
mov    %r8d,%eax
imul   %ecx,%eax
cltq
mov    %rdi,0x68(%rsp)
lea    (%rdi,%rax,8),%rbx
movsd  -0x8(%rbx,%r14,8),%xmm1
movapd 0xea3(%rip),%xmm2
movapd %xmm1,%xmm3
andpd  %xmm2,%xmm3
mov    %r14d,%eax
sub    %r8d,%eax
cltq
lea    (%rbx,%rax,8),%rsi
movsd  (%rbx,%rax,8),%xmm0
andpd  %xmm0,%xmm2
ucomisd %xmm2,%xmm3
mov    %r8,0x20(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,0x28(%rsp)
mov    %r10,0x10(%rsp)
jbe    11da <BackSubstitute_Complex_Vector+0xca>
movslq %ecx,%r14
movsd  (%rbx,%r14,8),%xmm0
subsd  (%r10,%r14,8),%xmm0
movapd 0xe65(%rip),%xmm2
xorpd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
mov    %r9d,%eax
sub    %r8d,%eax
cltq
movsd  %xmm0,(%rbx,%rax,8)
movsd  (%rdx,%r14,8),%xmm0
xorpd  %xmm2,%xmm0
mov    0x8(%rsp),%rax
divsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rsi)
jmp    1224 <BackSubstitute_Complex_Vector+0x114>
xorpd  0xe2e(%rip),%xmm0
mov    %r9d,%eax
sub    %r8d,%eax
cltq
lea    (%rbx,%rax,8),%rdi
movsd  (%rbx,%rax,8),%xmm2
subsd  (%r10,%r14,8),%xmm2
movsd  (%rdx,%r14,8),%xmm3
xorpd  %xmm1,%xmm1
mov    $0x4,%al
mov    %r9d,%ebp
call   1030 <Complex_Division@plt>
mov    %ebp,%r9d
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
movabs $0x3ff0000000000000,%rax
mov    0x8(%rsp),%rsi
mov    %rax,(%rbx,%rsi,8)
movq   $0x0,(%rbx,%r14,8)
cmp    $0x2,%ecx
jl     1723 <BackSubstitute_Complex_Vector+0x613>
lea    -0x2(%rcx),%eax
mov    %eax,%ebx
imul   %r8d,%eax
cltq
mov    0x68(%rsp),%rsi
lea    (%rsi,%rax,8),%r15
movslq %r8d,%r13
lea    (%r8,%rcx,1),%eax
lea    -0x1(%r8,%rcx,1),%esi
movslq %esi,%rsi
mov    %rsi,0x48(%rsp)
cltq
mov    %rax,0x40(%rsp)
lea    0x0(,%r13,8),%rsi
mov    0x8(%rsp),%rdi
lea    0x0(,%rdi,8),%rax
lea    0x8(,%rdi,8),%rdi
mov    %rdi,0x90(%rsp)
lea    (%rax,%r13,8),%rbp
add    $0x8,%rbp
mov    %r13,0x60(%rsp)
shl    $0x4,%r13
lea    (%rsi,%r14,8),%r12
neg    %rsi
mov    %rsi,0x98(%rsp)
xorpd  %xmm11,%xmm11
jmp    12f7 <BackSubstitute_Complex_Vector+0x1e7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm6,%xmm10
movapd %xmm5,%xmm8
movapd %xmm7,%xmm9
add    0x98(%rsp),%r15
lea    -0x1(%rbx),%rax
test   %rbx,%rbx
mov    %rax,%rbx
jle    1723 <BackSubstitute_Complex_Vector+0x613>
movsd  (%r15,%r14,8),%xmm0
cmp    %ecx,%r9d
jge    1330 <BackSubstitute_Complex_Vector+0x220>
mov    %r9d,%eax
imul   %r8d,%eax
cltq
mov    0x68(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
movslq %r9d,%rdi
mov    %r14d,%esi
mov    %r9d,%r11d
sub    %r9d,%esi
lea    0x1(%rdi),%r9
xorpd  %xmm1,%xmm1
test   $0x1,%sil
jne    1340 <BackSubstitute_Complex_Vector+0x230>
jmp    1377 <BackSubstitute_Complex_Vector+0x267>
xorpd  %xmm5,%xmm5
movapd %xmm0,%xmm7
jmp    13dd <BackSubstitute_Complex_Vector+0x2cd>
nopl   (%rax)
movsd  (%r15,%rdi,8),%xmm5
mov    0x8(%rsp),%rsi
movsd  (%rax,%rsi,8),%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm0,%xmm7
mulsd  (%rax,%r14,8),%xmm5
addsd  %xmm11,%xmm5
mov    0x60(%rsp),%rsi
lea    (%rax,%rsi,8),%rax
mov    %r9,%rdi
movapd %xmm7,%xmm0
movapd %xmm5,%xmm1
cmp    %r9,%r14
mov    0x90(%rsp),%rsi
mov    %r11d,%r9d
je     13dd <BackSubstitute_Complex_Vector+0x2cd>
movapd %xmm0,%xmm7
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdi,8),%xmm0
movsd  0x8(%r15,%rdi,8),%xmm5
movsd  -0x8(%rax,%rsi,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm7,%xmm2
mulsd  (%rax,%r14,8),%xmm0
addsd  %xmm1,%xmm0
movsd  -0x8(%rax,%rbp,1),%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm2,%xmm7
mulsd  (%rax,%r12,1),%xmm5
addsd  %xmm0,%xmm5
add    $0x2,%rdi
add    %r13,%rax
movapd %xmm5,%xmm1
cmp    %rdi,%r14
jne    1390 <BackSubstitute_Complex_Vector+0x280>
movsd  (%r15,%rbx,8),%xmm6
movsd  (%r10,%r14,8),%xmm1
subsd  %xmm1,%xmm6
movsd  (%rdx,%rbx,8),%xmm0
ucomisd %xmm0,%xmm11
ja     12d0 <BackSubstitute_Complex_Vector+0x1c0>
lea    (%r15,%r14,8),%rsi
ucomisd %xmm11,%xmm0
movsd  %xmm9,0x38(%rsp)
movsd  %xmm8,0x30(%rsp)
movapd %xmm10,0x70(%rsp)
jne    1487 <BackSubstitute_Complex_Vector+0x377>
jp     1487 <BackSubstitute_Complex_Vector+0x377>
movapd 0xbe9(%rip),%xmm0
xorpd  %xmm0,%xmm7
xorpd  %xmm0,%xmm5
movsd  (%rdx,%r14,8),%xmm3
mov    0x8(%rsp),%rax
lea    (%r15,%rax,8),%rdi
movapd %xmm7,%xmm0
movapd %xmm5,%xmm1
movapd %xmm6,%xmm2
mov    $0x4,%al
call   1030 <Complex_Division@plt>
movapd 0x70(%rsp),%xmm10
movsd  0x30(%rsp),%xmm8
movsd  0x38(%rsp),%xmm9
xorpd  %xmm11,%xmm11
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%rdx
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%r8
mov    %ebx,%r9d
jmp    12df <BackSubstitute_Complex_Vector+0x1cf>
movsd  0x8(%r15,%rbx,8),%xmm12
mov    0x60(%rsp),%rax
add    %rbx,%rax
movsd  (%r15,%rax,8),%xmm13
movsd  (%r10,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
movapd %xmm2,%xmm3
addsd  %xmm2,%xmm3
movsd  (%rdx,%r14,8),%xmm4
mulsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
subsd  %xmm0,%xmm2
ucomisd %xmm11,%xmm2
movapd %xmm6,0xf0(%rsp)
mov    %rbx,0x58(%rsp)
movapd %xmm13,0xe0(%rsp)
jne    1551 <BackSubstitute_Complex_Vector+0x441>
jp     1551 <BackSubstitute_Complex_Vector+0x441>
ucomisd %xmm11,%xmm3
jne    1551 <BackSubstitute_Complex_Vector+0x441>
jp     1551 <BackSubstitute_Complex_Vector+0x441>
movapd %xmm6,%xmm0
movapd 0xafa(%rip),%xmm6
andpd  %xmm6,%xmm0
movapd %xmm10,%xmm2
unpcklpd %xmm12,%xmm2
andpd  %xmm6,%xmm2
pshufd $0xee,%xmm2,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm13,%xmm0
andpd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movaps %xmm2,0xa0(%rsp)
addsd  %xmm2,%xmm0
movapd %xmm4,%xmm2
andpd  %xmm6,%xmm2
addsd  %xmm0,%xmm2
mulsd  0x88(%rsp),%xmm2
jmp    1570 <BackSubstitute_Complex_Vector+0x460>
movapd %xmm10,%xmm1
unpcklpd %xmm12,%xmm1
movapd 0xa9d(%rip),%xmm0
andpd  %xmm0,%xmm1
movapd %xmm1,0xa0(%rsp)
movapd %xmm7,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm12,%xmm1
mulsd  %xmm9,%xmm1
subsd  %xmm0,%xmm1
movapd %xmm5,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm5,%xmm6
mulsd  %xmm10,%xmm6
movapd %xmm12,%xmm1
mulsd  %xmm8,%xmm1
subsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm1
mov    0x8(%rsp),%rax
lea    (%r15,%rax,8),%rdi
mov    %rdi,0x50(%rsp)
mov    %rsi,%rbx
mov    $0x4,%al
movapd %xmm5,0xc0(%rsp)
movapd %xmm7,0xb0(%rsp)
movapd %xmm12,0xd0(%rsp)
call   1030 <Complex_Division@plt>
mov    0x28(%rsp),%rdx
movsd  (%rdx,%r14,8),%xmm3
movapd %xmm3,%xmm0
andpd  0xa03(%rip),%xmm0
movapd 0xa0(%rsp),%xmm1
addsd  %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    169b <BackSubstitute_Complex_Vector+0x58b>
movapd 0x9f0(%rip),%xmm1
movapd 0xb0(%rsp),%xmm4
xorpd  %xmm1,%xmm4
movapd 0xf0(%rsp),%xmm2
movapd %xmm2,%xmm0
xorpd  %xmm1,%xmm0
mov    0x50(%rsp),%rcx
mulsd  (%rcx),%xmm2
subsd  %xmm2,%xmm4
mulsd  (%r15,%r14,8),%xmm3
movapd 0xd0(%rsp),%xmm2
divsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
mov    0x48(%rsp),%rax
movsd  %xmm3,(%r15,%rax,8)
mulsd  (%r15,%r14,8),%xmm0
movsd  (%rdx,%r14,8),%xmm1
mulsd  (%rcx),%xmm1
subsd  0xc0(%rsp),%xmm0
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    0x40(%rsp),%rax
movsd  %xmm0,(%r15,%rax,8)
jmp    16ed <BackSubstitute_Complex_Vector+0x5dd>
movapd 0xe0(%rsp),%xmm1
xorpd  0x964(%rip),%xmm1
mov    0x50(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rbx),%xmm1
subsd  0x38(%rsp),%xmm0
subsd  0x30(%rsp),%xmm1
mov    0x48(%rsp),%rax
lea    (%r15,%rax,8),%rdi
mov    0x40(%rsp),%rax
lea    (%r15,%rax,8),%rsi
movapd 0x70(%rsp),%xmm2
mov    $0x4,%al
call   1030 <Complex_Division@plt>
mov    0x28(%rsp),%rdx
mov    0x58(%rsp),%rbx
mov    %ebx,%r9d
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%r10
xorpd  %xmm11,%xmm11
movsd  0x38(%rsp),%xmm9
movsd  0x30(%rsp),%xmm8
movapd 0x70(%rsp),%xmm10
jmp    12df <BackSubstitute_Complex_Vector+0x1cf>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @BackSubstitute_Complex_Vector(double* %0, double* %1, double* %2, i32 %3, double %4, i32 %5) {
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca double
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca double
%16 = alloca double
%17 = alloca [4 x double]
%18 = alloca [2 x double]
%19 = alloca [2 x double]
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store double* %0, double** %7
store double* %1, double** %8
store double* %2, double** %9
store i32 %3, i32* %10
store double %4, double* %11
store i32 %5, i32* %12
%23 = load i32, i32* %10
%24 = sub nsw i32 %23, 1
store i32 %24, i32* %22
%25 = load double*, double** %7
%26 = load i32, i32* %12
%27 = load i32, i32* %10
%28 = mul nsw i32 %26, %27
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %25, i64 %29
store double* %30, double** %13
%31 = load double*, double** %13
%32 = load i32, i32* %22
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds double, double* %31, i64 %33
%35 = load double, double* %34
%36 = call double @llvm.fabs.f64(double %35)
%37 = load double*, double** %13
%38 = load i32, i32* %10
%39 = load i32, i32* %12
%40 = sub nsw i32 %38, %39
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %37, i64 %41
%43 = load double, double* %42
%44 = call double @llvm.fabs.f64(double %43)
%45 = fcmp ogt double %36, %44
br i1 %45, label %46, label %89
46: ; preds = %6
%47 = load double*, double** %13
%48 = load i32, i32* %10
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds double, double* %47, i64 %49
%51 = load double, double* %50
%52 = load double*, double** %8
%53 = load i32, i32* %10
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fsub double %51, %56
%58 = fneg double %57
%59 = load double*, double** %13
%60 = load i32, i32* %22
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load double, double* %62
%64 = fdiv double %58, %63
%65 = load double*, double** %13
%66 = load i32, i32* %22
%67 = load i32, i32* %12
%68 = sub nsw i32 %66, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %65, i64 %69
store double %64, double* %70
%71 = load double*, double** %9
%72 = load i32, i32* %10
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %71, i64 %73
%75 = load double, double* %74
%76 = fneg double %75
%77 = load double*, double** %13
%78 = load i32, i32* %22
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
%81 = load double, double* %80
%82 = fdiv double %76, %81
%83 = load double*, double** %13
%84 = load i32, i32* %10
%85 = load i32, i32* %12
%86 = sub nsw i32 %84, %85
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds double, double* %83, i64 %87
store double %82, double* %88
br label %129
89: ; preds = %6
%90 = load double*, double** %13
%91 = load i32, i32* %10
%92 = load i32, i32* %12
%93 = sub nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %90, i64 %94
%96 = load double, double* %95
%97 = fneg double %96
%98 = load double*, double** %13
%99 = load i32, i32* %22
%100 = load i32, i32* %12
%101 = sub nsw i32 %99, %100
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %98, i64 %102
%104 = load double, double* %103
%105 = load double*, double** %8
%106 = load i32, i32* %10
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = fsub double %104, %109
%111 = load double*, double** %9
%112 = load i32, i32* %10
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds double, double* %111, i64 %113
%115 = load double, double* %114
%116 = load double*, double** %13
%117 = load i32, i32* %22
%118 = load i32, i32* %12
%119 = sub nsw i32 %117, %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %116, i64 %120
%122 = load double*, double** %13
%123 = load i32, i32* %10
%124 = load i32, i32* %12
%125 = sub nsw i32 %123, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %122, i64 %126
%128 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %97, double 0.000000e+00, double %110, double %115, double* %121, double* %127)
br label %129
129: ; preds = %89, %46
%130 = load double*, double** %13
%131 = load i32, i32* %22
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %130, i64 %132
store double 1.000000e+00, double* %133
%134 = load double*, double** %13
%135 = load i32, i32* %10
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
store double 0.000000e+00, double* %137
%138 = load i32, i32* %10
%139 = sub nsw i32 %138, 2
store i32 %139, i32* %20
%140 = load double*, double** %7
%141 = load i32, i32* %12
%142 = load i32, i32* %20
%143 = mul nsw i32 %141, %142
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds double, double* %140, i64 %144
store double* %145, double** %13
br label %146
146: ; preds = %541, %129
%147 = load i32, i32* %20
%148 = icmp sge i32 %147, 0
br i1 %148, label %149, label %549
149: ; preds = %146
%150 = load double*, double** %13
%151 = load i32, i32* %20
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %150, i64 %152
%154 = load double, double* %153
%155 = load double*, double** %8
%156 = load i32, i32* %10
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %155, i64 %157
%159 = load double, double* %158
%160 = fsub double %154, %159
%161 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 0
store double %160, double* %161
%162 = load double*, double** %13
%163 = load i32, i32* %10
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
%166 = load double, double* %165
%167 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
store double %166, double* %167
%168 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
store double 0.000000e+00, double* %168
%169 = load double*, double** %7
%170 = load i32, i32* %22
%171 = load i32, i32* %12
%172 = mul nsw i32 %170, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %169, i64 %173
store double* %174, double** %14
%175 = load i32, i32* %22
store i32 %175, i32* %21
br label %176
176: ; preds = %208, %149
%177 = load i32, i32* %21
%178 = load i32, i32* %10
%179 = icmp slt i32 %177, %178
br i1 %179, label %180, label %215
180: ; preds = %176
%181 = load double*, double** %13
%182 = load i32, i32* %21
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %181, i64 %183
%185 = load double, double* %184
%186 = load double*, double** %14
%187 = load i32, i32* %10
%188 = sub nsw i32 %187, 1
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %186, i64 %189
%191 = load double, double* %190
%192 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
%193 = load double, double* %192
%194 = call double @llvm.fmuladd.f64(double %185, double %191, double %193)
store double %194, double* %192
%195 = load double*, double** %13
%196 = load i32, i32* %21
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %195, i64 %197
%199 = load double, double* %198
%200 = load double*, double** %14
%201 = load i32, i32* %10
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
%204 = load double, double* %203
%205 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
%206 = load double, double* %205
%207 = call double @llvm.fmuladd.f64(double %199, double %204, double %206)
store double %207, double* %205
br label %208
208: ; preds = %180
%209 = load i32, i32* %21
%210 = add nsw i32 %209, 1
store i32 %210, i32* %21
%211 = load i32, i32* %12
%212 = load double*, double** %14
%213 = sext i32 %211 to i64
%214 = getelementptr inbounds double, double* %212, i64 %213
store double* %214, double** %14
br label %176
215: ; preds = %176
%216 = load double*, double** %9
%217 = load i32, i32* %20
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = fcmp olt double %220, 0.000000e+00
br i1 %221, label %222, label %232
222: ; preds = %215
%223 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 0
%224 = load double, double* %223
%225 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 3
store double %224, double* %225
%226 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
%227 = load double, double* %226
%228 = getelementptr inbounds [2 x double], [2 x double]* %18, i64 0, i64 0
store double %227, double* %228
%229 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
%230 = load double, double* %229
%231 = getelementptr inbounds [2 x double], [2 x double]* %18, i64 0, i64 1
store double %230, double* %231
br label %540
232: ; preds = %215
%233 = load i32, i32* %20
store i32 %233, i32* %22
%234 = load double*, double** %9
%235 = load i32, i32* %20
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds double, double* %234, i64 %236
%238 = load double, double* %237
%239 = fcmp oeq double %238, 0.000000e+00
br i1 %239, label %240, label %264
240: ; preds = %232
%241 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
%242 = load double, double* %241
%243 = fneg double %242
%244 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
%245 = load double, double* %244
%246 = fneg double %245
%247 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 0
%248 = load double, double* %247
%249 = load double*, double** %9
%250 = load i32, i32* %10
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds double, double* %249, i64 %251
%253 = load double, double* %252
%254 = load double*, double** %13
%255 = load i32, i32* %10
%256 = sub nsw i32 %255, 1
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %254, i64 %257
%259 = load double*, double** %13
%260 = load i32, i32* %10
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double, double* %259, i64 %261
%263 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %243, double %246, double %248, double %253, double* %258, double* %262)
br label %539
264: ; preds = %232
%265 = load double*, double** %13
%266 = load i32, i32* %20
%267 = add nsw i32 %266, 1
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds double, double* %265, i64 %268
%270 = load double, double* %269
%271 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
store double %270, double* %271
%272 = load double*, double** %13
%273 = load i32, i32* %12
%274 = load i32, i32* %20
%275 = add nsw i32 %273, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %272, i64 %276
%278 = load double, double* %277
%279 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 2
store double %278, double* %279
%280 = load double*, double** %8
%281 = load i32, i32* %20
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds double, double* %280, i64 %282
%284 = load double, double* %283
%285 = load double*, double** %8
%286 = load i32, i32* %10
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double, double* %285, i64 %287
%289 = load double, double* %288
%290 = fsub double %284, %289
store double %290, double* %15
%291 = load double, double* %15
%292 = fmul double 2.000000e+00, %291
%293 = load double*, double** %9
%294 = load i32, i32* %10
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %293, i64 %295
%297 = load double, double* %296
%298 = fmul double %292, %297
store double %298, double* %16
%299 = load double, double* %15
%300 = load double, double* %15
%301 = load double*, double** %9
%302 = load i32, i32* %20
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds double, double* %301, i64 %303
%305 = load double, double* %304
%306 = load double*, double** %9
%307 = load i32, i32* %20
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %306, i64 %308
%310 = load double, double* %309
%311 = fmul double %305, %310
%312 = call double @llvm.fmuladd.f64(double %299, double %300, double %311)
%313 = load double*, double** %9
%314 = load i32, i32* %10
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds double, double* %313, i64 %315
%317 = load double, double* %316
%318 = load double*, double** %9
%319 = load i32, i32* %10
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %318, i64 %320
%322 = load double, double* %321
%323 = fneg double %317
%324 = call double @llvm.fmuladd.f64(double %323, double %322, double %312)
store double %324, double* %15
%325 = load double, double* %15
%326 = fcmp oeq double %325, 0.000000e+00
br i1 %326, label %327, label %355
327: ; preds = %264
%328 = load double, double* %16
%329 = fcmp oeq double %328, 0.000000e+00
br i1 %329, label %330, label %355
330: ; preds = %327
%331 = load double, double* %11
%332 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 0
%333 = load double, double* %332
%334 = call double @llvm.fabs.f64(double %333)
%335 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
%336 = load double, double* %335
%337 = call double @llvm.fabs.f64(double %336)
%338 = fadd double %334, %337
%339 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 2
%340 = load double, double* %339
%341 = call double @llvm.fabs.f64(double %340)
%342 = fadd double %338, %341
%343 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 3
%344 = load double, double* %343
%345 = call double @llvm.fabs.f64(double %344)
%346 = fadd double %342, %345
%347 = load double*, double** %9
%348 = load i32, i32* %10
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %347, i64 %349
%351 = load double, double* %350
%352 = call double @llvm.fabs.f64(double %351)
%353 = fadd double %346, %352
%354 = fmul double %331, %353
store double %354, double* %15
br label %355
355: ; preds = %330, %327, %264
%356 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
%357 = load double, double* %356
%358 = getelementptr inbounds [2 x double], [2 x double]* %18, i64 0, i64 0
%359 = load double, double* %358
%360 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 3
%361 = load double, double* %360
%362 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
%363 = load double, double* %362
%364 = fmul double %361, %363
%365 = fneg double %364
%366 = call double @llvm.fmuladd.f64(double %357, double %359, double %365)
%367 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
%368 = load double, double* %367
%369 = load double*, double** %9
%370 = load i32, i32* %10
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %369, i64 %371
%373 = load double, double* %372
%374 = call double @llvm.fmuladd.f64(double %368, double %373, double %366)
%375 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
%376 = load double, double* %375
%377 = getelementptr inbounds [2 x double], [2 x double]* %18, i64 0, i64 1
%378 = load double, double* %377
%379 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 3
%380 = load double, double* %379
%381 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
%382 = load double, double* %381
%383 = fmul double %380, %382
%384 = fneg double %383
%385 = call double @llvm.fmuladd.f64(double %376, double %378, double %384)
%386 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
%387 = load double, double* %386
%388 = load double*, double** %9
%389 = load i32, i32* %10
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds double, double* %388, i64 %390
%392 = load double, double* %391
%393 = fneg double %387
%394 = call double @llvm.fmuladd.f64(double %393, double %392, double %385)
%395 = load double, double* %15
%396 = load double, double* %16
%397 = load double*, double** %13
%398 = load i32, i32* %10
%399 = sub nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %397, i64 %400
%402 = load double*, double** %13
%403 = load i32, i32* %10
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %402, i64 %404
%406 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %374, double %394, double %395, double %396, double* %401, double* %405)
%407 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
%408 = load double, double* %407
%409 = call double @llvm.fabs.f64(double %408)
%410 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 3
%411 = load double, double* %410
%412 = call double @llvm.fabs.f64(double %411)
%413 = load double*, double** %9
%414 = load i32, i32* %10
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %413, i64 %415
%417 = load double, double* %416
%418 = call double @llvm.fabs.f64(double %417)
%419 = fadd double %412, %418
%420 = fcmp ogt double %409, %419
br i1 %420, label %421, label %491
421: ; preds = %355
%422 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 0
%423 = load double, double* %422
%424 = fneg double %423
%425 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 0
%426 = load double, double* %425
%427 = load double*, double** %13
%428 = load i32, i32* %10
%429 = sub nsw i32 %428, 1
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %427, i64 %430
%432 = load double, double* %431
%433 = fneg double %426
%434 = call double @llvm.fmuladd.f64(double %433, double %432, double %424)
%435 = load double*, double** %9
%436 = load i32, i32* %10
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds double, double* %435, i64 %437
%439 = load double, double* %438
%440 = load double*, double** %13
%441 = load i32, i32* %10
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %440, i64 %442
%444 = load double, double* %443
%445 = fmul double %439, %444
%446 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
%447 = load double, double* %446
%448 = fdiv double %445, %447
%449 = fadd double %434, %448
%450 = load double*, double** %13
%451 = load i32, i32* %12
%452 = load i32, i32* %10
%453 = add nsw i32 %451, %452
%454 = sub nsw i32 %453, 1
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %450, i64 %455
store double %449, double* %456
%457 = getelementptr inbounds [2 x double], [2 x double]* %19, i64 0, i64 1
%458 = load double, double* %457
%459 = fneg double %458
%460 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 0
%461 = load double, double* %460
%462 = load double*, double** %13
%463 = load i32, i32* %10
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %462, i64 %464
%466 = load double, double* %465
%467 = fneg double %461
%468 = call double @llvm.fmuladd.f64(double %467, double %466, double %459)
%469 = load double*, double** %9
%470 = load i32, i32* %10
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %469, i64 %471
%473 = load double, double* %472
%474 = load double*, double** %13
%475 = load i32, i32* %10
%476 = sub nsw i32 %475, 1
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %474, i64 %477
%479 = load double, double* %478
%480 = fmul double %473, %479
%481 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 1
%482 = load double, double* %481
%483 = fdiv double %480, %482
%484 = fsub double %468, %483
%485 = load double*, double** %13
%486 = load i32, i32* %12
%487 = load i32, i32* %10
%488 = add nsw i32 %486, %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %485, i64 %489
store double %484, double* %490
br label %538
491: ; preds = %355
%492 = getelementptr inbounds [2 x double], [2 x double]* %18, i64 0, i64 0
%493 = load double, double* %492
%494 = fneg double %493
%495 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 2
%496 = load double, double* %495
%497 = load double*, double** %13
%498 = load i32, i32* %10
%499 = sub nsw i32 %498, 1
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %497, i64 %500
%502 = load double, double* %501
%503 = fneg double %496
%504 = call double @llvm.fmuladd.f64(double %503, double %502, double %494)
%505 = getelementptr inbounds [2 x double], [2 x double]* %18, i64 0, i64 1
%506 = load double, double* %505
%507 = fneg double %506
%508 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 2
%509 = load double, double* %508
%510 = load double*, double** %13
%511 = load i32, i32* %10
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %510, i64 %512
%514 = load double, double* %513
%515 = fneg double %509
%516 = call double @llvm.fmuladd.f64(double %515, double %514, double %507)
%517 = getelementptr inbounds [4 x double], [4 x double]* %17, i64 0, i64 3
%518 = load double, double* %517
%519 = load double*, double** %9
%520 = load i32, i32* %10
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double, double* %519, i64 %521
%523 = load double, double* %522
%524 = load double*, double** %13
%525 = load i32, i32* %12
%526 = load i32, i32* %10
%527 = add nsw i32 %525, %526
%528 = sub nsw i32 %527, 1
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double, double* %524, i64 %529
%531 = load double*, double** %13
%532 = load i32, i32* %12
%533 = load i32, i32* %10
%534 = add nsw i32 %532, %533
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds double, double* %531, i64 %535
%537 = call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %504, double %516, double %518, double %523, double* %530, double* %536)
br label %538
538: ; preds = %491, %421
br label %539
539: ; preds = %538, %240
br label %540
540: ; preds = %539, %222
br label %541
541: ; preds = %540
%542 = load i32, i32* %12
%543 = load double*, double** %13
%544 = sext i32 %542 to i64
%545 = sub i64 0, %544
%546 = getelementptr inbounds double, double* %543, i64 %545
store double* %546, double** %13
%547 = load i32, i32* %20
%548 = add nsw i32 %547, -1
store i32 %548, i32* %20
br label %146
549: ; preds = %146
ret void
}

LLVM IR (-O2):
define void @BackSubstitute_Complex_Vector(double* %0, double* nocapture %1, double* nocapture %2, i32 %3, double %4, i32 %5) {
%7 = add nsw i32 %3, -1
%8 = mul nsw i32 %5, %3
%9 = sext i32 %8 to i64
%10 = getelementptr inbounds double, double* %0, i64 %9
%11 = sext i32 %7 to i64
%12 = getelementptr inbounds double, double* %10, i64 %11
%13 = load double, double* %12
%14 = tail call double @llvm.fabs.f64(double %13)
%15 = sub nsw i32 %3, %5
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds double, double* %10, i64 %16
%18 = load double, double* %17
%19 = tail call double @llvm.fabs.f64(double %18)
%20 = fcmp ogt double %14, %19
br i1 %20, label %21, label %38
21: ; preds = %6
%22 = sext i32 %3 to i64
%23 = getelementptr inbounds double, double* %10, i64 %22
%24 = load double, double* %23
%25 = getelementptr inbounds double, double* %1, i64 %22
%26 = load double, double* %25
%27 = fsub double %24, %26
%28 = fneg double %27
%29 = fdiv double %28, %13
%30 = sub nsw i32 %7, %5
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %10, i64 %31
store double %29, double* %32
%33 = getelementptr inbounds double, double* %2, i64 %22
%34 = load double, double* %33
%35 = fneg double %34
%36 = load double, double* %12
%37 = fdiv double %35, %36
store double %37, double* %17
br label %51
38: ; preds = %6
%39 = fneg double %18
%40 = sub nsw i32 %7, %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %10, i64 %41
%43 = load double, double* %42
%44 = sext i32 %3 to i64
%45 = getelementptr inbounds double, double* %1, i64 %44
%46 = load double, double* %45
%47 = fsub double %43, %46
%48 = getelementptr inbounds double, double* %2, i64 %44
%49 = load double, double* %48
%50 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %39, double 0.000000e+00, double %47, double %49, double* %42, double* %17)
br label %51
51: ; preds = %38, %21
%52 = phi i64 [ %44, %38 ], [ %22, %21 ]
store double 1.000000e+00, double* %12
%53 = getelementptr inbounds double, double* %10, i64 %52
store double 0.000000e+00, double* %53
%54 = add i32 %3, -2
%55 = icmp sgt i32 %3, 1
br i1 %55, label %56, label %246
56: ; preds = %51
%57 = mul nsw i32 %54, %5
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %0, i64 %58
%60 = getelementptr inbounds double, double* %1, i64 %52
%61 = sext i32 %5 to i64
%62 = getelementptr inbounds double, double* %2, i64 %52
%63 = add nsw i32 %5, %3
%64 = add nsw i32 %63, -1
%65 = sext i32 %64 to i64
%66 = sext i32 %63 to i64
%67 = sub nsw i64 0, %61
%68 = zext i32 %54 to i64
br label %69
69: ; preds = %56, %238
%70 = phi i64 [ %68, %56 ], [ %244, %238 ]
%71 = phi i32 [ %7, %56 ], [ %242, %238 ]
%72 = phi double [ undef, %56 ], [ %241, %238 ]
%73 = phi double [ undef, %56 ], [ %240, %238 ]
%74 = phi double* [ %59, %56 ], [ %243, %238 ]
%75 = phi double [ undef, %56 ], [ %239, %238 ]
%76 = getelementptr inbounds double, double* %74, i64 %70
%77 = load double, double* %76
%78 = load double, double* %60
%79 = fsub double %77, %78
%80 = getelementptr inbounds double, double* %74, i64 %52
%81 = load double, double* %80
%82 = icmp slt i32 %71, %3
br i1 %82, label %83, label %137
83: ; preds = %69
%84 = mul nsw i32 %71, %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds double, double* %0, i64 %85
%87 = sext i32 %71 to i64
%88 = sub nsw i64 %52, %87
%89 = add nsw i64 %87, 1
%90 = and i64 %88, 1
%91 = icmp eq i64 %90, 0
br i1 %91, label %103, label %92
92: ; preds = %83
%93 = getelementptr inbounds double, double* %74, i64 %87
%94 = load double, double* %93
%95 = getelementptr inbounds double, double* %86, i64 %11
%96 = load double, double* %95
%97 = tail call double @llvm.fmuladd.f64(double %94, double %96, double %81)
%98 = getelementptr inbounds double, double* %86, i64 %52
%99 = load double, double* %98
%100 = tail call double @llvm.fmuladd.f64(double %94, double %99, double 0.000000e+00)
%101 = add nsw i64 %87, 1
%102 = getelementptr inbounds double, double* %86, i64 %61
br label %103
103: ; preds = %92, %83
%104 = phi double [ undef, %83 ], [ %97, %92 ]
%105 = phi double [ undef, %83 ], [ %100, %92 ]
%106 = phi i64 [ %87, %83 ], [ %101, %92 ]
%107 = phi double [ %81, %83 ], [ %97, %92 ]
%108 = phi double [ 0.000000e+00, %83 ], [ %100, %92 ]
%109 = phi double* [ %86, %83 ], [ %102, %92 ]
%110 = icmp eq i64 %52, %89
br i1 %110, label %137, label %111
111: ; preds = %103, %111
%112 = phi i64 [ %134, %111 ], [ %106, %103 ]
%113 = phi double [ %130, %111 ], [ %107, %103 ]
%114 = phi double [ %133, %111 ], [ %108, %103 ]
%115 = phi double* [ %135, %111 ], [ %109, %103 ]
%116 = getelementptr inbounds double, double* %74, i64 %112
%117 = load double, double* %116
%118 = getelementptr inbounds double, double* %115, i64 %11
%119 = load double, double* %118
%120 = tail call double @llvm.fmuladd.f64(double %117, double %119, double %113)
%121 = getelementptr inbounds double, double* %115, i64 %52
%122 = load double, double* %121
%123 = tail call double @llvm.fmuladd.f64(double %117, double %122, double %114)
%124 = add nsw i64 %112, 1
%125 = getelementptr inbounds double, double* %115, i64 %61
%126 = getelementptr inbounds double, double* %74, i64 %124
%127 = load double, double* %126
%128 = getelementptr inbounds double, double* %125, i64 %11
%129 = load double, double* %128
%130 = tail call double @llvm.fmuladd.f64(double %127, double %129, double %120)
%131 = getelementptr inbounds double, double* %125, i64 %52
%132 = load double, double* %131
%133 = tail call double @llvm.fmuladd.f64(double %127, double %132, double %123)
%134 = add nsw i64 %112, 2
%135 = getelementptr inbounds double, double* %125, i64 %61
%136 = icmp eq i64 %134, %52
br i1 %136, label %137, label %111
137: ; preds = %103, %111, %69
%138 = phi double [ 0.000000e+00, %69 ], [ %105, %103 ], [ %133, %111 ]
%139 = phi double [ %81, %69 ], [ %104, %103 ], [ %130, %111 ]
%140 = getelementptr inbounds double, double* %2, i64 %70
%141 = load double, double* %140
%142 = fcmp olt double %141, 0.000000e+00
br i1 %142, label %238, label %143
143: ; preds = %137
%144 = fcmp oeq double %141, 0.000000e+00
%145 = trunc i64 %70 to i32
br i1 %144, label %146, label %152
146: ; preds = %143
%147 = fneg double %139
%148 = fneg double %138
%149 = load double, double* %62
%150 = getelementptr inbounds double, double* %74, i64 %11
%151 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %147, double %148, double %79, double %149, double* %150, double* %80)
br label %238
152: ; preds = %143
%153 = add nsw i64 %70, 1
%154 = getelementptr inbounds double, double* %74, i64 %153
%155 = load double, double* %154
%156 = add nsw i64 %70, %61
%157 = getelementptr inbounds double, double* %74, i64 %156
%158 = load double, double* %157
%159 = getelementptr inbounds double, double* %1, i64 %70
%160 = load double, double* %159
%161 = fsub double %160, %78
%162 = fmul double %161, 2.000000e+00
%163 = load double, double* %62
%164 = fmul double %163, %162
%165 = fmul double %141, %141
%166 = tail call double @llvm.fmuladd.f64(double %161, double %161, double %165)
%167 = fneg double %163
%168 = tail call double @llvm.fmuladd.f64(double %167, double %163, double %166)
%169 = fcmp oeq double %168, 0.000000e+00
%170 = fcmp oeq double %164, 0.000000e+00
%171 = select i1 %169, i1 %170, i1 false
br i1 %171, label %176, label %172
172: ; preds = %152
%173 = insertelement <2 x double> poison, double %75, i64 0
%174 = insertelement <2 x double> %173, double %155, i64 1
%175 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %174)
br label %190
176: ; preds = %152
%177 = tail call double @llvm.fabs.f64(double %79)
%178 = insertelement <2 x double> poison, double %75, i64 0
%179 = insertelement <2 x double> %178, double %155, i64 1
%180 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %179)
%181 = extractelement <2 x double> %180, i64 1
%182 = fadd double %177, %181
%183 = tail call double @llvm.fabs.f64(double %158)
%184 = fadd double %182, %183
%185 = extractelement <2 x double> %180, i64 0
%186 = fadd double %185, %184
%187 = tail call double @llvm.fabs.f64(double %163)
%188 = fadd double %186, %187
%189 = fmul double %188, %4
br label %190
190: ; preds = %172, %176
%191 = phi double [ %168, %172 ], [ %189, %176 ]
%192 = phi <2 x double> [ %175, %172 ], [ %180, %176 ]
%193 = fneg double %75
%194 = fmul double %139, %193
%195 = tail call double @llvm.fmuladd.f64(double %155, double %72, double %194)
%196 = tail call double @llvm.fmuladd.f64(double %138, double %163, double %195)
%197 = fmul double %138, %193
%198 = tail call double @llvm.fmuladd.f64(double %155, double %73, double %197)
%199 = fneg double %139
%200 = tail call double @llvm.fmuladd.f64(double %199, double %163, double %198)
%201 = getelementptr inbounds double, double* %74, i64 %11
%202 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %196, double %200, double %191, double %164, double* %201, double* %80)
%203 = load double, double* %62
%204 = tail call double @llvm.fabs.f64(double %203)
%205 = extractelement <2 x double> %192, i64 0
%206 = fadd double %205, %204
%207 = extractelement <2 x double> %192, i64 1
%208 = fcmp ogt double %207, %206
br i1 %208, label %209, label %227
209: ; preds = %190
%210 = load double, double* %201
%211 = fneg double %79
%212 = tail call double @llvm.fmuladd.f64(double %211, double %210, double %199)
%213 = load double, double* %80
%214 = fmul double %203, %213
%215 = fdiv double %214, %155
%216 = fadd double %212, %215
%217 = getelementptr inbounds double, double* %74, i64 %65
store double %216, double* %217
%218 = fneg double %138
%219 = load double, double* %80
%220 = tail call double @llvm.fmuladd.f64(double %211, double %219, double %218)
%221 = load double, double* %62
%222 = load double, double* %201
%223 = fmul double %221, %222
%224 = fdiv double %223, %155
%225 = fsub double %220, %224
%226 = getelementptr inbounds double, double* %74, i64 %66
store double %225, double* %226
br label %238
227: ; preds = %190
%228 = fneg double %72
%229 = load double, double* %201
%230 = fneg double %158
%231 = tail call double @llvm.fmuladd.f64(double %230, double %229, double %228)
%232 = fneg double %73
%233 = load double, double* %80
%234 = tail call double @llvm.fmuladd.f64(double %230, double %233, double %232)
%235 = getelementptr inbounds double, double* %74, i64 %65
%236 = getelementptr inbounds double, double* %74, i64 %66
%237 = tail call i32 (double, double, double, double, double*, double*, ...) bitcast (i32 (...)* @Complex_Division to i32 (double, double, double, double, double*, double*, ...)*)(double %231, double %234, double %75, double %203, double* %235, double* %236)
br label %238
238: ; preds = %137, %209, %227, %146
%239 = phi double [ %75, %146 ], [ %75, %209 ], [ %75, %227 ], [ %79, %137 ]
%240 = phi double [ %73, %146 ], [ %73, %209 ], [ %73, %227 ], [ %138, %137 ]
%241 = phi double [ %72, %146 ], [ %72, %209 ], [ %72, %227 ], [ %139, %137 ]
%242 = phi i32 [ %145, %146 ], [ %145, %209 ], [ %145, %227 ], [ %71, %137 ]
%243 = getelementptr inbounds double, double* %74, i64 %67
%244 = add nsw i64 %70, -1
%245 = icmp sgt i64 %70, 0
br i1 %245, label %69, label %246
246: ; preds = %238, %51
ret void
}