#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double *create_1D_array(int);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ solveTXeqB(double *, double *, double *, double *, double *,
                              int);
void solve_real_virt(double xr[2], double xv[311], double Trr[2][2],
                     double *Trv[2], double *Tvr[2], double *Tvv[3],
                     double sr[2], double sv[311]) {
  double *Tvv_inv_Tvr[2];
  double *Tvv_inv_sv;
  double Trr_new[2][2];
  double sr_new[2];
  unsigned i, j, b;
  double det;
  unsigned NSUBDIFF;
  NSUBDIFF = 140 - 80 / 2;
  for (i = 0; i < 2; i++)
    Tvv_inv_Tvr[i] = create_1D_array(311);
  Tvv_inv_sv = create_1D_array(311);
  for (i = 0; i < 2; i++) {
    for (b = 0; b < NSUBDIFF; b++)
      Tvv_inv_Tvr[i][b] = Tvr[i][b] / Tvv[0][b];
    for (b = 140 + 80 / 2; b < 311; b++)
      Tvv_inv_Tvr[i][b] = Tvr[i][b] / Tvv[0][b];
    solveTXeqB(Tvv[0] + NSUBDIFF, Tvv[2] + NSUBDIFF, Tvv[1] + NSUBDIFF,
               Tvv_inv_Tvr[i] + NSUBDIFF, Tvr[i] + NSUBDIFF, 80);
  }
  for (i = 0; i < 2; i++)
    for (j = 0; j < 2; j++) {
      Trr_new[i][j] = Trr[i][j];
      for (b = 0; b < 311; b++)
        Trr_new[i][j] -= Trv[i][b] * Tvv_inv_Tvr[j][b];
    }
  for (b = 0; b < NSUBDIFF; b++)
    Tvv_inv_sv[b] = sv[b] / Tvv[0][b];
  for (b = 140 + 80 / 2; b < 311; b++)
    Tvv_inv_sv[b] = sv[b] / Tvv[0][b];
  solveTXeqB(Tvv[0] + NSUBDIFF, Tvv[2] + NSUBDIFF, Tvv[1] + NSUBDIFF,
             Tvv_inv_sv + NSUBDIFF, sv + NSUBDIFF, 80);
  for (i = 0; i < 2; i++) {
    sr_new[i] = sr[i];
    for (b = 0; b < 311; b++)
      sr_new[i] -= Trv[i][b] * Tvv_inv_sv[b];
  }
  det = Trr_new[0][0] * Trr_new[1][1] - Trr_new[0][1] * Trr_new[1][0];
  xr[0] = (Trr_new[1][1] * sr_new[0] - Trr_new[0][1] * sr_new[1]) / det;
  xr[1] = (Trr_new[0][0] * sr_new[1] - Trr_new[1][0] * sr_new[0]) / det;
  for (b = 0; b < 311; b++)
    xv[b] =
        Tvv_inv_sv[b] - Tvv_inv_Tvr[0][b] * xr[0] - Tvv_inv_Tvr[1][b] * xr[1];
  for (i = 0; i < 2; i++)
    free(Tvv_inv_Tvr[i]);
  free(Tvv_inv_sv);
}


