#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 */
int /*<<< orphan*/ MACULAFUNC(double *, int *, int *, int *, int *, int *,
                              int *, double *, double *, double *, double *,
                              double *, double *, double *, double *, double *,
                              double *, double *);
int /*<<< orphan*/ VARTOOLS_error(int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(size_t);
void simulatemaculalc(int N, double *JD, double *fluxout, double *Theta_star,
                      int Nspot, double **Theta_spot, double baseflux,
                      double blend, int derivatives, int temporal, int TdeltaV,
                      double *deltaratio, double **dFmod_star,
                      double ***dFmod_spot, double ***dFmod_inst,
                      double *dFmoddt) {
  double *Theta_spot_fortran = NULL, *Theta_inst_fortran = NULL,
         *dFmod_star_fortran = NULL, *dFmod_spot_fortran = NULL,
         *dFmod_inst_fortran = NULL;
  double tstart, tend;
  int i, j, k, Nsets;
  size_t size_Theta_spot_fortran, size_Theta_inst_fortran,
      size_dFmod_star_fortran, size_dFmod_spot_fortran, size_dFmod_inst_fortran;
  size_Theta_spot_fortran = 8 * Nspot + 1;
  size_Theta_inst_fortran = 2 + 1;
  size_dFmod_star_fortran = N * 12 + 1;
  size_dFmod_spot_fortran = N * 8 * Nspot + 1;
  size_dFmod_inst_fortran = N * 2 + 1;
  if (size_Theta_spot_fortran > 0) {
    if ((Theta_spot_fortran = (double *)malloc(size_Theta_spot_fortran *
                                               sizeof(double))) == NULL)
      VARTOOLS_error(3);
  }
  if (size_Theta_inst_fortran > 0) {
    if ((Theta_inst_fortran = (double *)malloc(size_Theta_inst_fortran *
                                               sizeof(double))) == NULL)
      VARTOOLS_error(3);
  }
  if (size_dFmod_star_fortran > 0) {
    if ((dFmod_star_fortran = (double *)malloc(size_dFmod_star_fortran *
                                               sizeof(double))) == NULL)
      VARTOOLS_error(3);
  }
  if (size_dFmod_spot_fortran > 0) {
    if ((dFmod_spot_fortran = (double *)malloc(size_dFmod_spot_fortran *
                                               sizeof(double))) == NULL)
      VARTOOLS_error(3);
  }
  if (size_dFmod_inst_fortran > 0) {
    if ((dFmod_inst_fortran = (double *)malloc(size_dFmod_inst_fortran *
                                               sizeof(double))) == NULL)
      VARTOOLS_error(3);
  }
  for (j = 0; j < 8; j++) {
    for (k = 0; k < Nspot; k++) {
      Theta_spot_fortran[j + 8 * k] = Theta_spot[j][k];
    }
  }
  Theta_inst_fortran[0] = baseflux;
  Theta_inst_fortran[1] = blend;
  tstart = JD[0] - 0.001;
  tend = JD[N - 1] + 0.001;
  Nsets = 1;
  MACULAFUNC(JD, &N, &Nspot, &Nsets, &derivatives, &temporal, &TdeltaV,
             Theta_star, Theta_spot_fortran, Theta_inst_fortran, &tstart, &tend,
             fluxout, dFmod_star_fortran, dFmod_spot_fortran,
             dFmod_inst_fortran, dFmoddt, deltaratio);
  if (derivatives) {
    for (i = 0; i < N; i++) {
      for (j = 0; j < 12; j++)
        dFmod_star[i][j] = dFmod_star_fortran[i + N * j];
      for (j = 0; j < 8; j++) {
        for (k = 0; k < Nspot; k++)
          dFmod_spot[i][j][k] = dFmod_spot_fortran[i + N * (j + 8 * k)];
      }
      for (j = 0; j < 2; j++) {
        dFmod_inst[i][j][0] = dFmod_inst_fortran[i + N * j];
      }
    }
  }
  if (Theta_spot_fortran != NULL)
    free(Theta_spot_fortran);
  if (Theta_inst_fortran != NULL)
    free(Theta_inst_fortran);
  if (dFmod_star_fortran != NULL)
    free(dFmod_star_fortran);
  if (dFmod_spot_fortran != NULL)
    free(dFmod_spot_fortran);
  if (dFmod_inst_fortran != NULL)
    free(dFmod_inst_fortran);
  return;
}


x86 assembly (clang, -O0):
<simulatemaculalc>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x2c(%rbp)
mov    %rsi,-0x38(%rbp)
mov    %rdx,-0x40(%rbp)
mov    %rcx,-0x48(%rbp)
mov    %r8d,-0x4c(%rbp)
mov    %r9,-0x58(%rbp)
movsd  %xmm0,-0x60(%rbp)
movsd  %xmm1,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
movq   $0x0,-0x90(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x3,%eax
add    $0x1,%eax
cltq
mov    %rax,-0xb8(%rbp)
movq   $0x3,-0xc0(%rbp)
imul   $0xc,-0x2c(%rbp),%eax
add    $0x1,%eax
cltq
mov    %rax,-0xc8(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x3,%eax
imul   -0x4c(%rbp),%eax
add    $0x1,%eax
cltq
mov    %rax,-0xd0(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    %rax,-0xd8(%rbp)
cmpq   $0x0,-0xb8(%rbp)
jbe    1250 <simulatemaculalc+0x110>
mov    -0xb8(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmp    $0x0,%rax
jne    124b <simulatemaculalc+0x10b>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
jmp    1250 <simulatemaculalc+0x110>
cmpq   $0x0,-0xc0(%rbp)
jbe    128b <simulatemaculalc+0x14b>
mov    -0xc0(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
cmp    $0x0,%rax
jne    1286 <simulatemaculalc+0x146>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
jmp    128b <simulatemaculalc+0x14b>
cmpq   $0x0,-0xc8(%rbp)
jbe    12c6 <simulatemaculalc+0x186>
mov    -0xc8(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
cmp    $0x0,%rax
jne    12c1 <simulatemaculalc+0x181>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
jmp    12c6 <simulatemaculalc+0x186>
cmpq   $0x0,-0xd0(%rbp)
jbe    1304 <simulatemaculalc+0x1c4>
mov    -0xd0(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x88(%rbp)
cmp    $0x0,%rax
jne    12ff <simulatemaculalc+0x1bf>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
jmp    1304 <simulatemaculalc+0x1c4>
cmpq   $0x0,-0xd8(%rbp)
jbe    1342 <simulatemaculalc+0x202>
mov    -0xd8(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x90(%rbp)
cmp    $0x0,%rax
jne    133d <simulatemaculalc+0x1fd>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
jmp    1342 <simulatemaculalc+0x202>
movl   $0x0,-0xa8(%rbp)
cmpl   $0x8,-0xa8(%rbp)
jge    13d7 <simulatemaculalc+0x297>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13be <simulatemaculalc+0x27e>
mov    -0x58(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xa8(%rbp),%ecx
mov    -0xac(%rbp),%edx
shl    $0x3,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1363 <simulatemaculalc+0x223>
jmp    13c3 <simulatemaculalc+0x283>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    134c <simulatemaculalc+0x20c>
movsd  -0x60(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xbfe(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xbdd(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0xb0(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x40(%rbp),%r15
mov    -0x80(%rbp),%r14
mov    -0x88(%rbp),%rbx
mov    -0x90(%rbp),%r11
mov    0x48(%rbp),%r10
mov    0x28(%rbp),%rax
mov    %rax,-0xe0(%rbp)
lea    -0x2c(%rbp),%rsi
lea    -0x4c(%rbp),%rdx
lea    -0xb0(%rbp),%rcx
lea    0x10(%rbp),%r8
lea    0x18(%rbp),%r9
lea    0x20(%rbp),%rax
lea    -0x98(%rbp),%r13
lea    -0xa0(%rbp),%r12
mov    %rax,(%rsp)
mov    -0xf8(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0xf0(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xe8(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0xe0(%rbp),%rax
mov    %r13,0x20(%rsp)
mov    %r12,0x28(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x38(%rsp)
mov    %rbx,0x40(%rsp)
mov    %r11,0x48(%rsp)
mov    %r10,0x50(%rsp)
mov    %rax,0x58(%rsp)
call   1040 <MACULAFUNC@plt>
cmpl   $0x0,0x10(%rbp)
je     16c9 <simulatemaculalc+0x589>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    16c4 <simulatemaculalc+0x584>
movl   $0x0,-0xa8(%rbp)
cmpl   $0xc,-0xa8(%rbp)
jge    1590 <simulatemaculalc+0x450>
mov    -0x80(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0xa8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1536 <simulatemaculalc+0x3f6>
movl   $0x0,-0xa8(%rbp)
cmpl   $0x8,-0xa8(%rbp)
jge    1641 <simulatemaculalc+0x501>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1628 <simulatemaculalc+0x4e8>
mov    -0x88(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0xa8(%rbp),%esi
mov    -0xac(%rbp),%edi
shl    $0x3,%edi
add    %edi,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    15b1 <simulatemaculalc+0x471>
jmp    162d <simulatemaculalc+0x4ed>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    159a <simulatemaculalc+0x45a>
movl   $0x0,-0xa8(%rbp)
cmpl   $0x2,-0xa8(%rbp)
jge    16ab <simulatemaculalc+0x56b>
mov    -0x90(%rbp),%rax
mov    -0xa4(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0xa8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    164b <simulatemaculalc+0x50b>
jmp    16b0 <simulatemaculalc+0x570>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    151d <simulatemaculalc+0x3dd>
jmp    16c9 <simulatemaculalc+0x589>
cmpq   $0x0,-0x70(%rbp)
je     16dd <simulatemaculalc+0x59d>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x78(%rbp)
je     16f1 <simulatemaculalc+0x5b1>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x80(%rbp)
je     1705 <simulatemaculalc+0x5c5>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x88(%rbp)
je     171f <simulatemaculalc+0x5df>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x90(%rbp)
je     1739 <simulatemaculalc+0x5f9>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<simulatemaculalc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
movsd  %xmm1,0x50(%rsp)
movsd  %xmm0,0x48(%rsp)
mov    %r9,0x40(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rsi,0x18(%rsp)
mov    %edi,%r12d
mov    %edi,0x3c(%rsp)
mov    %r8d,0x38(%rsp)
lea    0x0(,%r12,4),%eax
lea    (%rax,%rax,2),%ebx
or     $0x1,%ebx
mov    %edi,%ebp
imul   %r8d,%ebp
mov    %r8,%r14
lea    0x1(,%r8,8),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
test   %rax,%rax
jne    11b9 <simulatemaculalc+0x79>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
xor    %eax,%eax
mov    %rax,0x80(%rsp)
lea    0x1(,%rbp,8),%ebp
movslq %ebx,%rbx
mov    $0x18,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    %rax,0x58(%rsp)
test   %rax,%rax
jne    11f3 <simulatemaculalc+0xb3>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
xor    %eax,%eax
mov    %rax,0x58(%rsp)
mov    %r12,%r15
lea    (%r12,%r12,1),%r13d
add    $0x1,%r13d
movslq %ebp,%r12
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
test   %rax,%rax
jne    121e <simulatemaculalc+0xde>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
xor    %eax,%eax
mov    %rax,0x60(%rsp)
movslq %r13d,%rbp
shl    $0x3,%r12
mov    %r12,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
test   %rax,%rax
jne    1247 <simulatemaculalc+0x107>
mov    $0x3,%edi
call   1060 <VARTOOLS_error@plt>
xor    %r13d,%r13d
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
test   %rax,%rax
mov    0x80(%rsp),%r10
jne    1272 <simulatemaculalc+0x132>
mov    $0x3,%edi
mov    %r10,%rbx
call   1060 <VARTOOLS_error@plt>
mov    %rbx,%r10
xor    %eax,%eax
mov    %rax,0x70(%rsp)
mov    0x168(%rsp),%r11
mov    %r14,%rdx
test   %edx,%edx
mov    0x40(%rsp),%r14
jle    1793 <simulatemaculalc+0x653>
mov    (%r14),%rbx
mov    %edx,%eax
lea    -0x1(%rax),%r8
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    12a7 <simulatemaculalc+0x167>
xor    %edi,%edi
jmp    12fe <simulatemaculalc+0x1be>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xc0(%r10),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rbx,%rdi,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rbx,%rdi,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rbx,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rdi
add    $0x100,%rbp
cmp    %rdi,%rcx
jne    12c0 <simulatemaculalc+0x180>
test   %rsi,%rsi
je     1333 <simulatemaculalc+0x1f3>
lea    (%rbx,%rdi,8),%rcx
shl    $0x6,%rdi
add    %r10,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1320 <simulatemaculalc+0x1e0>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x8(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    134e <simulatemaculalc+0x20e>
xor    %ebx,%ebx
jmp    139e <simulatemaculalc+0x25e>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xc8(%r10),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rbx
add    $0x100,%rbp
cmp    %rbx,%rcx
jne    1360 <simulatemaculalc+0x220>
test   %rsi,%rsi
je     13d3 <simulatemaculalc+0x293>
lea    (%rdi,%rbx,8),%rcx
shl    $0x6,%rbx
lea    (%rbx,%r10,1),%rdi
add    $0x8,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    13c0 <simulatemaculalc+0x280>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x10(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    13ee <simulatemaculalc+0x2ae>
xor    %ebx,%ebx
jmp    143e <simulatemaculalc+0x2fe>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xd0(%r10),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rbx
add    $0x100,%rbp
cmp    %rbx,%rcx
jne    1400 <simulatemaculalc+0x2c0>
test   %rsi,%rsi
je     1473 <simulatemaculalc+0x333>
lea    (%rdi,%rbx,8),%rcx
shl    $0x6,%rbx
lea    (%rbx,%r10,1),%rdi
add    $0x10,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1460 <simulatemaculalc+0x320>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x18(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    148e <simulatemaculalc+0x34e>
xor    %ebx,%ebx
jmp    14de <simulatemaculalc+0x39e>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xd8(%r10),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rbx
add    $0x100,%rbp
cmp    %rbx,%rcx
jne    14a0 <simulatemaculalc+0x360>
test   %rsi,%rsi
je     1513 <simulatemaculalc+0x3d3>
lea    (%rdi,%rbx,8),%rcx
shl    $0x6,%rbx
lea    (%rbx,%r10,1),%rdi
add    $0x18,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1500 <simulatemaculalc+0x3c0>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x20(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    152e <simulatemaculalc+0x3ee>
xor    %ebx,%ebx
jmp    157e <simulatemaculalc+0x43e>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xe0(%r10),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rbx
add    $0x100,%rbp
cmp    %rbx,%rcx
jne    1540 <simulatemaculalc+0x400>
test   %rsi,%rsi
je     15b3 <simulatemaculalc+0x473>
lea    (%rdi,%rbx,8),%rcx
shl    $0x6,%rbx
lea    (%rbx,%r10,1),%rdi
add    $0x20,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    15a0 <simulatemaculalc+0x460>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x28(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    15ce <simulatemaculalc+0x48e>
xor    %ebx,%ebx
jmp    161e <simulatemaculalc+0x4de>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xe8(%r10),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rbx
add    $0x100,%rbp
cmp    %rbx,%rcx
jne    15e0 <simulatemaculalc+0x4a0>
test   %rsi,%rsi
je     1653 <simulatemaculalc+0x513>
lea    (%rdi,%rbx,8),%rcx
shl    $0x6,%rbx
lea    (%rbx,%r10,1),%rdi
add    $0x28,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1640 <simulatemaculalc+0x500>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x30(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    166e <simulatemaculalc+0x52e>
xor    %ebx,%ebx
jmp    16be <simulatemaculalc+0x57e>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0xf0(%r10),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x8(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x10(%rdi,%rbx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0x18(%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x4,%rbx
add    $0x100,%rbp
cmp    %rbx,%rcx
jne    1680 <simulatemaculalc+0x540>
test   %rsi,%rsi
je     16f3 <simulatemaculalc+0x5b3>
lea    (%rdi,%rbx,8),%rcx
shl    $0x6,%rbx
lea    (%rbx,%r10,1),%rdi
add    $0x30,%rdi
shl    $0x3,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rcx,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,8)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    16e0 <simulatemaculalc+0x5a0>
test   %edx,%edx
jle    1793 <simulatemaculalc+0x653>
mov    0x38(%r14),%rdi
mov    %eax,%esi
and    $0x3,%esi
cmp    $0x3,%r8
jae    170e <simulatemaculalc+0x5ce>
xor    %edx,%edx
jmp    175d <simulatemaculalc+0x61d>
and    $0xfffffffc,%eax
lea    0xf8(%r10),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,-0xc0(%rcx)
ff
movsd  0x8(%rdi,%rdx,8),%xmm0
movsd  %xmm0,-0x80(%rcx)
movsd  0x10(%rdi,%rdx,8),%xmm0
movsd  %xmm0,-0x40(%rcx)
movsd  0x18(%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx)
add    $0x4,%rdx
add    $0x100,%rcx
cmp    %rdx,%rax
jne    1720 <simulatemaculalc+0x5e0>
test   %rsi,%rsi
je     1793 <simulatemaculalc+0x653>
lea    (%rdi,%rdx,8),%rax
shl    $0x6,%rdx
lea    (%rdx,%r10,1),%rcx
add    $0x38,%rcx
shl    $0x3,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1780 <simulatemaculalc+0x640>
mov    0x58(%rsp),%rbx
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,(%rbx)
movsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x8(%rbx)
mov    0x18(%rsp),%rdi
movsd  (%rdi),%xmm0
addsd  0x1842(%rip),%xmm0
movsd  %xmm0,0x110(%rsp)
movslq %r15d,%rax
movsd  -0x8(%rdi,%rax,8),%xmm0
addsd  0x1830(%rip),%xmm0
movsd  %xmm0,0x108(%rsp)
movl   $0x1,0x7c(%rsp)
lea    0x108(%rsp),%rax
lea    0x110(%rsp),%r15
lea    0x160(%rsp),%r14
lea    0x3c(%rsp),%rsi
lea    0x38(%rsp),%rdx
lea    0x7c(%rsp),%rcx
lea    0x150(%rsp),%r8
lea    0x158(%rsp),%r9
push   %r11
push   0x190(%rsp)
mov    0x80(%rsp),%r12
push   %r12
mov    %r13,0x38(%rsp)
push   %r13
mov    0x80(%rsp),%rbp
push   %rbp
push   0x38(%rsp)
push   %rax
push   %r15
push   %rbx
push   %r10
push   0x58(%rsp)
push   %r14
call   1040 <MACULAFUNC@plt>
add    $0x60,%rsp
cmpl   $0x0,0x150(%rsp)
je     2056 <simulatemaculalc+0xf16>
mov    0x3c(%rsp),%ecx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
test   %ecx,%ecx
jle    2056 <simulatemaculalc+0xf16>
mov    %rbp,%rdi
mov    0x38(%rsp),%r13d
mov    0x18(%rsp),%r11
lea    (%r11,%r11,2),%rbp
mov    %rbp,0xa8(%rsp)
lea    0x0(,%r11,8),%rcx
mov    %rcx,0xf8(%rsp)
sub    %r11,%rcx
mov    %rcx,0xa0(%rsp)
mov    %r13d,%esi
and    $0xfffffffe,%esi
mov    %r11,%r8
shl    $0x6,%r8
mov    %r11,%rcx
shl    $0x7,%rcx
mov    %r11,%r15
shl    $0x4,%r15
mov    0x20(%rsp),%rdx
add    %rdx,%r15
shl    $0x5,%rbp
add    %rdx,%rbp
mov    %rbp,0xb0(%rsp)
mov    %r11,%rbp
shl    $0x5,%rbp
add    %rdx,%rbp
imul   $0x68,%r11,%rbx
add    %rdx,%rbx
mov    %rbx,0x30(%rsp)
imul   $0x70,%r11,%rbx
add    %rdx,%rbx
imul   $0x78,%r11,%r10
add    %rdx,%r10
lea    (%r11,%r11,1),%r14
lea    0x0(,%r11,4),%rax
mov    %rax,0xe8(%rsp)
lea    (%r11,%r11,4),%r9
lea    (%r14,%r14,2),%rax
mov    %rax,0x98(%rsp)
lea    (%r11,%r11,8),%r12
mov    %r14,0xf0(%rsp)
lea    (%r14,%r14,4),%r14
lea    (%r11,%r9,2),%rax
mov    %rax,0x90(%rsp)
mov    %r13,0x8(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0x28(%rsp)
mov    %r12,0xd8(%rsp)
lea    (%rdx,%r12,8),%r13
lea    (%rdx,%r11,8),%r11
mov    %r14,0xd0(%rsp)
lea    (%rdx,%r14,8),%r14
mov    0x90(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0xc0(%rsp)
mov    0xa8(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0xb8(%rsp)
mov    %r9,0xe0(%rsp)
lea    (%rdx,%r9,8),%rax
mov    %rax,0x10(%rsp)
mov    0x98(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    %rdx,%r12
mov    0xa0(%rsp),%rdx
lea    (%r12,%rdx,8),%rdx
mov    %rdx,0x88(%rsp)
xor    %r9d,%r9d
mov    %r12,0xc8(%rsp)
jmp    1a8e <simulatemaculalc+0x94e>
xchg   %ax,%ax
mov    0x180(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x70(%rsp),%rbx
movsd  (%rbx,%r9,8),%xmm0
mov    (%rdx),%rbp
movsd  %xmm0,0x0(%rbp)
mov    0x100(%rsp),%rbp
movsd  (%rbx,%rbp,8),%xmm0
mov    0x8(%rdx),%rdx
movsd  %xmm0,(%rdx)
add    $0x1,%r9
addq   $0x8,0xc8(%rsp)
add    $0x8,%r13
add    $0x8,%r11
add    $0x8,%r14
add    $0x8,%r15
addq   $0x8,0xc0(%rsp)
addq   $0x8,0xb8(%rsp)
addq   $0x8,0xb0(%rsp)
mov    0x50(%rsp),%rbp
add    $0x8,%rbp
addq   $0x8,0x30(%rsp)
add    $0x8,%r12
mov    %r12,0x10(%rsp)
mov    0x48(%rsp),%rbx
add    $0x8,%rbx
mov    0x40(%rsp),%rax
add    $0x8,%rax
add    $0x8,%r10
addq   $0x8,0x88(%rsp)
cmp    0x18(%rsp),%r9
je     2056 <simulatemaculalc+0xf16>
mov    %rax,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %rbp,0x50(%rsp)
mov    0x18(%rsp),%rax
lea    (%r9,%rax,1),%rbx
mov    0xf0(%rsp),%rax
lea    (%rax,%r9,1),%rdx
mov    0x170(%rsp),%rax
mov    (%rax,%r9,8),%rbp
movsd  (%rdi,%r9,8),%xmm0
movsd  %xmm0,0x0(%rbp)
mov    %rbx,0x100(%rsp)
movsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,0x8(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xa8(%rsp),%rdx
lea    (%rdx,%r9,1),%rdx
movsd  %xmm0,0x10(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xe8(%rsp),%rax
lea    (%rax,%r9,1),%rdx
movsd  %xmm0,0x18(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xe0(%rsp),%rax
lea    (%rax,%r9,1),%rdx
movsd  %xmm0,0x20(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0x98(%rsp),%rax
lea    (%rax,%r9,1),%rdx
movsd  %xmm0,0x28(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xa0(%rsp),%rdx
lea    (%rdx,%r9,1),%rdx
movsd  %xmm0,0x30(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xf8(%rsp),%rdx
lea    (%rdx,%r9,1),%rdx
movsd  %xmm0,0x38(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xd8(%rsp),%rax
lea    (%rax,%r9,1),%rdx
movsd  %xmm0,0x40(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0xd0(%rsp),%rax
lea    (%rax,%r9,1),%rdx
movsd  %xmm0,0x48(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
mov    0x90(%rsp),%rax
lea    (%rax,%r9,1),%rdx
movsd  %xmm0,0x50(%rbp)
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x58(%rbp)
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%r12
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    (%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
je     1c10 <simulatemaculalc+0xad0>
mov    0xc8(%rsp),%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%rdx,%r8,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1be0 <simulatemaculalc+0xaa0>
jmp    1c12 <simulatemaculalc+0xad2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
test   $0x1,%dl
je     1c42 <simulatemaculalc+0xb02>
mov    %rbp,%rdx
imul   0x18(%rsp),%rdx
lea    (%r9,%rdx,8),%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%rbx,%rbp,8)
test   %edx,%edx
jle    19e0 <simulatemaculalc+0x8a0>
mov    %r10,0x68(%rsp)
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x8(%rdx),%r10
cmpq   $0x0,0x28(%rsp)
je     1c98 <simulatemaculalc+0xb58>
xor    %edx,%edx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%r11,%rdx,1),%xmm0
movsd  %xmm0,(%r10,%rbx,8)
movsd  0x0(%r13,%rdx,1),%xmm0
movsd  %xmm0,0x8(%r10,%rbx,8)
add    $0x2,%rbx
add    %rcx,%rdx
cmp    %rbx,%rsi
jne    1c70 <simulatemaculalc+0xb30>
jmp    1c9a <simulatemaculalc+0xb5a>
xor    %ebx,%ebx
mov    0x8(%rsp),%rdx
test   $0x1,%dl
je     1ccf <simulatemaculalc+0xb8f>
lea    0x1(,%rbx,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%r10,%rbx,8)
test   %edx,%edx
mov    0x60(%rsp),%rdi
mov    0x68(%rsp),%r10
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x10(%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
je     1d25 <simulatemaculalc+0xbe5>
xor    %edx,%edx
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%r15,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%r14,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1d00 <simulatemaculalc+0xbc0>
jmp    1d27 <simulatemaculalc+0xbe7>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
test   $0x1,%dl
je     1d5b <simulatemaculalc+0xc1b>
lea    0x2(,%rbp,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%rbx,%rbp,8)
test   %edx,%edx
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x18(%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
mov    %r12,0x10(%rsp)
je     1dc4 <simulatemaculalc+0xc84>
xor    %edx,%edx
xor    %ebp,%ebp
mov    0xc0(%rsp),%r12
mov    0xb8(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%r12,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1da0 <simulatemaculalc+0xc60>
jmp    1dc6 <simulatemaculalc+0xc86>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
test   $0x1,%dl
mov    0x10(%rsp),%r12
je     1dff <simulatemaculalc+0xcbf>
lea    0x3(,%rbp,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%rbx,%rbp,8)
test   %edx,%edx
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x20(%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
je     1e54 <simulatemaculalc+0xd14>
xor    %edx,%edx
xor    %ebp,%ebp
mov    0xb0(%rsp),%r10
mov    0x50(%rsp),%rax
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%r10,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1e30 <simulatemaculalc+0xcf0>
jmp    1e56 <simulatemaculalc+0xd16>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
test   $0x1,%dl
mov    0x30(%rsp),%rax
mov    0x68(%rsp),%r10
mov    0x10(%rsp),%r12
je     1e9e <simulatemaculalc+0xd5e>
lea    0x4(,%rbp,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x30(%rsp),%rax
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%rbx,%rbp,8)
mov    %rax,0x30(%rsp)
test   %edx,%edx
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x28(%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
je     1ef4 <simulatemaculalc+0xdb4>
xor    %edx,%edx
xor    %ebp,%ebp
mov    0x30(%rsp),%rax
nopl   0x0(%rax)
movsd  (%r12,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1ed0 <simulatemaculalc+0xd90>
jmp    1ef6 <simulatemaculalc+0xdb6>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
test   $0x1,%dl
je     1f2a <simulatemaculalc+0xdea>
lea    0x5(,%rbp,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%rbx,%rbp,8)
test   %edx,%edx
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x30(%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
je     1f84 <simulatemaculalc+0xe44>
xor    %edx,%edx
xor    %ebp,%ebp
mov    0x48(%rsp),%r10
mov    0x40(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%r10,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1f60 <simulatemaculalc+0xe20>
jmp    1f86 <simulatemaculalc+0xe46>
xor    %ebp,%ebp
mov    0x8(%rsp),%rdx
test   $0x1,%dl
mov    0x68(%rsp),%r10
je     1fbf <simulatemaculalc+0xe7f>
lea    0x6(,%rbp,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
movsd  %xmm0,(%rbx,%rbp,8)
test   %edx,%edx
jle    19e0 <simulatemaculalc+0x8a0>
mov    0x178(%rsp),%rdx
mov    (%rdx,%r9,8),%rdx
mov    0x38(%rdx),%rbx
cmpq   $0x0,0x28(%rsp)
je     201f <simulatemaculalc+0xedf>
xor    %edx,%edx
xor    %ebp,%ebp
mov    0x88(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,1),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
movsd  (%r10,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rcx,%rdx
cmp    %rbp,%rsi
jne    1ff0 <simulatemaculalc+0xeb0>
testb  $0x1,0x8(%rsp)
je     19e0 <simulatemaculalc+0x8a0>
jmp    202c <simulatemaculalc+0xeec>
xor    %ebp,%ebp
testb  $0x1,0x8(%rsp)
je     19e0 <simulatemaculalc+0x8a0>
lea    0x7(,%rbp,8),%rdx
imul   0x18(%rsp),%rdx
add    %r9,%rdx
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mov    0x10(%rsp),%r12
movsd  %xmm0,(%rbx,%rbp,8)
jmp    19e0 <simulatemaculalc+0x8a0>
mov    0x80(%rsp),%rdi
test   %rdi,%rdi
je     2068 <simulatemaculalc+0xf28>
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
test   %rdi,%rdi
mov    0x20(%rsp),%rbx
je     2086 <simulatemaculalc+0xf46>
call   1030 <free@plt>
test   %rbx,%rbx
je     2093 <simulatemaculalc+0xf53>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
test   %rdi,%rdi
je     20a2 <simulatemaculalc+0xf62>
call   1030 <free@plt>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @simulatemaculalc(i32 %0, double* %1, double* %2, double* %3, i32 %4, double** %5, double %6, double %7, i32 %8, i32 %9, i32 %10, double* %11, double** %12, double*** %13, double*** %14, double* %15) {
%17 = alloca i32
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca i32
%22 = alloca double**
%23 = alloca double
%24 = alloca double
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca double*
%29 = alloca double**
%30 = alloca double***
%31 = alloca double***
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double
%39 = alloca double
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i64
%45 = alloca i64
%46 = alloca i64
%47 = alloca i64
%48 = alloca i64
store i32 %0, i32* %17
store double* %1, double** %18
store double* %2, double** %19
store double* %3, double** %20
store i32 %4, i32* %21
store double** %5, double*** %22
store double %6, double* %23
store double %7, double* %24
store i32 %8, i32* %25
store i32 %9, i32* %26
store i32 %10, i32* %27
store double* %11, double** %28
store double** %12, double*** %29
store double*** %13, double**** %30
store double*** %14, double**** %31
store double* %15, double** %32
store double* null, double** %33
store double* null, double** %34
store double* null, double** %35
store double* null, double** %36
store double* null, double** %37
%49 = load i32, i32* %21
%50 = mul nsw i32 8, %49
%51 = add nsw i32 %50, 1
%52 = sext i32 %51 to i64
store i64 %52, i64* %44
store i64 3, i64* %45
%53 = load i32, i32* %17
%54 = mul nsw i32 %53, 12
%55 = add nsw i32 %54, 1
%56 = sext i32 %55 to i64
store i64 %56, i64* %46
%57 = load i32, i32* %17
%58 = mul nsw i32 %57, 8
%59 = load i32, i32* %21
%60 = mul nsw i32 %58, %59
%61 = add nsw i32 %60, 1
%62 = sext i32 %61 to i64
store i64 %62, i64* %47
%63 = load i32, i32* %17
%64 = mul nsw i32 %63, 2
%65 = add nsw i32 %64, 1
%66 = sext i32 %65 to i64
store i64 %66, i64* %48
%67 = load i64, i64* %44
%68 = icmp ugt i64 %67, 0
br i1 %68, label %69, label %78
69: ; preds = %16
%70 = load i64, i64* %44
%71 = mul i64 %70, 8
%72 = call i64 @malloc(i64 %71)
%73 = inttoptr i64 %72 to double*
store double* %73, double** %33
%74 = icmp eq double* %73, null
br i1 %74, label %75, label %77
75: ; preds = %69
%76 = call i32 @VARTOOLS_error(i32 3)
br label %77
77: ; preds = %75, %69
br label %78
78: ; preds = %77, %16
%79 = load i64, i64* %45
%80 = icmp ugt i64 %79, 0
br i1 %80, label %81, label %90
81: ; preds = %78
%82 = load i64, i64* %45
%83 = mul i64 %82, 8
%84 = call i64 @malloc(i64 %83)
%85 = inttoptr i64 %84 to double*
store double* %85, double** %34
%86 = icmp eq double* %85, null
br i1 %86, label %87, label %89
87: ; preds = %81
%88 = call i32 @VARTOOLS_error(i32 3)
br label %89
89: ; preds = %87, %81
br label %90
90: ; preds = %89, %78
%91 = load i64, i64* %46
%92 = icmp ugt i64 %91, 0
br i1 %92, label %93, label %102
93: ; preds = %90
%94 = load i64, i64* %46
%95 = mul i64 %94, 8
%96 = call i64 @malloc(i64 %95)
%97 = inttoptr i64 %96 to double*
store double* %97, double** %35
%98 = icmp eq double* %97, null
br i1 %98, label %99, label %101
99: ; preds = %93
%100 = call i32 @VARTOOLS_error(i32 3)
br label %101
101: ; preds = %99, %93
br label %102
102: ; preds = %101, %90
%103 = load i64, i64* %47
%104 = icmp ugt i64 %103, 0
br i1 %104, label %105, label %114
105: ; preds = %102
%106 = load i64, i64* %47
%107 = mul i64 %106, 8
%108 = call i64 @malloc(i64 %107)
%109 = inttoptr i64 %108 to double*
store double* %109, double** %36
%110 = icmp eq double* %109, null
br i1 %110, label %111, label %113
111: ; preds = %105
%112 = call i32 @VARTOOLS_error(i32 3)
br label %113
113: ; preds = %111, %105
br label %114
114: ; preds = %113, %102
%115 = load i64, i64* %48
%116 = icmp ugt i64 %115, 0
br i1 %116, label %117, label %126
117: ; preds = %114
%118 = load i64, i64* %48
%119 = mul i64 %118, 8
%120 = call i64 @malloc(i64 %119)
%121 = inttoptr i64 %120 to double*
store double* %121, double** %37
%122 = icmp eq double* %121, null
br i1 %122, label %123, label %125
123: ; preds = %117
%124 = call i32 @VARTOOLS_error(i32 3)
br label %125
125: ; preds = %123, %117
br label %126
126: ; preds = %125, %114
store i32 0, i32* %41
br label %127
127: ; preds = %156, %126
%128 = load i32, i32* %41
%129 = icmp slt i32 %128, 8
br i1 %129, label %130, label %159
130: ; preds = %127
store i32 0, i32* %42
br label %131
131: ; preds = %152, %130
%132 = load i32, i32* %42
%133 = load i32, i32* %21
%134 = icmp slt i32 %132, %133
br i1 %134, label %135, label %155
135: ; preds = %131
%136 = load double**, double*** %22
%137 = load i32, i32* %41
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double*, double** %136, i64 %138
%140 = load double*, double** %139
%141 = load i32, i32* %42
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %140, i64 %142
%144 = load double, double* %143
%145 = load double*, double** %33
%146 = load i32, i32* %41
%147 = load i32, i32* %42
%148 = mul nsw i32 8, %147
%149 = add nsw i32 %146, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %145, i64 %150
store double %144, double* %151
br label %152
152: ; preds = %135
%153 = load i32, i32* %42
%154 = add nsw i32 %153, 1
store i32 %154, i32* %42
br label %131
155: ; preds = %131
br label %156
156: ; preds = %155
%157 = load i32, i32* %41
%158 = add nsw i32 %157, 1
store i32 %158, i32* %41
br label %127
159: ; preds = %127
%160 = load double, double* %23
%161 = load double*, double** %34
%162 = getelementptr inbounds double, double* %161, i64 0
store double %160, double* %162
%163 = load double, double* %24
%164 = load double*, double** %34
%165 = getelementptr inbounds double, double* %164, i64 1
store double %163, double* %165
%166 = load double*, double** %18
%167 = getelementptr inbounds double, double* %166, i64 0
%168 = load double, double* %167
%169 = fsub double %168, 1.000000e-03
store double %169, double* %38
%170 = load double*, double** %18
%171 = load i32, i32* %17
%172 = sub nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds double, double* %170, i64 %173
%175 = load double, double* %174
%176 = fadd double %175, 1.000000e-03
store double %176, double* %39
store i32 1, i32* %43
%177 = load double*, double** %18
%178 = load double*, double** %20
%179 = load double*, double** %33
%180 = load double*, double** %34
%181 = load double*, double** %19
%182 = load double*, double** %35
%183 = load double*, double** %36
%184 = load double*, double** %37
%185 = load double*, double** %32
%186 = load double*, double** %28
%187 = call i32 @MACULAFUNC(double* %177, i32* %17, i32* %21, i32* %43, i32* %25, i32* %26, i32* %27, double* %178, double* %179, double* %180, double* %38, double* %39, double* %181, double* %182, double* %183, double* %184, double* %185, double* %186)
%188 = load i32, i32* %25
%189 = icmp ne i32 %188, 0
br i1 %189, label %190, label %293
190: ; preds = %159
store i32 0, i32* %40
br label %191
191: ; preds = %289, %190
%192 = load i32, i32* %40
%193 = load i32, i32* %17
%194 = icmp slt i32 %192, %193
br i1 %194, label %195, label %292
195: ; preds = %191
store i32 0, i32* %41
br label %196
196: ; preds = %217, %195
%197 = load i32, i32* %41
%198 = icmp slt i32 %197, 12
br i1 %198, label %199, label %220
199: ; preds = %196
%200 = load double*, double** %35
%201 = load i32, i32* %40
%202 = load i32, i32* %17
%203 = load i32, i32* %41
%204 = mul nsw i32 %202, %203
%205 = add nsw i32 %201, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %200, i64 %206
%208 = load double, double* %207
%209 = load double**, double*** %29
%210 = load i32, i32* %40
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double*, double** %209, i64 %211
%213 = load double*, double** %212
%214 = load i32, i32* %41
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %213, i64 %215
store double %208, double* %216
br label %217
217: ; preds = %199
%218 = load i32, i32* %41
%219 = add nsw i32 %218, 1
store i32 %219, i32* %41
br label %196
220: ; preds = %196
store i32 0, i32* %41
br label %221
221: ; preds = %258, %220
%222 = load i32, i32* %41
%223 = icmp slt i32 %222, 8
br i1 %223, label %224, label %261
224: ; preds = %221
store i32 0, i32* %42
br label %225
225: ; preds = %254, %224
%226 = load i32, i32* %42
%227 = load i32, i32* %21
%228 = icmp slt i32 %226, %227
br i1 %228, label %229, label %257
229: ; preds = %225
%230 = load double*, double** %36
%231 = load i32, i32* %40
%232 = load i32, i32* %17
%233 = load i32, i32* %41
%234 = load i32, i32* %42
%235 = mul nsw i32 8, %234
%236 = add nsw i32 %233, %235
%237 = mul nsw i32 %232, %236
%238 = add nsw i32 %231, %237
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double, double* %230, i64 %239
%241 = load double, double* %240
%242 = load double***, double**** %30
%243 = load i32, i32* %40
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds double**, double*** %242, i64 %244
%246 = load double**, double*** %245
%247 = load i32, i32* %41
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds double*, double** %246, i64 %248
%250 = load double*, double** %249
%251 = load i32, i32* %42
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
store double %241, double* %253
br label %254
254: ; preds = %229
%255 = load i32, i32* %42
%256 = add nsw i32 %255, 1
store i32 %256, i32* %42
br label %225
257: ; preds = %225
br label %258
258: ; preds = %257
%259 = load i32, i32* %41
%260 = add nsw i32 %259, 1
store i32 %260, i32* %41
br label %221
261: ; preds = %221
store i32 0, i32* %41
br label %262
262: ; preds = %285, %261
%263 = load i32, i32* %41
%264 = icmp slt i32 %263, 2
br i1 %264, label %265, label %288
265: ; preds = %262
%266 = load double*, double** %37
%267 = load i32, i32* %40
%268 = load i32, i32* %17
%269 = load i32, i32* %41
%270 = mul nsw i32 %268, %269
%271 = add nsw i32 %267, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %266, i64 %272
%274 = load double, double* %273
%275 = load double***, double**** %31
%276 = load i32, i32* %40
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double**, double*** %275, i64 %277
%279 = load double**, double*** %278
%280 = load i32, i32* %41
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds double*, double** %279, i64 %281
%283 = load double*, double** %282
%284 = getelementptr inbounds double, double* %283, i64 0
store double %274, double* %284
br label %285
285: ; preds = %265
%286 = load i32, i32* %41
%287 = add nsw i32 %286, 1
store i32 %287, i32* %41
br label %262
288: ; preds = %262
br label %289
289: ; preds = %288
%290 = load i32, i32* %40
%291 = add nsw i32 %290, 1
store i32 %291, i32* %40
br label %191
292: ; preds = %191
br label %293
293: ; preds = %292, %159
%294 = load double*, double** %33
%295 = icmp ne double* %294, null
br i1 %295, label %296, label %299
296: ; preds = %293
%297 = load double*, double** %33
%298 = call i32 @free(double* %297)
br label %299
299: ; preds = %296, %293
%300 = load double*, double** %34
%301 = icmp ne double* %300, null
br i1 %301, label %302, label %305
302: ; preds = %299
%303 = load double*, double** %34
%304 = call i32 @free(double* %303)
br label %305
305: ; preds = %302, %299
%306 = load double*, double** %35
%307 = icmp ne double* %306, null
br i1 %307, label %308, label %311
308: ; preds = %305
%309 = load double*, double** %35
%310 = call i32 @free(double* %309)
br label %311
311: ; preds = %308, %305
%312 = load double*, double** %36
%313 = icmp ne double* %312, null
br i1 %313, label %314, label %317
314: ; preds = %311
%315 = load double*, double** %36
%316 = call i32 @free(double* %315)
br label %317
317: ; preds = %314, %311
%318 = load double*, double** %37
%319 = icmp ne double* %318, null
br i1 %319, label %320, label %323
320: ; preds = %317
%321 = load double*, double** %37
%322 = call i32 @free(double* %321)
br label %323
323: ; preds = %320, %317
ret void
}

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