void generate_rho_semicore(semicore_type, rho_core, r_semicore,
                           rho_semicore) int semicore_type;
double rho_core[], r_semicore, rho_semicore[];
{
  int k, index;
  int Ngrid;
  double *rgrid;
  double *drho_core, *ddrho_core;
  double c1, c2;
  double x1, x2, cs, ct, A, B, f, fp;
  double r, rho, drho, ddrho, dddrho;
  double c0, c3, c4, c5, c6;
  double bs[4], as[4 * 4];
  Ngrid = N_LogGrid();
  rgrid = r_LogGrid();
  drho_core = alloc_LogGrid();
  ddrho_core = alloc_LogGrid();
  index = index_r_LogGrid(r_semicore);
  Derivative_LogGrid(rho_core, drho_core);
  Derivative_LogGrid(drho_core, ddrho_core);
  r = rgrid[index];
  rho = rho_core[index];
  drho = drho_core[index];
  ddrho = ddrho_core[index];
  Derivative_LogGrid(ddrho_core, drho_core);
  dddrho = drho_core[index];
  if (semicore_type == 0) {
    c1 = rho - (r * drho) / 2.0;
    c2 = drho / (2.0 * r);
    for (k = 0; k < index; ++k)
      rho_semicore[k] = c1 + c2 * rgrid[k] * rgrid[k];
  }
  if (semicore_type == 1) {
    x2 = 0.5 * sqrt(-3.0 * (r * drho / rho));
    x1 = x2 - 1.0;
    while (fabs(x2 - x1) > 1.0e-6) {
      x1 = x2;
      ct = cos(x1) / sin(x1);
      cs = sin(x1) * sin(x1);
      cs = 1.0 / cs;
      f = x1 * ct - (r * drho / rho + 1.0);
      fp = ct - x1 * cs;
      x2 = x1 - f / fp;
    }
    B = x2 / r;
    A = (r * rho) / sin(x2);
    for (k = 0; k < index; ++k)
      rho_semicore[k] = (A / rgrid[k]) * sin(B * rgrid[k]);
  }
  if (semicore_type == 2) {
    c0 = rho - (r * drho) / 2.0;
    bs[0] = rho - c0;
    bs[1] = drho;
    bs[2] = ddrho;
    bs[3] = dddrho;
    as[0] = 1.0 * pow(r, 3.0);
    as[4] = 1.0 * pow(r, 4.0);
    as[8] = 1.0 * pow(r, 5.0);
    as[1] = 3.0 * r * r;
    as[5] = 4.0 * pow(r, 3.0);
    as[9] = 5.0 * pow(r, 4.0);
    as[2] = 6.0 * r;
    as[6] = 12.0 * r * r;
    as[10] = 20.0 * pow(r, 3.0);
    as[3] = 6.0;
    as[7] = 24.0 * r;
    as[11] = 60.0 * r * r;
    as[12] = 1.0 * pow(r, 6.0);
    as[13] = 6.0 * pow(r, 5.0);
    as[14] = 30.0 * pow(r, 4.0);
    as[15] = 120.0 * pow(r, 3.0);
    gaussj(4, as, 1, bs);
    c3 = bs[0];
    c4 = bs[1];
    c5 = bs[2];
    c6 = bs[3];
    for (k = 0; k < index; ++k)
      rho_semicore[k] =
          c0 + c3 * rgrid[k] * rgrid[k] * rgrid[k] +
          c4 * rgrid[k] * rgrid[k] * rgrid[k] * rgrid[k] +
          c5 * rgrid[k] * rgrid[k] * rgrid[k] * rgrid[k] * rgrid[k] +
          c6 * rgrid[k] * rgrid[k] * rgrid[k] * rgrid[k] * rgrid[k] * rgrid[k];
  }
  for (k = index; k < Ngrid; ++k)
    rho_semicore[k] = rho_core[k];
  dealloc_LogGrid(drho_core);
  dealloc_LogGrid(ddrho_core);
}