x86 assembly (clang, -O0):
<solve_real_virt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x64,-0x9c(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x2,-0x84(%rbp)
jae    11a8 <solve_real_virt+0x78>
mov    $0x137,%edi
call   1040 <create_1D_array@plt>
mov    %rax,%rcx
mov    -0x84(%rbp),%eax
mov    %rcx,-0x40(%rbp,%rax,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    116f <solve_real_virt+0x3f>
mov    $0x137,%edi
call   1040 <create_1D_array@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x84(%rbp)
cmpl   $0x2,-0x84(%rbp)
jae    133e <solve_real_virt+0x20e>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jae    123e <solve_real_virt+0x10e>
mov    -0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x8c(%rbp),%ecx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x84(%rbp),%eax
mov    -0x40(%rbp,%rax,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    11d7 <solve_real_virt+0xa7>
movl   $0xb4,-0x8c(%rbp)
cmpl   $0x137,-0x8c(%rbp)
jae    12ad <solve_real_virt+0x17d>
mov    -0x28(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x8c(%rbp),%ecx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x84(%rbp),%eax
mov    -0x40(%rbp,%rax,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1248 <solve_real_virt+0x118>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rsi
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdx
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x84(%rbp),%eax
mov    -0x40(%rbp,%rax,8),%rcx
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    -0x84(%rbp),%r8d
mov    (%rax,%r8,8),%r8
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%r8
mov    $0x50,%r9d
call   1050 <solveTXeqB@plt>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    11c0 <solve_real_virt+0x90>
movl   $0x0,-0x84(%rbp)
cmpl   $0x2,-0x84(%rbp)
jae    1477 <solve_real_virt+0x347>
movl   $0x0,-0x88(%rbp)
cmpl   $0x2,-0x88(%rbp)
jae    145e <solve_real_virt+0x32e>
mov    -0x18(%rbp),%rax
mov    -0x84(%rbp),%ecx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x84(%rbp),%eax
mov    %eax,%ecx
lea    -0x70(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x8c(%rbp)
cmpl   $0x137,-0x8c(%rbp)
jae    1445 <solve_real_virt+0x315>
mov    -0x20(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%eax
mov    -0x40(%rbp,%rax,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x84(%rbp),%eax
mov    %eax,%ecx
lea    -0x70(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    13b0 <solve_real_virt+0x280>
jmp    144a <solve_real_virt+0x31a>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    135f <solve_real_virt+0x22f>
jmp    1463 <solve_real_virt+0x333>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1348 <solve_real_virt+0x218>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jae    14d7 <solve_real_virt+0x3a7>
mov    0x18(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x8c(%rbp),%ecx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1481 <solve_real_virt+0x351>
movl   $0xb4,-0x8c(%rbp)
cmpl   $0x137,-0x8c(%rbp)
jae    1535 <solve_real_virt+0x405>
mov    0x18(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x8c(%rbp),%ecx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    14e1 <solve_real_virt+0x3b1>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rax
mov    0x10(%rax),%rsi
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdx
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x48(%rbp),%rcx
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%rcx
mov    0x18(%rbp),%r8
mov    -0x9c(%rbp),%eax
shl    $0x3,%rax
add    %rax,%r8
mov    $0x50,%r9d
call   1050 <solveTXeqB@plt>
movl   $0x0,-0x84(%rbp)
cmpl   $0x2,-0x84(%rbp)
jae    1672 <solve_real_virt+0x542>
mov    0x10(%rbp),%rax
mov    -0x84(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x84(%rbp),%eax
movsd  %xmm0,-0x80(%rbp,%rax,8)
movl   $0x0,-0x8c(%rbp)
cmpl   $0x137,-0x8c(%rbp)
jae    1659 <solve_real_virt+0x529>
mov    -0x20(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x84(%rbp),%eax
movsd  -0x80(%rbp,%rax,8),%xmm1
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp,%rax,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    15dc <solve_real_virt+0x4ac>
jmp    165e <solve_real_virt+0x52e>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    15aa <solve_real_virt+0x47a>
movsd  -0x70(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movl   $0x0,-0x8c(%rbp)
cmpl   $0x137,-0x8c(%rbp)
jae    17ed <solve_real_virt+0x6bd>
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8c(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    173e <solve_real_virt+0x60e>
movl   $0x0,-0x84(%rbp)
cmpl   $0x2,-0x84(%rbp)
jae    1828 <solve_real_virt+0x6f8>
mov    -0x84(%rbp),%eax
mov    -0x40(%rbp,%rax,8),%rdi
call   1030 <free@plt>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    17f7 <solve_real_virt+0x6c7>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_real_virt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,0x18(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rdi,(%rsp)
mov    0xd8(%rsp),%rbp
mov    0xd0(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    $0x137,%edi
call   1040 <create_1D_array@plt>
mov    %rax,%r12
mov    $0x137,%edi
call   1040 <create_1D_array@plt>
mov    %rax,%r13
mov    $0x137,%edi
call   1040 <create_1D_array@plt>
mov    %rax,%rbx
mov    %r15,0x10(%rsp)
mov    (%r15),%rax
mov    %r14,0x8(%rsp)
mov    (%r14),%rdx
lea    0x320(%r12),%rcx
lea    0x320(%rax),%rsi
lea    0x320(%rdx),%rdi
mov    %rsi,0x20(%rsp)
cmp    %rsi,%r12
setb   %r10b
cmp    %rcx,%rax
setb   %r11b
cmp    %rdi,%r12
setb   %sil
cmp    %rcx,%rdx
setb   %r9b
test   %r11b,%r10b
jne    1227 <solve_real_virt+0xf7>
and    %r9b,%sil
jne    1227 <solve_real_virt+0xf7>
mov    $0x2,%esi
nopl   0x0(%rax)
movupd -0x10(%rax,%rsi,8),%xmm0
movupd -0x10(%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%r12,%rsi,8)
movupd (%rax,%rsi,8),%xmm0
movupd (%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r12,%rsi,8)
add    $0x4,%rsi
cmp    $0x66,%rsi
jne    11f0 <solve_real_virt+0xc0>
jmp    125d <solve_real_virt+0x12d>
mov    $0x1,%esi
nopl   0x0(%rax)
movsd  -0x8(%rax,%rsi,8),%xmm0
divsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%r12,%rsi,8)
add    $0x2,%rsi
cmp    $0x65,%rsi
jne    1230 <solve_real_virt+0x100>
lea    0x5a0(%r12),%rsi
lea    0x9b8(%r12),%r15
lea    0x5a0(%rax),%r9
lea    0x9b8(%rax),%r10
lea    0x5a0(%rdx),%r11
lea    0x9b8(%rdx),%r8
cmp    %r10,%rsi
setb   %r10b
cmp    %r15,%r9
setb   %r14b
and    %r10b,%r14b
cmp    %r8,%rsi
setb   %sil
mov    %r15,0x60(%rsp)
cmp    %r15,%r11
setb   %r9b
and    %sil,%r9b
or     %r14b,%r9b
mov    $0xb4,%esi
jne    1314 <solve_real_virt+0x1e4>
xor    %esi,%esi
nopl   0x0(%rax)
movupd 0x5a0(%rax,%rsi,8),%xmm0
movupd 0x5a0(%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x5a0(%r12,%rsi,8)
cmp    $0x80,%rsi
je     130f <solve_real_virt+0x1df>
movupd 0x5b0(%rax,%rsi,8),%xmm0
movupd 0x5b0(%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x5b0(%r12,%rsi,8)
add    $0x4,%rsi
jmp    12c0 <solve_real_virt+0x190>
mov    $0x136,%esi
movsd  (%rax,%rsi,8),%xmm0
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%r12,%rsi,8)
test   %r9b,%r9b
je     1360 <solve_real_virt+0x230>
add    $0x2,%rsi
nopl   (%rax)
movsd  -0x8(%rax,%rsi,8),%xmm0
divsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%r12,%rsi,8)
add    $0x2,%rsi
cmp    $0x138,%rsi
jne    1330 <solve_real_virt+0x200>
mov    $0x320,%edx
mov    0x8(%rsp),%r14
mov    0x10(%r14),%rsi
add    %rdx,%rsi
add    0x8(%r14),%rdx
mov    0x20(%rsp),%r8
mov    $0x50,%r9d
call   1050 <solveTXeqB@plt>
mov    0x10(%rsp),%rax
mov    0x8(%rax),%rax
mov    (%r14),%rdx
lea    0x320(%r13),%rcx
lea    0x320(%rax),%r8
lea    0x320(%rdx),%rdi
cmp    %r8,%r13
setb   %r10b
cmp    %rcx,%rax
setb   %r11b
cmp    %rdi,%r13
setb   %sil
cmp    %rcx,%rdx
setb   %r9b
test   %r11b,%r10b
jne    1418 <solve_real_virt+0x2e8>
and    %r9b,%sil
jne    1418 <solve_real_virt+0x2e8>
mov    $0x2,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rax,%rsi,8),%xmm0
movupd -0x10(%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%r13,%rsi,8)
movupd (%rax,%rsi,8),%xmm0
movupd (%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x0(%r13,%rsi,8)
add    $0x4,%rsi
cmp    $0x66,%rsi
jne    13e0 <solve_real_virt+0x2b0>
jmp    144e <solve_real_virt+0x31e>
mov    $0x1,%esi
nopl   (%rax)
movsd  -0x8(%rax,%rsi,8),%xmm0
divsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x2,%rsi
cmp    $0x65,%rsi
jne    1420 <solve_real_virt+0x2f0>
lea    0x5a0(%r13),%rsi
lea    0x9b8(%r13),%r9
lea    0x5a0(%rax),%r15
lea    0x9b8(%rax),%r10
lea    0x5a0(%rdx),%r11
lea    0x9b8(%rdx),%r14
cmp    %r10,%rsi
setb   %r10b
cmp    %r9,%r15
setb   %r15b
and    %r10b,%r15b
cmp    %r14,%rsi
setb   %sil
mov    %r9,0x10(%rsp)
cmp    %r9,%r11
setb   %r9b
and    %sil,%r9b
or     %r15b,%r9b
mov    $0xb4,%esi
jne    1504 <solve_real_virt+0x3d4>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd 0x5a0(%rax,%rsi,8),%xmm0
movupd 0x5a0(%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x5a0(%r13,%rsi,8)
cmp    $0x80,%rsi
je     14ff <solve_real_virt+0x3cf>
movupd 0x5b0(%rax,%rsi,8),%xmm0
movupd 0x5b0(%rdx,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x5b0(%r13,%rsi,8)
add    $0x4,%rsi
jmp    14b0 <solve_real_virt+0x380>
mov    $0x136,%esi
movsd  (%rax,%rsi,8),%xmm0
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
test   %r9b,%r9b
je     1551 <solve_real_virt+0x421>
add    $0x2,%rsi
xchg   %ax,%ax
movsd  -0x8(%rax,%rsi,8),%xmm0
divsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
divsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,0x0(%r13,%rsi,8)
add    $0x2,%rsi
cmp    $0x138,%rsi
jne    1520 <solve_real_virt+0x3f0>
mov    $0x320,%edx
mov    0x8(%rsp),%rax
mov    0x10(%rax),%rsi
add    %rdx,%rsi
add    0x8(%rax),%rdx
mov    $0x50,%r9d
call   1050 <solveTXeqB@plt>
mov    0x18(%rsp),%rdx
mov    (%rdx),%rax
mov    0x30(%rsp),%rsi
movsd  (%rsi),%xmm2
mov    $0x3,%ecx
mov    0x68(%rsp),%r15
nopl   0x0(%rax)
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  -0x10(%rax,%rcx,8),%xmm1
mulsd  -0x18(%r12,%rcx,8),%xmm0
subsd  %xmm0,%xmm2
mulsd  -0x10(%r12,%rcx,8),%xmm1
subsd  %xmm1,%xmm2
movsd  -0x8(%rax,%rcx,8),%xmm0
mulsd  -0x8(%r12,%rcx,8),%xmm0
subsd  %xmm0,%xmm2
cmp    $0x137,%rcx
je     15e1 <solve_real_virt+0x4b1>
movsd  (%rax,%rcx,8),%xmm0
mulsd  (%r12,%rcx,8),%xmm0
subsd  %xmm0,%xmm2
add    $0x4,%rcx
jmp    1590 <solve_real_virt+0x460>
movsd  0x8(%rsi),%xmm3
mov    $0x3,%ecx
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  -0x10(%rax,%rcx,8),%xmm1
mulsd  -0x18(%r13,%rcx,8),%xmm0
subsd  %xmm0,%xmm3
mulsd  -0x10(%r13,%rcx,8),%xmm1
subsd  %xmm1,%xmm3
movsd  -0x8(%rax,%rcx,8),%xmm0
mulsd  -0x8(%r13,%rcx,8),%xmm0
subsd  %xmm0,%xmm3
cmp    $0x137,%rcx
je     1642 <solve_real_virt+0x512>
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x0(%r13,%rcx,8),%xmm0
subsd  %xmm0,%xmm3
add    $0x4,%rcx
jmp    15f0 <solve_real_virt+0x4c0>
mov    0x8(%rdx),%rax
movsd  0x10(%rsi),%xmm4
mov    $0x3,%ecx
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  -0x10(%rax,%rcx,8),%xmm1
mulsd  -0x18(%r12,%rcx,8),%xmm0
subsd  %xmm0,%xmm4
mulsd  -0x10(%r12,%rcx,8),%xmm1
subsd  %xmm1,%xmm4
movsd  -0x8(%rax,%rcx,8),%xmm0
mulsd  -0x8(%r12,%rcx,8),%xmm0
subsd  %xmm0,%xmm4
cmp    $0x137,%rcx
je     16a1 <solve_real_virt+0x571>
movsd  (%rax,%rcx,8),%xmm0
mulsd  (%r12,%rcx,8),%xmm0
subsd  %xmm0,%xmm4
add    $0x4,%rcx
jmp    1650 <solve_real_virt+0x520>
movsd  0x18(%rsi),%xmm5
mov    $0x3,%ecx
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rcx,8),%xmm0
movsd  -0x10(%rax,%rcx,8),%xmm1
mulsd  -0x18(%r13,%rcx,8),%xmm0
subsd  %xmm0,%xmm5
mulsd  -0x10(%r13,%rcx,8),%xmm1
subsd  %xmm1,%xmm5
movsd  -0x8(%rax,%rcx,8),%xmm0
mulsd  -0x8(%r13,%rcx,8),%xmm0
subsd  %xmm0,%xmm5
cmp    $0x137,%rcx
je     1702 <solve_real_virt+0x5d2>
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x0(%r13,%rcx,8),%xmm0
subsd  %xmm0,%xmm5
add    $0x4,%rcx
jmp    16b0 <solve_real_virt+0x580>
mov    0x8(%rsp),%rax
mov    (%rax),%rax
lea    0x320(%rbx),%rcx
lea    0x320(%rbp),%rdx
lea    0x320(%rax),%rdi
mov    %rdx,0x48(%rsp)
cmp    %rdx,%rbx
setb   %r9b
cmp    %rbp,%rcx
seta   %r10b
cmp    %rdi,%rbx
setb   %dl
cmp    %rcx,%rax
setb   %sil
test   %r10b,%r9b
jne    1786 <solve_real_virt+0x656>
and    %sil,%dl
jne    1786 <solve_real_virt+0x656>
mov    $0x2,%edx
xchg   %ax,%ax
movupd -0x10(%rbp,%rdx,8),%xmm0
movupd -0x10(%rax,%rdx,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%rbx,%rdx,8)
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd (%rax,%rdx,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    $0x66,%rdx
jne    1750 <solve_real_virt+0x620>
jmp    17bc <solve_real_virt+0x68c>
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rdx,8),%xmm0
divsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm0
divsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    $0x65,%rdx
jne    1790 <solve_real_virt+0x660>
lea    0x5a0(%rbx),%rsi
lea    0x9b8(%rbx),%r8
lea    0x5a0(%rbp),%r9
lea    0x9b8(%rbp),%rdx
lea    0x5a0(%rax),%r10
lea    0x9b8(%rax),%r11
cmp    %rdx,%rsi
setb   %r14b
cmp    %r8,%r9
setb   %dl
and    %r14b,%dl
cmp    %r11,%rsi
setb   %sil
mov    %r8,0x50(%rsp)
cmp    %r8,%r10
setb   %r9b
and    %sil,%r9b
or     %dl,%r9b
mov    $0xb4,%esi
jne    1872 <solve_real_virt+0x742>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movupd 0x5a0(%rbp,%rsi,8),%xmm0
movupd 0x5a0(%rax,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x5a0(%rbx,%rsi,8)
cmp    $0x80,%rsi
je     186d <solve_real_virt+0x73d>
movupd 0x5b0(%rbp,%rsi,8),%xmm0
movupd 0x5b0(%rax,%rsi,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x5b0(%rbx,%rsi,8)
add    $0x4,%rsi
jmp    1820 <solve_real_virt+0x6f0>
mov    $0x136,%esi
movapd %xmm5,0x70(%rsp)
movapd %xmm4,0x80(%rsp)
movapd %xmm3,0x20(%rsp)
movapd %xmm2,0x30(%rsp)
movsd  0x0(%rbp,%rsi,8),%xmm0
divsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
test   %r9b,%r9b
je     18df <solve_real_virt+0x7af>
add    $0x2,%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rsi,8),%xmm0
divsd  -0x8(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rsi,8)
movsd  0x0(%rbp,%rsi,8),%xmm0
divsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rbx,%rsi,8)
add    $0x2,%rsi
cmp    $0x138,%rsi
jne    18b0 <solve_real_virt+0x780>
mov    $0x320,%edx
mov    0x8(%rsp),%rax
mov    0x10(%rax),%rsi
add    %rdx,%rsi
add    0x8(%rax),%rdx
mov    0x48(%rsp),%r8
mov    $0x50,%r9d
call   1050 <solveTXeqB@plt>
mov    0x58(%rsp),%rsi
movsd  (%rsi),%xmm0
mov    0x18(%rsp),%rdx
mov    (%rdx),%rax
mov    $0x3,%ecx
mov    (%rsp),%r8
movapd 0x20(%rsp),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x18(%rax,%rcx,8),%xmm1
movsd  -0x10(%rax,%rcx,8),%xmm2
mulsd  -0x18(%rbx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mulsd  -0x10(%rbx,%rcx,8),%xmm2
subsd  %xmm2,%xmm0
movsd  -0x8(%rax,%rcx,8),%xmm1
mulsd  -0x8(%rbx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
cmp    $0x137,%rcx
je     197d <solve_real_virt+0x84d>
movsd  (%rax,%rcx,8),%xmm1
mulsd  (%rbx,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x4,%rcx
jmp    1930 <solve_real_virt+0x800>
movsd  0x8(%rsi),%xmm1
mov    0x8(%rdx),%rax
mov    $0x3,%ecx
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rax,%rcx,8),%xmm2
movsd  -0x10(%rax,%rcx,8),%xmm3
mulsd  -0x18(%rbx,%rcx,8),%xmm2
subsd  %xmm2,%xmm1
mulsd  -0x10(%rbx,%rcx,8),%xmm3
subsd  %xmm3,%xmm1
movsd  -0x8(%rax,%rcx,8),%xmm2
mulsd  -0x8(%rbx,%rcx,8),%xmm2
subsd  %xmm2,%xmm1
cmp    $0x137,%rcx
je     19dd <solve_real_virt+0x8ad>
movsd  (%rax,%rcx,8),%xmm2
mulsd  (%rbx,%rcx,8),%xmm2
subsd  %xmm2,%xmm1
add    $0x4,%rcx
jmp    1990 <solve_real_virt+0x860>
movapd %xmm4,%xmm2
movapd 0x80(%rsp),%xmm3
unpcklpd %xmm3,%xmm2
xorpd  0x60a(%rip),%xmm4
mulsd  %xmm3,%xmm4
movapd 0x30(%rsp),%xmm5
movapd %xmm5,%xmm3
movapd 0x70(%rsp),%xmm6
mulsd  %xmm6,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm0,%xmm4
mulpd  %xmm2,%xmm4
unpcklpd %xmm5,%xmm6
unpcklpd %xmm1,%xmm0
mulpd  %xmm6,%xmm0
subpd  %xmm4,%xmm0
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm0
movupd %xmm0,(%r8)
movsd  (%rbx),%xmm1
movsd  (%r12),%xmm2
mulsd  %xmm0,%xmm2
unpckhpd %xmm0,%xmm0
mulsd  0x0(%r13),%xmm0
subsd  %xmm2,%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r15)
lea    0x8(%r15),%rax
lea    0x9b8(%r15),%rbp
lea    0x10(%r8),%rcx
mov    %rbx,%rdx
add    $0x8,%rdx
mov    %r12,%rsi
add    $0x8,%rsi
mov    %r13,%rdi
add    $0x8,%rdi
cmp    %rcx,%rax
setb   %r11b
cmp    %r8,%rbp
seta   %r14b
cmp    0x50(%rsp),%rax
setb   %cl
cmp    %rbp,%rdx
setb   %r10b
cmp    0x60(%rsp),%rax
setb   %dl
cmp    %rbp,%rsi
setb   %r8b
cmp    0x10(%rsp),%rax
setb   %sil
cmp    %rbp,%rdi
setb   %r9b
mov    $0x1,%eax
test   %r14b,%r11b
jne    1be4 <solve_real_virt+0xab4>
and    %r10b,%cl
jne    1bea <solve_real_virt+0xaba>
and    %r8b,%dl
jne    1bde <solve_real_virt+0xaae>
and    %r9b,%sil
mov    (%rsp),%rcx
jne    1b80 <solve_real_virt+0xa50>
movsd  (%rcx),%xmm0
movsd  0x8(%rcx),%xmm1
unpcklpd %xmm0,%xmm0
unpcklpd %xmm1,%xmm1
mov    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rbx,%rax,8),%xmm2
movupd (%rbx,%rax,8),%xmm3
movupd -0x10(%r12,%rax,8),%xmm4
movupd (%r12,%rax,8),%xmm5
mulpd  %xmm0,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm0,%xmm5
subpd  %xmm5,%xmm3
movupd -0x10(%r13,%rax,8),%xmm4
movupd 0x0(%r13,%rax,8),%xmm5
mulpd  %xmm1,%xmm4
subpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm5
subpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%r15,%rax,8)
movupd %xmm3,(%r15,%rax,8)
add    $0x4,%rax
cmp    $0x137,%rax
jne    1b10 <solve_real_virt+0x9e0>
mov    $0x135,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
mulsd  (%rcx),%xmm1
subsd  %xmm1,%xmm0
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  0x8(%rcx),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
cmp    $0x137,%rax
jne    1b80 <solve_real_virt+0xa50>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    (%rsp),%rcx
jmp    1b80 <solve_real_virt+0xa50>
mov    (%rsp),%rcx
jmp    1b80 <solve_real_virt+0xa50>
mov    (%rsp),%rcx
jmp    1b80 <solve_real_virt+0xa50>

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

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