x86 assembly (clang, -O0):
<generate_rho_semicore>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    $0x0,%al
call   10d0 <N_LogGrid@plt>
mov    %eax,-0x2c(%rbp)
mov    $0x0,%al
call   1070 <r_LogGrid@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x40(%rbp)
mov    $0x0,%al
call   10c0 <alloc_LogGrid@plt>
cltq
mov    %rax,-0x48(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    $0x1,%al
call   1050 <index_r_LogGrid@plt>
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    $0x0,%al
call   1030 <Derivative_LogGrid@plt>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
cmpl   $0x0,-0x4(%rbp)
jne    1358 <generate_rho_semicore+0x1a8>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movsd  0xd35(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0xd18(%rip),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1353 <generate_rho_semicore+0x1a3>
movsd  -0x50(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1300 <generate_rho_semicore+0x150>
jmp    1358 <generate_rho_semicore+0x1a8>
cmpl   $0x1,-0x4(%rbp)
jne    15c7 <generate_rho_semicore+0x417>
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
divsd  -0xa8(%rbp),%xmm1
ff
movsd  0xc96(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xc7a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  0xc5c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movaps 0xcba(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xc4e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1506 <generate_rho_semicore+0x356>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1080 <cos@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x1a0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x198(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xbba(%rip),%xmm0
divsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
divsd  -0xa8(%rbp),%xmm1
ff
movsd  0xb86(%rip),%xmm3
addsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
divsd  -0x98(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    13b5 <generate_rho_semicore+0x205>
movsd  -0x68(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x1a8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15c2 <generate_rho_semicore+0x412>
movsd  -0x80(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x1b0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1558 <generate_rho_semicore+0x3a8>
jmp    15c7 <generate_rho_semicore+0x417>
cmpl   $0x2,-0x4(%rbp)
jne    1a65 <generate_rho_semicore+0x8b5>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
movsd  0xa0f(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x9d7(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x99f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x9bb(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x973(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x99f(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x947(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x95b(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x933(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x933(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x917(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x917(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  0x8fb(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  0x90b(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x8a3(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x8cb(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x897(%rip),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0x89f(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x87f(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x847(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x7f7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x823(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x80b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x7e7(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x7cf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  0x7ab(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  0x793(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
lea    -0x190(%rbp),%rsi
lea    -0x110(%rbp),%rcx
mov    $0x4,%edi
mov    $0x1,%edx
mov    $0x0,%al
call   1040 <gaussj@plt>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a60 <generate_rho_semicore+0x8b0>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1907 <generate_rho_semicore+0x757>
jmp    1a65 <generate_rho_semicore+0x8b5>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a9f <generate_rho_semicore+0x8ef>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a6b <generate_rho_semicore+0x8bb>
mov    -0x40(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
mov    -0x48(%rbp),%rdi
mov    $0x0,%al
call   10b0 <dealloc_LogGrid@plt>
add    $0x1b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generate_rho_semicore>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %rdx,%rbx
movsd  %xmm0,0x10(%rsp)
mov    %rsi,%r14
mov    %edi,0x3c(%rsp)
xor    %eax,%eax
call   10d0 <N_LogGrid@plt>
mov    %eax,0x6c(%rsp)
xor    %eax,%eax
call   1070 <r_LogGrid@plt>
cltq
mov    %rax,0x100(%rsp)
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%r13
xor    %eax,%eax
call   10c0 <alloc_LogGrid@plt>
movslq %eax,%r15
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   1050 <index_r_LogGrid@plt>
mov    %eax,%ebp
mov    %r14,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    %r13,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    %ebp,0xc(%rsp)
movslq %ebp,%r12
mov    0x100(%rsp),%rax
mov    %rax,%rbp
movsd  (%rax,%r12,8),%xmm0
movaps %xmm0,0x20(%rsp)
movsd  (%r14,%r12,8),%xmm0
movaps %xmm0,0x70(%rsp)
movsd  0x0(%r13,%r12,8),%xmm0
movaps %xmm0,0x80(%rsp)
movsd  (%r15,%r12,8),%xmm0
movsd  %xmm0,0xf8(%rsp)
mov    %r15,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1030 <Derivative_LogGrid@plt>
mov    0x3c(%rsp),%eax
test   %eax,%eax
je     12c0 <generate_rho_semicore+0x110>
movsd  0x0(%r13,%r12,8),%xmm3
cmp    $0x1,%eax
je     13a5 <generate_rho_semicore+0x1f5>
cmp    $0x2,%eax
mov    0xc(%rsp),%esi
movapd 0x70(%rsp),%xmm1
movapd 0x80(%rsp),%xmm2
jne    1a8d <generate_rho_semicore+0x8dd>
movapd 0x20(%rsp),%xmm0
mulsd  %xmm2,%xmm0
jmp    1699 <generate_rho_semicore+0x4e9>
mov    0xc(%rsp),%esi
test   %esi,%esi
movapd 0x70(%rsp),%xmm6
movapd 0x80(%rsp),%xmm7
jle    1a8d <generate_rho_semicore+0x8dd>
movapd 0x20(%rsp),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm7,%xmm0
mulsd  0xd37(%rip),%xmm0
addsd  %xmm0,%xmm6
addsd  %xmm1,%xmm1
divsd  %xmm1,%xmm7
mov    %esi,%eax
cmp    $0x4,%esi
jb     1325 <generate_rho_semicore+0x175>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    1c55 <generate_rho_semicore+0xaa5>
lea    (%rbx,%rax,8),%rcx
cmp    %rcx,%rbp
jae    1c55 <generate_rho_semicore+0xaa5>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     1350 <generate_rho_semicore+0x1a0>
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
or     $0x1,%rcx
add    %rax,%rdx
je     1a8d <generate_rho_semicore+0x8dd>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm6,%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1360 <generate_rho_semicore+0x1b0>
jmp    1a8d <generate_rho_semicore+0x8dd>
movapd 0x20(%rsp),%xmm2
mulsd  0x80(%rsp),%xmm2
movapd %xmm2,%xmm4
divsd  0x70(%rsp),%xmm4
movsd  0xc3a(%rip),%xmm0
mulsd  %xmm4,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movapd %xmm2,0xb0(%rsp)
movsd  %xmm3,0xe8(%rsp)
jb     13ec <generate_rho_semicore+0x23c>
sqrtsd %xmm0,%xmm0
jmp    1403 <generate_rho_semicore+0x253>
movapd %xmm4,0xc0(%rsp)
call   10a0 <sqrt@plt>
movapd 0xc0(%rsp),%xmm4
mulsd  0xbfd(%rip),%xmm0
movsd  0xbfd(%rip),%xmm2
addsd  %xmm0,%xmm2
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
andpd  0xc49(%rip),%xmm1
ucomisd 0xbe9(%rip),%xmm1
mov    %r15,0xf0(%rsp)
jbe    153d <generate_rho_semicore+0x38d>
addsd  0xbdb(%rip),%xmm4
xorpd  0xc33(%rip),%xmm4
movapd %xmm0,%xmm2
movapd %xmm4,0xc0(%rsp)
nopw   0x0(%rax,%rax,1)
movapd %xmm0,0x10(%rsp)
movapd %xmm2,0x40(%rsp)
call   1080 <cos@plt>
movapd %xmm0,0x50(%rsp)
movaps 0x10(%rsp),%xmm0
call   1060 <sin@plt>
movaps %xmm0,0xd0(%rsp)
movaps 0x10(%rsp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x108(%rsp)
movapd 0x10(%rsp),%xmm0
call   1060 <sin@plt>
movapd 0xc0(%rsp),%xmm4
movapd 0x40(%rsp),%xmm2
mulsd  0x108(%rsp),%xmm0
movapd 0x50(%rsp),%xmm5
shufpd $0x2,0xbc2(%rip),%xmm5
movapd 0xd0(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
divpd  %xmm1,%xmm5
movapd 0x10(%rsp),%xmm3
movapd %xmm3,%xmm0
xorpd  0xb8f(%rip),%xmm0
movapd %xmm3,%xmm1
unpcklpd %xmm0,%xmm1
movapd %xmm4,%xmm0
unpcklpd %xmm5,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
divsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
subsd  %xmm3,%xmm0
andpd  0xb47(%rip),%xmm0
ucomisd 0xae7(%rip),%xmm0
movapd %xmm2,%xmm0
ja     1460 <generate_rho_semicore+0x2b0>
jmp    1541 <generate_rho_semicore+0x391>
movapd %xmm0,%xmm2
movapd %xmm2,0x40(%rsp)
movapd %xmm2,%xmm0
call   1060 <sin@plt>
movapd 0x40(%rsp),%xmm2
mov    0xc(%rsp),%esi
test   %esi,%esi
jle    1665 <generate_rho_semicore+0x4b5>
mov    %rbp,%rax
movapd 0x20(%rsp),%xmm1
divsd  %xmm1,%xmm2
mulsd  0x70(%rsp),%xmm1
divsd  %xmm0,%xmm1
mov    %esi,%ecx
cmp    $0x1,%esi
mov    %r13,0xe0(%rsp)
mov    %rcx,0xd0(%rsp)
movapd %xmm1,0x10(%rsp)
jne    159e <generate_rho_semicore+0x3ee>
xor    %r15d,%r15d
jmp    161c <generate_rho_semicore+0x46c>
mov    %ecx,%r13d
and    $0xfffffffe,%r13d
xor    %r15d,%r15d
movapd %xmm2,0x40(%rsp)
xchg   %ax,%ax
movsd  (%rax,%r15,8),%xmm0
movapd 0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
mulsd  %xmm2,%xmm0
call   1060 <sin@plt>
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,(%rbx,%r15,8)
movsd  0x8(%rbp,%r15,8),%xmm0
movapd 0x10(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
mulsd  0x40(%rsp),%xmm0
call   1060 <sin@plt>
movapd 0x40(%rsp),%xmm2
mov    %rbp,%rax
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx,%r15,8)
add    $0x2,%r15
cmp    %r15,%r13
jne    15b0 <generate_rho_semicore+0x400>
movapd 0x10(%rsp),%xmm1
testb  $0x1,0xd0(%rsp)
01
mov    0xe0(%rsp),%r13
mov    0xc(%rsp),%esi
je     1665 <generate_rho_semicore+0x4b5>
movsd  (%rax,%r15,8),%xmm0
divsd  %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
mulsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
call   1060 <sin@plt>
mov    0xc(%rsp),%esi
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rbx,%r15,8)
cmpl   $0x2,0x3c(%rsp)
mov    0xf0(%rsp),%r15
movapd 0xb0(%rsp),%xmm0
movapd 0x70(%rsp),%xmm1
movapd 0x80(%rsp),%xmm2
movsd  0xe8(%rsp),%xmm3
jne    1a8d <generate_rho_semicore+0x8dd>
mulsd  0x987(%rip),%xmm0
addsd  %xmm1,%xmm0
movapd %xmm0,0xb0(%rsp)
subsd  %xmm0,%xmm1
movsd  %xmm1,0x90(%rsp)
movsd  %xmm2,0x98(%rsp)
movsd  0xf8(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
movsd  %xmm3,0xa8(%rsp)
movsd  0x949(%rip),%xmm1
movaps 0x20(%rsp),%xmm0
call   1090 <pow@plt>
movsd  %xmm0,0x110(%rsp)
movsd  0x936(%rip),%xmm1
movaps 0x20(%rsp),%xmm0
call   1090 <pow@plt>
movsd  %xmm0,0x130(%rsp)
movsd  0x923(%rip),%xmm1
movaps 0x20(%rsp),%xmm0
call   1090 <pow@plt>
movsd  %xmm0,0x150(%rsp)
movapd 0x20(%rsp),%xmm0
movapd %xmm0,%xmm2
movsd  0x8ee(%rip),%xmm1
mulsd  %xmm1,%xmm2
movapd %xmm2,0x50(%rsp)
call   1090 <pow@plt>
movapd %xmm0,0x40(%rsp)
movaps 0x20(%rsp),%xmm0
movsd  0x8d4(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,0x10(%rsp)
movapd 0x20(%rsp),%xmm0
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
movapd 0x50(%rsp),%xmm2
shufpd $0x2,0x915(%rip),%xmm2
mulpd  %xmm1,%xmm2
movupd %xmm2,0x118(%rsp)
movsd  0x8a8(%rip),%xmm2
mulsd  %xmm0,%xmm2
movapd 0x40(%rsp),%xmm3
unpcklpd %xmm0,%xmm3
movapd 0x8fa(%rip),%xmm1
unpcklpd %xmm2,%xmm1
mulpd  %xmm3,%xmm1
movupd %xmm1,0x138(%rsp)
movsd  0x861(%rip),%xmm1
call   1090 <pow@plt>
movapd 0x10(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  0x8da(%rip),%xmm1
movupd %xmm1,0x158(%rsp)
movabs $0x4018000000000000,%rax
mov    %rax,0x128(%rsp)
movsd  0x847(%rip),%xmm1
movapd 0x20(%rsp),%xmm0
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x148(%rsp)
movsd  0x834(%rip),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x168(%rsp)
movsd  0x823(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,0x170(%rsp)
movaps 0x20(%rsp),%xmm0
movsd  0x7e8(%rip),%xmm1
call   1090 <pow@plt>
movaps %xmm0,0x10(%rsp)
movapd 0x20(%rsp),%xmm0
movsd  0x7c8(%rip),%xmm1
call   1090 <pow@plt>
movapd 0x10(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
mulpd  0x849(%rip),%xmm1
movupd %xmm1,0x178(%rsp)
movapd 0x20(%rsp),%xmm0
movsd  0x792(%rip),%xmm1
call   1090 <pow@plt>
mulsd  0x7bd(%rip),%xmm0
movsd  %xmm0,0x188(%rsp)
lea    0x110(%rsp),%rsi
lea    0x90(%rsp),%rcx
mov    $0x4,%edi
mov    $0x1,%edx
xor    %eax,%eax
call   1040 <gaussj@plt>
movapd 0xb0(%rsp),%xmm12
mov    0xc(%rsp),%esi
test   %esi,%esi
jle    1a8d <generate_rho_semicore+0x8dd>
movsd  0x90(%rsp),%xmm0
movsd  0x98(%rsp),%xmm1
movsd  0xa0(%rsp),%xmm2
movsd  0xa8(%rsp),%xmm3
mov    %esi,%eax
cmp    $0x1,%esi
jne    191d <generate_rho_semicore+0x76d>
xor    %ecx,%ecx
jmp    1a10 <generate_rho_semicore+0x860>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    193d <generate_rho_semicore+0x78d>
lea    (%rbx,%rax,8),%rcx
cmp    %rcx,%rbp
jae    193d <generate_rho_semicore+0x78d>
xor    %ecx,%ecx
jmp    1a10 <generate_rho_semicore+0x860>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
movapd %xmm12,%xmm9
unpcklpd %xmm12,%xmm9
movapd %xmm1,%xmm10
unpcklpd %xmm1,%xmm10
movapd %xmm2,%xmm11
unpcklpd %xmm2,%xmm11
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x0(%rbp,%rdx,8),%xmm5
movapd %xmm8,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm9,%xmm6
movapd %xmm10,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movapd %xmm11,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm4,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    1980 <generate_rho_semicore+0x7d0>
cmp    %rax,%rcx
je     1a8d <generate_rho_semicore+0x8dd>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,8),%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm12,%xmm5
movapd %xmm1,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
movapd %xmm2,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
movapd %xmm3,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a10 <generate_rho_semicore+0x860>
mov    0x6c(%rsp),%eax
cmp    %eax,%esi
jge    1c2f <generate_rho_semicore+0xa7f>
cltq
mov    %rax,%r9
sub    %r12,%r9
cmp    $0x4,%r9
jb     1bb7 <generate_rho_semicore+0xa07>
lea    (%rbx,%r12,8),%rcx
lea    (%r14,%rax,8),%rdx
cmp    %rdx,%rcx
jae    1ac9 <generate_rho_semicore+0x919>
lea    (%rbx,%rax,8),%rcx
lea    (%r14,%r12,8),%rdx
cmp    %rcx,%rdx
jb     1bb7 <generate_rho_semicore+0xa07>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rcx
jae    1aee <generate_rho_semicore+0x93e>
xor    %ebp,%ebp
jmp    1b6c <generate_rho_semicore+0x9bc>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r12,8),%rdx
add    $0x70,%rdx
lea    (%r14,%r12,8),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x70(%rcx,%rbp,8),%xmm0
movups -0x60(%rcx,%rbp,8),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,8)
movups %xmm1,-0x60(%rdx,%rbp,8)
movups -0x50(%rcx,%rbp,8),%xmm0
movups -0x40(%rcx,%rbp,8),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,8)
movups %xmm1,-0x40(%rdx,%rbp,8)
movups -0x30(%rcx,%rbp,8),%xmm0
movups -0x20(%rcx,%rbp,8),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,8)
movups %xmm1,-0x20(%rdx,%rbp,8)
movupd -0x10(%rcx,%rbp,8),%xmm0
movupd (%rcx,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm1,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1b10 <generate_rho_semicore+0x960>
test   %rsi,%rsi
je     1baf <generate_rho_semicore+0x9ff>
add    %r12,%rbp
lea    (%rbx,%rbp,8),%rcx
add    $0x10,%rcx
lea    (%r14,%rbp,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdi,1)
movupd %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1b90 <generate_rho_semicore+0x9e0>
cmp    %r8,%r9
je     1c2f <generate_rho_semicore+0xa7f>
add    %r8,%r12
mov    %eax,%edx
sub    %r12d,%edx
mov    %r12,%rcx
not    %rcx
add    %rax,%rcx
and    $0x3,%rdx
je     1be6 <generate_rho_semicore+0xa36>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
add    $0x1,%r12
add    $0xffffffffffffffff,%rdx
jne    1bd0 <generate_rho_semicore+0xa20>
cmp    $0x3,%rcx
jb     1c2f <generate_rho_semicore+0xa7f>
nopl   0x0(%rax)
movsd  (%r14,%r12,8),%xmm0
movsd  %xmm0,(%rbx,%r12,8)
movsd  0x8(%r14,%r12,8),%xmm0
movsd  %xmm0,0x8(%rbx,%r12,8)
movsd  0x10(%r14,%r12,8),%xmm0
movsd  %xmm0,0x10(%rbx,%r12,8)
movsd  0x18(%r14,%r12,8),%xmm0
movsd  %xmm0,0x18(%rbx,%r12,8)
add    $0x4,%r12
cmp    %r12,%rax
jne    1bf0 <generate_rho_semicore+0xa40>
mov    %r13,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
mov    %r15,%rdi
xor    %eax,%eax
call   10b0 <dealloc_LogGrid@plt>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
lea    -0x4(%rcx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1d1b <generate_rho_semicore+0xb6b>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %r8,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x0(%rbp,%rdx,8),%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm0,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm4,(%rbx,%rdx,8)
movupd %xmm5,0x10(%rbx,%rdx,8)
movupd 0x20(%rbp,%rdx,8),%xmm2
movupd 0x30(%rbp,%rdx,8),%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm0,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
movupd %xmm4,0x20(%rbx,%rdx,8)
movupd %xmm5,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1ca0 <generate_rho_semicore+0xaf0>
jmp    1d1d <generate_rho_semicore+0xb6d>
xor    %edx,%edx
test   $0x1,%r8b
je     1d56 <generate_rho_semicore+0xba6>
movupd 0x0(%rbp,%rdx,8),%xmm2
movupd 0x10(%rbp,%rdx,8),%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm3,%xmm0
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,(%rbx,%rdx,8)
movupd %xmm0,0x10(%rbx,%rdx,8)
cmp    %rax,%rcx
je     1a8d <generate_rho_semicore+0x8dd>
jmp    1327 <generate_rho_semicore+0x177>

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

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