#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 abs(int);
double fabs(double);
int floor(double);
int /*<<< orphan*/ iniparll(int *, int *, double *, double *, double *,
                            double *, double *, double *, double *, double *,
                            int *, int *);
int /*<<< orphan*/ setpardou(double *, int, int, int);
scalar_t__ strcmp1(char *, char *);
void resultsini(int *nk, double *v, int *ithermal, char *filab, int *iperturb,
                double *f, double *fn, int *nactdof, int *iout, double *qa,
                double *vold, double *b, int *nodeboun, int *ndirboun,
                double *xboun, int *nboun, int *ipompc, int *nodempc,
                double *coefmpc, char *labmpc, int *nmpc, int *nmethod,
                double *cam, int *neq, double *veold, double *accold,
                double *bet, double *gam, double *dtime, int *mi, double *vini,
                int *nprint, char *prlab, int *intpointvarm, int *calcul_fn,
                int *calcul_f, int *calcul_qa, int *calcul_cauchy, int *ikin,
                int *intpointvart, char *typeboun, int *num_cpus) {
  int mt, i, j, node, ndir, ist, index, incrementalmpc;
  double bnac, scal1, scal2, fixed_disp;
  mt = mi[1] + 1;
  if ((*iout != 2) && (*iout > -1)) {
    if ((*nmethod != 4) || (iperturb[0] <= 1)) {
      if (ithermal[0] != 2) {
        for (i = 0; i < *nk; i++) {
          for (j = 1; j < mt; j++) {
            if (nactdof[mt * i + j] > 0) {
              bnac = b[nactdof[mt * i + j] - 1];
            } else {
              continue;
            }
            v[mt * i + j] += bnac;
            if ((iperturb[0] != 0) && (abs(*nmethod) == 1)) {
              if (fabs(bnac) > cam[0]) {
                cam[0] = fabs(bnac);
                cam[3] = nactdof[mt * i + j] - 0.5;
              }
            }
          }
        }
      }
      if (ithermal[0] > 1) {
        for (i = 0; i < *nk; i++) {
          if (nactdof[mt * i] > 0) {
            bnac = b[nactdof[mt * i] - 1];
          } else {
            continue;
          }
          v[mt * i] += bnac;
          if ((iperturb[0] != 0) && (abs(*nmethod) == 1)) {
            if (fabs(bnac) > cam[1]) {
              cam[1] = fabs(bnac);
              cam[4] = nactdof[mt * i] - 0.5;
            }
          }
        }
      }
    } else {
      if (ithermal[0] != 2) {
        iniparll(&mt, nactdof, b, v, veold, accold, bet, gam, dtime, cam, nk,
                 num_cpus);
      }
      if (ithermal[0] > 1) {
        for (i = 0; i < *nk; i++) {
          veold[mt * i] = 0.;
          if (nactdof[mt * i] > 0) {
            bnac = b[nactdof[mt * i] - 1];
          } else {
            continue;
          }
          v[mt * i] += bnac;
          if (fabs(bnac) > cam[1]) {
            cam[1] = fabs(bnac);
            cam[4] = nactdof[mt * i] - 0.5;
          }
          if (cam[2] < fabs(v[mt * i] - vini[mt * i])) {
            cam[2] = fabs(v[mt * i] - vini[mt * i]);
          }
        }
      }
    }
  }
  *calcul_fn = 0;
  *calcul_f = 0;
  *calcul_qa = 0;
  *calcul_cauchy = 0;
  if ((iperturb[0] >= 2) || ((iperturb[0] <= 0) && (*iout < 0))) {
    if ((*iout < 1) && (*iout > -2)) {
      *calcul_fn = 1;
      *calcul_f = 1;
      *calcul_qa = 1;
    } else if ((*iout != -2) && (iperturb[1] == 1)) {
      *calcul_cauchy = 1;
    }
  }
  if (*iout > 0) {
    if ((strcmp1(&filab[348], "RF  ") == 0) ||
        (strcmp1(&filab[783], "RFL ") == 0)) {
      *calcul_fn = 1;
    }
    if (*calcul_fn != 1) {
      for (i = 0; i < *nprint; i++) {
        if ((strcmp1(&prlab[6 * i], "RF  ") == 0) ||
            (strcmp1(&prlab[6 * i], "RFL ") == 0)) {
          *calcul_fn = 1;
          break;
        }
      }
    }
  }
  if (*calcul_fn == 1) {
    setpardou(fn, 0., mt * *nk, *num_cpus);
  }
  if (*calcul_f == 1) {
    setpardou(f, 0., *neq, *num_cpus);
  }
  if (abs(*iout) < 2) {
    for (i = 0; i < *nboun; i++) {
      if ((ndirboun[i] > mi[1]) || (typeboun[i] == 'F'))
        continue;
      fixed_disp = xboun[i];
      if ((*nmethod == 4) && (iperturb[0] > 1)) {
        ndir = ndirboun[i];
        node = nodeboun[i] - 1;
        if (ndir > 0) {
          bnac = (xboun[i] - v[mt * node + ndir]) / (*bet * *dtime * *dtime);
          if (floor(*dtime * 1.e28 + 0.5) != 123571113) {
            veold[mt * node + ndir] += *gam * *dtime * bnac;
            accold[mt * node + ndir] += bnac;
          }
        }
      }
      v[mt * (nodeboun[i] - 1) + ndirboun[i]] = fixed_disp;
    }
    for (i = 0; i < *nmpc; i++) {
      if (strcmp1(&labmpc[20 * i], "FLUID") == 0)
        continue;
      if ((strcmp1(&labmpc[20 * i], "                    ") == 0) ||
          (strcmp1(&labmpc[20 * i], "CYCLIC") == 0) ||
          (strcmp1(&labmpc[20 * i], "SUBCYCLIC") == 0)) {
        incrementalmpc = 0;
      } else {
        if ((*nmethod == 2) || (*nmethod == 3) ||
            ((iperturb[0] == 0) && (abs(*nmethod) == 1))) {
          incrementalmpc = 0;
        } else {
          incrementalmpc = 1;
        }
      }
      ist = ipompc[i] - 1;
      node = nodempc[3 * ist] - 1;
      ndir = nodempc[3 * ist + 1];
      if (ndir == 0) {
        if (ithermal[0] < 2)
          continue;
      } else if (ndir > mi[1]) {
        continue;
      } else {
        if (ithermal[0] == 2)
          continue;
      }
      index = nodempc[3 * ist + 2] - 1;
      fixed_disp = 0.;
      if (index != -1) {
        do {
          if (incrementalmpc == 0) {
            fixed_disp -=
                coefmpc[index] *
                v[mt * (nodempc[3 * index] - 1) + nodempc[3 * index + 1]];
          } else {
            fixed_disp -=
                coefmpc[index] *
                (v[mt * (nodempc[3 * index] - 1) + nodempc[3 * index + 1]] -
                 vold[mt * (nodempc[3 * index] - 1) + nodempc[3 * index + 1]]);
          }
          index = nodempc[3 * index + 2] - 1;
          if (index == -1)
            break;
        } while (1);
      }
      fixed_disp /= coefmpc[ist];
      if (incrementalmpc == 1) {
        fixed_disp += vold[mt * node + ndir];
      }
      if ((*nmethod == 4) && (iperturb[0] > 1)) {
        if (ndir > 0) {
          bnac = (fixed_disp - v[mt * node + ndir]) / (*bet * *dtime * *dtime);
          if (floor(*dtime * 1.e28 + 0.5) != 123571113) {
            veold[mt * node + ndir] += *gam * *dtime * bnac;
          }
          accold[mt * node + ndir] += bnac;
        }
      }
      v[mt * node + ndir] = fixed_disp;
    }
  }
  *ikin = 0;
  if ((*nmethod == 4) && (iperturb[0] > 1) && (ithermal[0] <= 1)) {
    *ikin = 1;
  }
  if (*ikin != 1) {
    for (i = 0; i < *nprint; i++) {
      if (strcmp1(&prlab[6 * i], "ELKE") == 0) {
        *ikin = 1;
      }
    }
  }
  qa[0] = 0.;
  qa[1] = 0.;
  *intpointvarm = 1;
  *intpointvart = 1;
  if ((*nmethod >= 4) && (*nmethod <= 5) && (iperturb[0] < 2)) {
    *intpointvarm = 0;
    if ((strcmp1(&filab[174], "S") == 0) || (strcmp1(&filab[261], "E") == 0) ||
        (strcmp1(&filab[348], "RF") == 0) ||
        (strcmp1(&filab[435], "PEEQ") == 0) ||
        (strcmp1(&filab[522], "ENER") == 0) ||
        (strcmp1(&filab[609], "SDV") == 0) ||
        (strcmp1(&filab[1044], "ZZS") == 0) ||
        (strcmp1(&filab[1044], "ERR") == 0) ||
        (strcmp1(&filab[1479], "PHS") == 0) ||
        (strcmp1(&filab[1653], "MAXS") == 0) ||
        (strcmp1(&filab[2175], "CONT") == 0) ||
        (strcmp1(&filab[2262], "CELS") == 0)) {
      *intpointvarm = 1;
    }
    if (*intpointvarm != 1) {
      for (i = 0; i < *nprint; i++) {
        if ((strcmp1(&prlab[6 * i], "S") == 0) ||
            (strcmp1(&prlab[6 * i], "E") == 0) ||
            (strcmp1(&prlab[6 * i], "PEEQ") == 0) ||
            (strcmp1(&prlab[6 * i], "ENER") == 0) ||
            (strcmp1(&prlab[6 * i], "ELKE") == 0) ||
            (strcmp1(&prlab[6 * i], "CDIS") == 0) ||
            (strcmp1(&prlab[6 * i], "CSTR") == 0) ||
            (strcmp1(&prlab[6 * i], "CELS") == 0) ||
            (strcmp1(&prlab[6 * i], "SDV") == 0) ||
            (strcmp1(&prlab[6 * i], "RF") == 0)) {
          *intpointvarm = 1;
          break;
        }
      }
    }
    *intpointvart = 0;
    if ((strcmp1(&filab[696], "HFL") == 0) ||
        (strcmp1(&filab[783], "RFL") == 0)) {
      *intpointvart = 1;
    }
    if (*intpointvart != 1) {
      for (i = 0; i < *nprint; i++) {
        if ((strcmp1(&prlab[6 * i], "HFL") == 0) ||
            (strcmp1(&prlab[6 * i], "RFL") == 0)) {
          *intpointvart = 1;
          break;
        }
      }
    }
    if (*calcul_fn == 1) {
      *intpointvarm = 1;
      *intpointvart = 1;
    }
  }
  return;
}


x86 assembly (clang, -O0):
<resultsini>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0xa8,%rsp
mov    0x128(%rbp),%rax
mov    0x120(%rbp),%rax
mov    0x118(%rbp),%rax
mov    0x110(%rbp),%rax
mov    0x108(%rbp),%rax
mov    0x100(%rbp),%rax
mov    0xf8(%rbp),%rax
mov    0xf0(%rbp),%rax
mov    0xe8(%rbp),%rax
mov    0xe0(%rbp),%rax
mov    0xd8(%rbp),%rax
mov    0xd0(%rbp),%rax
mov    0xc8(%rbp),%rax
mov    0xc0(%rbp),%rax
mov    0xb8(%rbp),%rax
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    0xc8(%rbp),%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x20(%rbp),%rax
cmpl   $0x2,(%rax)
je     1751 <resultsini+0x601>
mov    0x20(%rbp),%rax
cmpl   $0xffffffff,(%rax)
jle    1751 <resultsini+0x601>
mov    0x88(%rbp),%rax
cmpl   $0x4,(%rax)
jne    1291 <resultsini+0x141>
mov    -0x40(%rbp),%rax
cmpl   $0x1,(%rax)
jg     1528 <resultsini+0x3d8>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
je     13f2 <resultsini+0x2a2>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    13ed <resultsini+0x29d>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13da <resultsini+0x28a>
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    130f <resultsini+0x1bf>
mov    0x38(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    -0x4c(%rbp),%edx
imul   -0x50(%rbp),%edx
add    -0x54(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1314 <resultsini+0x1c4>
jmp    13cc <resultsini+0x27c>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     13c7 <resultsini+0x277>
mov    0x88(%rbp),%rax
mov    (%rax),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
jne    13c7 <resultsini+0x277>
movsd  -0x70(%rbp),%xmm0
movaps 0x1c9c(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    13c2 <resultsini+0x272>
movsd  -0x70(%rbp),%xmm0
movaps 0x1c7b(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  0x1c5e(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,0x18(%rax)
jmp    13c7 <resultsini+0x277>
jmp    13cc <resultsini+0x27c>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12bb <resultsini+0x16b>
jmp    13df <resultsini+0x28f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12a5 <resultsini+0x155>
jmp    13f2 <resultsini+0x2a2>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1523 <resultsini+0x3d3>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    151e <resultsini+0x3ce>
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1457 <resultsini+0x307>
mov    0x38(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    -0x4c(%rbp),%edx
imul   -0x50(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    145c <resultsini+0x30c>
jmp    1510 <resultsini+0x3c0>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     150b <resultsini+0x3bb>
mov    0x88(%rbp),%rax
mov    (%rax),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
jne    150b <resultsini+0x3bb>
movsd  -0x70(%rbp),%xmm0
movaps 0x1b57(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    1506 <resultsini+0x3b6>
movsd  -0x70(%rbp),%xmm0
movaps 0x1b35(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  0x1b1a(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,0x20(%rax)
jmp    150b <resultsini+0x3bb>
jmp    1510 <resultsini+0x3c0>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1406 <resultsini+0x2b6>
jmp    1523 <resultsini+0x3d3>
jmp    174c <resultsini+0x5fc>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
je     159c <resultsini+0x44c>
mov    0x18(%rbp),%rsi
mov    0x38(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    0xa0(%rbp),%r8
mov    0xa8(%rbp),%r9
mov    0xb0(%rbp),%r15
mov    0xb8(%rbp),%r14
mov    0xc0(%rbp),%rbx
mov    0x90(%rbp),%r11
mov    -0x20(%rbp),%r10
mov    0x128(%rbp),%rax
lea    -0x4c(%rbp),%rdi
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1050 <iniparll@plt>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1747 <resultsini+0x5f7>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1742 <resultsini+0x5f2>
mov    0xa0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    161a <resultsini+0x4ca>
mov    0x38(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    -0x4c(%rbp),%edx
imul   -0x50(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    161f <resultsini+0x4cf>
jmp    1734 <resultsini+0x5e4>
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movaps 0x19b8(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    16a5 <resultsini+0x555>
movsd  -0x70(%rbp),%xmm0
movaps 0x1996(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  0x197b(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,0x20(%rax)
mov    0x90(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xd0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x191f(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    172f <resultsini+0x5df>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xd0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x18e1(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x90(%rbp),%rax
movsd  %xmm0,0x10(%rax)
jmp    1734 <resultsini+0x5e4>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15b0 <resultsini+0x460>
jmp    1747 <resultsini+0x5f7>
jmp    174c <resultsini+0x5fc>
jmp    1751 <resultsini+0x601>
mov    0xf0(%rbp),%rax
movl   $0x0,(%rax)
mov    0xf8(%rbp),%rax
movl   $0x0,(%rax)
mov    0x100(%rbp),%rax
movl   $0x0,(%rax)
mov    0x108(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x40(%rbp),%rax
cmpl   $0x2,(%rax)
jge    17ac <resultsini+0x65c>
mov    -0x40(%rbp),%rax
cmpl   $0x0,(%rax)
jg     1824 <resultsini+0x6d4>
mov    0x20(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1824 <resultsini+0x6d4>
mov    0x20(%rbp),%rax
cmpl   $0x1,(%rax)
jge    17f2 <resultsini+0x6a2>
mov    0x20(%rbp),%rax
cmpl   $0xfffffffe,(%rax)
jle    17f2 <resultsini+0x6a2>
mov    0xf0(%rbp),%rax
movl   $0x1,(%rax)
mov    0xf8(%rbp),%rax
movl   $0x1,(%rax)
mov    0x100(%rbp),%rax
movl   $0x1,(%rax)
jmp    181f <resultsini+0x6cf>
mov    0x20(%rbp),%rax
cmpl   $0xfffffffe,(%rax)
je     181a <resultsini+0x6ca>
mov    -0x40(%rbp),%rax
cmpl   $0x1,0x4(%rax)
jne    181a <resultsini+0x6ca>
mov    0x108(%rbp),%rax
movl   $0x1,(%rax)
jmp    181f <resultsini+0x6cf>
jmp    1824 <resultsini+0x6d4>
mov    0x20(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1924 <resultsini+0x7d4>
mov    -0x38(%rbp),%rdi
add    $0x15c,%rdi
lea    0x17dd(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     1873 <resultsini+0x723>
mov    -0x38(%rbp),%rdi
add    $0x30f,%rdi
lea    0x17c1(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    1880 <resultsini+0x730>
mov    0xf0(%rbp),%rax
movl   $0x1,(%rax)
mov    0xf0(%rbp),%rax
cmpl   $0x1,(%rax)
je     191f <resultsini+0x7cf>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0xd8(%rbp),%rcx
cmp    (%rcx),%eax
jge    191a <resultsini+0x7ca>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0x1760(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     18f5 <resultsini+0x7a5>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0x173f(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    1907 <resultsini+0x7b7>
mov    0xf0(%rbp),%rax
movl   $0x1,(%rax)
jmp    191a <resultsini+0x7ca>
jmp    190c <resultsini+0x7bc>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1897 <resultsini+0x747>
jmp    191f <resultsini+0x7cf>
jmp    1924 <resultsini+0x7d4>
mov    0xf0(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1952 <resultsini+0x802>
mov    0x10(%rbp),%rdi
mov    -0x4c(%rbp),%edx
mov    -0x20(%rbp),%rax
imul   (%rax),%edx
mov    0x128(%rbp),%rax
mov    (%rax),%ecx
xor    %esi,%esi
call   1060 <setpardou@plt>
mov    0xf8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    197f <resultsini+0x82f>
mov    -0x48(%rbp),%rdi
mov    0x98(%rbp),%rax
mov    (%rax),%edx
mov    0x128(%rbp),%rax
mov    (%rax),%ecx
xor    %esi,%esi
call   1060 <setpardou@plt>
mov    0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <abs@plt>
cmp    $0x2,%eax
jge    202b <resultsini+0xedb>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x58(%rbp),%rcx
cmp    (%rcx),%eax
jge    1b6b <resultsini+0xa1b>
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0xc8(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     19dc <resultsini+0x88c>
mov    0x120(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jne    19e1 <resultsini+0x891>
jmp    1b5d <resultsini+0xa0d>
mov    0x50(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x88(%rbp),%rax
cmpl   $0x4,(%rax)
jne    1b2a <resultsini+0x9da>
mov    -0x40(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1b2a <resultsini+0x9da>
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jle    1b25 <resultsini+0x9d5>
mov    0x50(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0xb0(%rbp),%rax
movsd  (%rax),%xmm1
mov    0xc0(%rbp),%rax
mulsd  (%rax),%xmm1
mov    0xc0(%rbp),%rax
mulsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x157c(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1568(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
cmp    $0x75d8ba9,%eax
je     1b20 <resultsini+0x9d0>
mov    0xb8(%rbp),%rax
movsd  (%rax),%xmm0
mov    0xc0(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    0xa0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0xa8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b25 <resultsini+0x9d5>
jmp    1b2a <resultsini+0x9da>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    0x40(%rbp),%rdx
movslq -0x50(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    0x48(%rbp),%rdx
movslq -0x50(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    199a <resultsini+0x84a>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x80(%rbp),%rcx
cmp    (%rcx),%eax
jge    2026 <resultsini+0xed6>
mov    0x78(%rbp),%rdi
imul   $0x14,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0x1492(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    1bac <resultsini+0xa5c>
jmp    2018 <resultsini+0xec8>
mov    0x78(%rbp),%rdi
imul   $0x14,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0x1470(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     1c15 <resultsini+0xac5>
mov    0x78(%rbp),%rdi
imul   $0x14,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0x1465(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     1c15 <resultsini+0xac5>
mov    0x78(%rbp),%rdi
imul   $0x14,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0x143f(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    1c21 <resultsini+0xad1>
movl   $0x0,-0x68(%rbp)
jmp    1c7d <resultsini+0xb2d>
mov    0x88(%rbp),%rax
cmpl   $0x2,(%rax)
je     1c65 <resultsini+0xb15>
mov    0x88(%rbp),%rax
cmpl   $0x3,(%rax)
je     1c65 <resultsini+0xb15>
mov    -0x40(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1c71 <resultsini+0xb21>
mov    0x88(%rbp),%rax
mov    (%rax),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
jne    1c71 <resultsini+0xb21>
movl   $0x0,-0x68(%rbp)
jmp    1c78 <resultsini+0xb28>
movl   $0x1,-0x68(%rbp)
jmp    1c7d <resultsini+0xb2d>
mov    0x60(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    0x68(%rbp),%rax
imul   $0x3,-0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    0x68(%rbp),%rax
imul   $0x3,-0x60(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jne    1cd7 <resultsini+0xb87>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jge    1cd2 <resultsini+0xb82>
jmp    2018 <resultsini+0xec8>
jmp    1d0b <resultsini+0xbbb>
mov    -0x5c(%rbp),%eax
mov    0xc8(%rbp),%rcx
cmp    0x4(%rcx),%eax
jle    1cef <resultsini+0xb9f>
jmp    2018 <resultsini+0xec8>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    1d01 <resultsini+0xbb1>
jmp    2018 <resultsini+0xec8>
jmp    1d06 <resultsini+0xbb6>
jmp    1d0b <resultsini+0xbbb>
mov    0x68(%rbp),%rax
imul   $0x3,-0x60(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0xffffffff,-0x64(%rbp)
je     1e9e <resultsini+0xd4e>
jmp    1d3c <resultsini+0xbec>
cmpl   $0x0,-0x68(%rbp)
jne    1dbb <resultsini+0xc6b>
mov    0x70(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    0x68(%rbp),%rdx
imul   $0x3,-0x64(%rbp),%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    0x68(%rbp),%rdx
imul   $0x3,-0x64(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1e5f <resultsini+0xd0f>
mov    0x70(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    0x68(%rbp),%rdx
imul   $0x3,-0x64(%rbp),%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    0x68(%rbp),%rdx
imul   $0x3,-0x64(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    0x68(%rbp),%rdx
imul   $0x3,-0x64(%rbp),%esi
movslq %esi,%rsi
mov    (%rdx,%rsi,4),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    0x68(%rbp),%rdx
imul   $0x3,-0x64(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x68(%rbp),%rax
imul   $0x3,-0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0xffffffff,-0x64(%rbp)
jne    1e85 <resultsini+0xd35>
jmp    1e99 <resultsini+0xd49>
jmp    1e8a <resultsini+0xd3a>
mov    $0x1,%al
test   $0x1,%al
jne    1d3c <resultsini+0xbec>
jmp    1e99 <resultsini+0xd49>
jmp    1e9e <resultsini+0xd4e>
mov    0x70(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cmpl   $0x1,-0x68(%rbp)
jne    1eef <resultsini+0xd9f>
mov    0x30(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x88(%rbp),%rax
cmpl   $0x4,(%rax)
jne    1ffa <resultsini+0xeaa>
mov    -0x40(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1ffa <resultsini+0xeaa>
cmpl   $0x0,-0x5c(%rbp)
jle    1ff5 <resultsini+0xea5>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0xb0(%rbp),%rax
movsd  (%rax),%xmm1
mov    0xc0(%rbp),%rax
mulsd  (%rax),%xmm1
mov    0xc0(%rbp),%rax
mulsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0xc0(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x10a7(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1093(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1070 <floor@plt>
cmp    $0x75d8ba9,%eax
je     1fd2 <resultsini+0xe82>
mov    0xb8(%rbp),%rax
movsd  (%rax),%xmm0
mov    0xc0(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
mov    0xa0(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0xa8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ffa <resultsini+0xeaa>
movsd  -0x88(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1b72 <resultsini+0xa22>
jmp    202b <resultsini+0xedb>
mov    0x110(%rbp),%rax
movl   $0x0,(%rax)
mov    0x88(%rbp),%rax
cmpl   $0x4,(%rax)
jne    206f <resultsini+0xf1f>
mov    -0x40(%rbp),%rax
cmpl   $0x1,(%rax)
jle    206f <resultsini+0xf1f>
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jg     206f <resultsini+0xf1f>
mov    0x110(%rbp),%rax
movl   $0x1,(%rax)
mov    0x110(%rbp),%rax
cmpl   $0x1,(%rax)
je     20e3 <resultsini+0xf93>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0xd8(%rbp),%rcx
cmp    (%rcx),%eax
jge    20de <resultsini+0xf8e>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xfa0(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    20cb <resultsini+0xf7b>
mov    0x110(%rbp),%rax
movl   $0x1,(%rax)
jmp    20d0 <resultsini+0xf80>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2086 <resultsini+0xf36>
jmp    20e3 <resultsini+0xf93>
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    0xe8(%rbp),%rax
movl   $0x1,(%rax)
mov    0x118(%rbp),%rax
movl   $0x1,(%rax)
mov    0x88(%rbp),%rax
cmpl   $0x4,(%rax)
jl     25e0 <resultsini+0x1490>
mov    0x88(%rbp),%rax
cmpl   $0x5,(%rax)
jg     25e0 <resultsini+0x1490>
mov    -0x40(%rbp),%rax
cmpl   $0x2,(%rax)
jge    25e0 <resultsini+0x1490>
mov    0xe8(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x38(%rbp),%rdi
add    $0xae,%rdi
lea    0xf0f(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x105,%rdi
lea    0xed1(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x15c,%rdi
lea    0xeb2(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x1b3,%rdi
lea    0xe94(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x20a,%rdi
lea    0xe78(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x261,%rdi
lea    0xe5c(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x414,%rdi
lea    0xe3f(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x414,%rdi
lea    0xe22(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x5c7,%rdi
lea    0xe05(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x675,%rdi
lea    0xde8(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x87f,%rdi
lea    0xdcc(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     22da <resultsini+0x118a>
mov    -0x38(%rbp),%rdi
add    $0x8d6,%rdi
lea    0xdb0(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    22e7 <resultsini+0x1197>
mov    0xe8(%rbp),%rax
movl   $0x1,(%rax)
mov    0xe8(%rbp),%rax
cmpl   $0x1,(%rax)
je     24b6 <resultsini+0x1366>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0xd8(%rbp),%rcx
cmp    (%rcx),%eax
jge    24b1 <resultsini+0x1361>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xd48(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xd05(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xce4(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xcc3(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xc90(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xc9b(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xc7a(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xc4a(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xc0a(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     248c <resultsini+0x133c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xbd7(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    249e <resultsini+0x134e>
mov    0xe8(%rbp),%rax
movl   $0x1,(%rax)
jmp    24b1 <resultsini+0x1361>
jmp    24a3 <resultsini+0x1353>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    22fe <resultsini+0x11ae>
jmp    24b6 <resultsini+0x1366>
mov    0x118(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x38(%rbp),%rdi
add    $0x2b8,%rdi
lea    0xbb5(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     2505 <resultsini+0x13b5>
mov    -0x38(%rbp),%rdi
add    $0x30f,%rdi
lea    0xb98(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    2512 <resultsini+0x13c2>
mov    0x118(%rbp),%rax
movl   $0x1,(%rax)
mov    0x118(%rbp),%rax
cmpl   $0x1,(%rax)
je     25b1 <resultsini+0x1461>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0xd8(%rbp),%rcx
cmp    (%rcx),%eax
jge    25ac <resultsini+0x145c>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xb38(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
je     2587 <resultsini+0x1437>
mov    0xe0(%rbp),%rdi
imul   $0x6,-0x50(%rbp),%eax
cltq
add    %rax,%rdi
lea    0xb16(%rip),%rsi
call   1040 <strcmp1@plt>
cmp    $0x0,%rax
jne    2599 <resultsini+0x1449>
mov    0x118(%rbp),%rax
movl   $0x1,(%rax)
jmp    25ac <resultsini+0x145c>
jmp    259e <resultsini+0x144e>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2529 <resultsini+0x13d9>
jmp    25b1 <resultsini+0x1461>
mov    0xf0(%rbp),%rax
cmpl   $0x1,(%rax)
jne    25db <resultsini+0x148b>
mov    0xe8(%rbp),%rax
movl   $0x1,(%rax)
mov    0x118(%rbp),%rax
movl   $0x1,(%rax)
jmp    25e0 <resultsini+0x1490>
add    $0xa8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<resultsini>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,%r14
mov    %rdx,0x30(%rsp)
mov    0x188(%rsp),%r11
mov    0x178(%rsp),%r13
mov    0x170(%rsp),%r15
mov    0x148(%rsp),%rax
mov    0x4(%rax),%r10d
lea    0x1(%r10),%edx
mov    %edx,0xc(%rsp)
mov    0xa0(%rsp),%r9
mov    (%r9),%eax
cmp    $0x2,%eax
mov    %rcx,0x48(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x20(%rsp)
je     1501 <resultsini+0x3c1>
test   %eax,%eax
js     1501 <resultsini+0x3c1>
mov    %rsi,%rcx
mov    %rdi,%rbx
mov    0x110(%rsp),%r12
mov    0xb8(%rsp),%rbp
mov    0x108(%rsp),%rax
mov    (%rax),%esi
cmp    $0x4,%esi
jne    11ea <resultsini+0xaa>
mov    0x10(%rsp),%rax
cmpl   $0x1,(%rax)
jg     13bb <resultsini+0x27b>
mov    0x30(%rsp),%rax
mov    (%rax),%eax
cmp    $0x2,%eax
je     1320 <resultsini+0x1e0>
mov    %eax,0x54(%rsp)
mov    %esi,0x38(%rsp)
mov    %edx,0x40(%rsp)
mov    (%rbx),%r11d
test   %r11d,%r11d
jle    12de <resultsini+0x19e>
mov    0x38(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
mov    0x40(%rsp),%eax
movslq %eax,%rsi
mov    %eax,%ebx
lea    0x0(,%rsi,4),%r13
shl    $0x3,%rsi
xor    %edi,%edi
movapd 0xdc4(%rip),%xmm0
movsd  0xdcc(%rip),%xmm1
mov    0x18(%rsp),%rax
mov    0x98(%rsp),%r15
mov    0x10(%rsp),%rcx
jmp    126f <resultsini+0x12f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    %r13,%r15
add    %rsi,%rax
cmp    %r11,%rdi
je     12de <resultsini+0x19e>
test   %r10d,%r10d
jle    1260 <resultsini+0x120>
mov    $0x1,%r8d
jmp    1289 <resultsini+0x149>
nopl   0x0(%rax)
add    $0x1,%r8
cmp    %r8,%rbx
je     1260 <resultsini+0x120>
mov    (%r15,%r8,4),%r9d
test   %r9d,%r9d
jle    1280 <resultsini+0x140>
lea    -0x1(%r9),%r14d
movsd  0x0(%rbp,%r14,8),%xmm2
movsd  (%rax,%r8,8),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%r8,8)
cmpl   $0x0,(%rcx)
je     1280 <resultsini+0x140>
cmp    $0x1,%edx
jne    1280 <resultsini+0x140>
andpd  %xmm0,%xmm2
ucomisd (%r12),%xmm2
jbe    1280 <resultsini+0x140>
movsd  %xmm2,(%r12)
xorps  %xmm2,%xmm2
cvtsi2sd %r9d,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x18(%r12)
jmp    1280 <resultsini+0x140>
cmpl   $0x2,0x54(%rsp)
mov    0x170(%rsp),%r15
mov    0x48(%rsp),%r14
mov    0x18(%rsp),%rcx
mov    0xa0(%rsp),%r9
mov    0x178(%rsp),%r13
mov    0x20(%rsp),%rbx
mov    0x188(%rsp),%r11
mov    0x40(%rsp),%edx
mov    0x38(%rsp),%esi
jl     1501 <resultsini+0x3c1>
mov    (%rbx),%eax
test   %eax,%eax
jle    1501 <resultsini+0x3c1>
mov    %esi,%r8d
neg    %r8d
cmovs  %esi,%r8d
movslq %edx,%rdx
shl    $0x2,%rdx
xor    %esi,%esi
movapd 0xcbb(%rip),%xmm0
movsd  0xcc3(%rip),%xmm1
jmp    135d <resultsini+0x21d>
nop
add    %rdx,%rsi
add    $0xffffffffffffffff,%rax
je     1501 <resultsini+0x3c1>
mov    0x98(%rsp),%rdi
mov    (%rdi,%rsi,1),%edi
test   %edi,%edi
jle    1350 <resultsini+0x210>
lea    -0x1(%rdi),%ebx
movsd  0x0(%rbp,%rbx,8),%xmm2
movsd  (%rcx,%rsi,2),%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rcx,%rsi,2)
mov    0x10(%rsp),%rbx
cmpl   $0x0,(%rbx)
je     1350 <resultsini+0x210>
cmp    $0x1,%r8d
jne    1350 <resultsini+0x210>
andpd  %xmm0,%xmm2
ucomisd 0x8(%r12),%xmm2
jbe    1350 <resultsini+0x210>
movsd  %xmm2,0x8(%r12)
xorps  %xmm2,%xmm2
cvtsi2sd %edi,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%r12)
jmp    1350 <resultsini+0x210>
mov    0x30(%rsp),%rax
cmpl   $0x2,(%rax)
je     1433 <resultsini+0x2f3>
lea    0xc(%rsp),%rdi
mov    0x98(%rsp),%rsi
mov    %rbp,%rdx
mov    0x120(%rsp),%r8
mov    0x128(%rsp),%r9
push   0x1a8(%rsp)
push   %rbx
push   %r12
push   0x158(%rsp)
push   0x158(%rsp)
push   0x158(%rsp)
mov    %r11,%rbx
call   1040 <iniparll@plt>
mov    %rbx,%r11
mov    0x50(%rsp),%rbx
mov    0xd0(%rsp),%r9
mov    0x48(%rsp),%rcx
add    $0x30,%rsp
mov    0x30(%rsp),%rax
cmpl   $0x2,(%rax)
jl     1501 <resultsini+0x3c1>
mov    (%rbx),%eax
test   %eax,%eax
jle    1501 <resultsini+0x3c1>
mov    0x150(%rsp),%r8
movslq 0xc(%rsp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
movapd 0xba8(%rip),%xmm0
movsd  0xbb0(%rip),%xmm1
jmp    147d <resultsini+0x33d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %rdx,%rsi
add    $0xffffffffffffffff,%rax
je     1501 <resultsini+0x3c1>
mov    0x120(%rsp),%rdi
movq   $0x0,(%rdi,%rsi,2)
mov    0x98(%rsp),%rdi
mov    (%rdi,%rsi,1),%edi
test   %edi,%edi
jle    1470 <resultsini+0x330>
lea    -0x1(%rdi),%ebx
movsd  0x0(%rbp,%rbx,8),%xmm3
movsd  (%rcx,%rsi,2),%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,(%rcx,%rsi,2)
andpd  %xmm0,%xmm3
ucomisd 0x8(%r12),%xmm3
jbe    14de <resultsini+0x39e>
xorps  %xmm2,%xmm2
cvtsi2sd %edi,%xmm2
movsd  %xmm3,0x8(%r12)
addsd  %xmm1,%xmm2
movsd  %xmm2,0x20(%r12)
movsd  (%rcx,%rsi,2),%xmm2
subsd  (%r8,%rsi,2),%xmm2
andpd  %xmm0,%xmm2
ucomisd 0x10(%r12),%xmm2
jbe    1470 <resultsini+0x330>
movsd  %xmm2,0x10(%r12)
jmp    1470 <resultsini+0x330>
movl   $0x0,(%r15)
movl   $0x0,0x0(%r13)
mov    0x180(%rsp),%rdx
movl   $0x0,(%rdx)
movl   $0x0,(%r11)
mov    0x10(%rsp),%rax
cmpl   $0x1,(%rax)
jle    154e <resultsini+0x40e>
mov    (%r9),%eax
lea    0x1(%rax),%ecx
cmp    $0x1,%ecx
ja     1559 <resultsini+0x419>
movl   $0x1,(%r15)
movl   $0x1,0x0(%r13)
mov    %rdx,%r11
jmp    1569 <resultsini+0x429>
je     1570 <resultsini+0x430>
mov    (%r9),%eax
test   %eax,%eax
jns    1573 <resultsini+0x433>
jmp    1532 <resultsini+0x3f2>
cmp    $0xfffffffe,%eax
je     1570 <resultsini+0x430>
mov    0x10(%rsp),%rax
cmpl   $0x1,0x4(%rax)
jne    1570 <resultsini+0x430>
movl   $0x1,(%r11)
mov    (%r9),%eax
mov    0x160(%rsp),%rbp
test   %eax,%eax
jle    1638 <resultsini+0x4f8>
lea    0x15c(%r14),%rdi
lea    0xa97(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1648 <resultsini+0x508>
lea    0x30f(%r14),%rdi
lea    0xa80(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1648 <resultsini+0x508>
cmpl   $0x1,(%r15)
mov    0x1a8(%rsp),%rbx
je     1657 <resultsini+0x517>
mov    0x158(%rsp),%rax
cmpl   $0x0,(%rax)
jle    1674 <resultsini+0x534>
xor    %ebx,%ebx
lea    0xa41(%rip),%r13
lea    0xa3f(%rip),%r12
mov    %rbp,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r13,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1648 <resultsini+0x508>
mov    %r14,%rdi
mov    %r12,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1648 <resultsini+0x508>
add    $0x1,%rbx
mov    0x158(%rsp),%rax
movslq (%rax),%rax
add    $0x6,%r14
cmp    %rax,%rbx
jl     1600 <resultsini+0x4c0>
cmpl   $0x1,(%r15)
mov    0x1a8(%rsp),%rbx
je     1657 <resultsini+0x517>
jmp    1674 <resultsini+0x534>
movl   $0x1,(%r15)
mov    0x1a8(%rsp),%rbx
mov    0x90(%rsp),%rdi
mov    0x20(%rsp),%rax
mov    (%rax),%edx
imul   0xc(%rsp),%edx
mov    (%rbx),%ecx
xor    %esi,%esi
call   1050 <setpardou@plt>
mov    0x178(%rsp),%rax
cmpl   $0x1,(%rax)
jne    1699 <resultsini+0x559>
mov    0x118(%rsp),%rax
mov    (%rax),%edx
mov    (%rbx),%ecx
mov    0x28(%rsp),%rdi
xor    %esi,%esi
call   1050 <setpardou@plt>
mov    0xa0(%rsp),%rax
mov    (%rax),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    $0x1,%ecx
ja     1b75 <resultsini+0xa35>
mov    0xd8(%rsp),%r13
mov    0x0(%r13),%eax
test   %eax,%eax
mov    0x18(%rsp),%r8
mov    0x148(%rsp),%rsi
jle    1861 <resultsini+0x721>
mov    0x1a0(%rsp),%rdx
mov    0xd0(%rsp),%r15
mov    0xc8(%rsp),%rbx
mov    0xc0(%rsp),%rdi
xor    %ebp,%ebp
jmp    1732 <resultsini+0x5f2>
nopl   0x0(%rax,%rax,1)
movslq 0xc(%rsp),%rax
movslq (%rdi,%rbp,4),%rcx
add    $0xffffffffffffffff,%rcx
imul   %rax,%rcx
movslq (%rbx,%rbp,4),%rax
add    %rcx,%rax
movsd  %xmm1,(%r8,%rax,8)
mov    0x0(%r13),%eax
add    $0x1,%rbp
movslq %eax,%rcx
cmp    %rcx,%rbp
jge    1861 <resultsini+0x721>
mov    (%rbx,%rbp,4),%r14d
cmp    0x4(%rsi),%r14d
jg     1722 <resultsini+0x5e2>
cmpb   $0x46,(%rdx,%rbp,1)
je     1722 <resultsini+0x5e2>
movsd  (%r15,%rbp,8),%xmm1
mov    0x108(%rsp),%rax
cmpl   $0x4,(%rax)
jne    1700 <resultsini+0x5c0>
mov    0x10(%rsp),%rax
cmpl   $0x2,(%rax)
jl     1700 <resultsini+0x5c0>
test   %r14d,%r14d
jle    1700 <resultsini+0x5c0>
mov    (%rdi,%rbp,4),%r12d
add    $0xffffffff,%r12d
mov    0xc(%rsp),%eax
imul   %r12d,%eax
add    %r14d,%eax
cltq
movapd %xmm1,%xmm0
subsd  (%r8,%rax,8),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x140(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x130(%rsp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x38(%rsp)
movsd  %xmm0,0x40(%rsp)
mulsd  0x85f(%rip),%xmm0
addsd  0x85f(%rip),%xmm0
movsd  %xmm1,0x20(%rsp)
call   1060 <floor@plt>
movsd  0x20(%rsp),%xmm1
mov    0xc0(%rsp),%rdi
mov    0x1a0(%rsp),%rdx
mov    0x148(%rsp),%rsi
mov    0x18(%rsp),%r8
cmp    $0x75d8ba9,%eax
je     1700 <resultsini+0x5c0>
movsd  0x40(%rsp),%xmm3
mulsd  0x38(%rsp),%xmm3
mov    0x138(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x140(%rsp),%rax
mulsd  (%rax),%xmm0
movsd  0x28(%rsp),%xmm2
divsd  %xmm3,%xmm2
imul   0xc(%rsp),%r12d
add    %r14d,%r12d
movslq %r12d,%rax
mulsd  %xmm2,%xmm0
mov    0x120(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x128(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,(%rcx,%rax,8)
jmp    1700 <resultsini+0x5c0>
mov    0x100(%rsp),%rbx
cmpl   $0x0,(%rbx)
jle    1b75 <resultsini+0xa35>
mov    0xe8(%rsp),%r14
mov    0xe0(%rsp),%rbp
xor    %r15d,%r15d
jmp    1910 <resultsini+0x7d0>
mov    0x138(%rsp),%rax
movsd  (%rax),%xmm0
mulsd  (%rbx),%xmm0
mov    0xc(%rsp),%eax
imul   %r12d,%eax
add    %r13d,%eax
cltq
movsd  0x28(%rsp),%xmm1
mulsd  %xmm1,%xmm0
mov    0x120(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %r13d,%r10d
movapd %xmm1,%xmm0
mov    0x128(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x18(%rsp),%rcx
movsd  0x20(%rsp),%xmm1
imul   0xc(%rsp),%r12d
add    %r10d,%r12d
movslq %r12d,%rax
movsd  %xmm1,(%rcx,%rax,8)
mov    0x100(%rsp),%rbx
add    $0x1,%r15
movslq (%rbx),%rax
cmp    %rax,%r15
jge    1b75 <resultsini+0xa35>
lea    (%r15,%r15,4),%rax
mov    0xf8(%rsp),%rcx
lea    (%rcx,%rax,4),%r12
mov    %r12,%rdi
lea    0x708(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1900 <resultsini+0x7c0>
mov    %r12,%rdi
lea    0x6fa(%rip),%rsi
call   1030 <strcmp1@plt>
mov    $0x1,%r13b
test   %rax,%rax
je     1990 <resultsini+0x850>
mov    %r12,%rdi
lea    0x6fb(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1990 <resultsini+0x850>
mov    %r12,%rdi
lea    0x6e4(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1990 <resultsini+0x850>
mov    0x108(%rsp),%rax
mov    (%rax),%eax
mov    %eax,%ecx
and    $0xfffffffe,%ecx
cmp    $0x2,%ecx
jne    1b57 <resultsini+0xa17>
nopl   0x0(%rax,%rax,1)
xor    %r8d,%r8d
movslq 0x0(%rbp,%r15,4),%r9
add    $0xffffffffffffffff,%r9
lea    (%r9,%r9,2),%rax
mov    (%r14,%rax,4),%r12d
movslq %eax,%rdx
mov    0x4(%r14,%rdx,4),%r10d
test   %r10d,%r10d
je     19e0 <resultsini+0x8a0>
mov    0x148(%rsp),%rax
cmp    0x4(%rax),%r10d
jg     1900 <resultsini+0x7c0>
mov    0x30(%rsp),%rax
cmpl   $0x2,(%rax)
je     1900 <resultsini+0x7c0>
jmp    19ee <resultsini+0x8ae>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x30(%rsp),%rax
cmpl   $0x2,(%rax)
jl     1900 <resultsini+0x7c0>
mov    0x8(%r14,%rdx,4),%esi
test   %esi,%esi
je     1a65 <resultsini+0x925>
movslq 0xc(%rsp),%rdx
xorpd  %xmm1,%xmm1
mov    0x18(%rsp),%rcx
mov    0xf0(%rsp),%rbp
mov    0xb0(%rsp),%r11
jmp    1a36 <resultsini+0x8f6>
nopw   0x0(%rax,%rax,1)
movslq %esi,%rax
mulsd  -0x8(%rbp,%rax,8),%xmm0
subsd  %xmm0,%xmm1
mov    0x8(%r14,%rdi,4),%esi
test   %esi,%esi
je     1a7e <resultsini+0x93e>
lea    (%rsi,%rsi,2),%eax
add    $0xfffffffd,%eax
movslq %eax,%rdi
movslq (%r14,%rdi,4),%rbx
add    $0xffffffffffffffff,%rbx
imul   %rdx,%rbx
movslq 0x4(%r14,%rdi,4),%rax
add    %rbx,%rax
movsd  (%rcx,%rax,8),%xmm0
test   %r13b,%r13b
jne    1a20 <resultsini+0x8e0>
subsd  (%r11,%rax,8),%xmm0
jmp    1a20 <resultsini+0x8e0>
xorpd  %xmm1,%xmm1
mov    0x18(%rsp),%rcx
mov    0xf0(%rsp),%rbp
mov    0xb0(%rsp),%r11
add    $0xffffffff,%r12d
movslq %r9d,%rax
divsd  0x0(%rbp,%rax,8),%xmm1
test   %r8b,%r8b
je     1aa3 <resultsini+0x963>
mov    0xc(%rsp),%eax
imul   %r12d,%eax
add    %r10d,%eax
cltq
addsd  (%r11,%rax,8),%xmm1
mov    0x140(%rsp),%rbx
mov    0xe0(%rsp),%rbp
mov    0x108(%rsp),%rax
cmpl   $0x4,(%rax)
jne    18e7 <resultsini+0x7a7>
mov    0x10(%rsp),%rax
cmpl   $0x2,(%rax)
jl     18e7 <resultsini+0x7a7>
test   %r10d,%r10d
jle    18e7 <resultsini+0x7a7>
mov    0xc(%rsp),%eax
imul   %r12d,%eax
add    %r10d,%eax
cltq
movsd  %xmm1,0x20(%rsp)
movapd %xmm1,%xmm2
subsd  (%rcx,%rax,8),%xmm2
movsd  (%rbx),%xmm0
mov    0x130(%rsp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0x28(%rsp)
mulsd  0x4f7(%rip),%xmm0
addsd  0x4f7(%rip),%xmm0
mov    %r10d,%r13d
call   1060 <floor@plt>
cmp    $0x75d8ba9,%eax
jne    188a <resultsini+0x74a>
mov    0xc(%rsp),%eax
imul   %r12d,%eax
add    %r13d,%eax
cltq
mov    %r13d,%r10d
movsd  0x28(%rsp),%xmm0
jmp    18ca <resultsini+0x78a>
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xor    $0x1,%ecx
mov    0x10(%rsp),%rax
or     (%rax),%ecx
sete   %r13b
setne  %r8b
jmp    1993 <resultsini+0x853>
mov    0x198(%rsp),%r14
mov    0x168(%rsp),%r12
mov    0xa8(%rsp),%r15
mov    0x190(%rsp),%rax
movl   $0x0,(%rax)
mov    0x108(%rsp),%rax
cmpl   $0x4,(%rax)
jne    1bcc <resultsini+0xa8c>
mov    0x10(%rsp),%rax
cmpl   $0x2,(%rax)
jl     1bcc <resultsini+0xa8c>
mov    0x30(%rsp),%rax
cmpl   $0x1,(%rax)
jg     1bcc <resultsini+0xa8c>
mov    0x190(%rsp),%rax
movl   $0x1,(%rax)
jmp    1c28 <resultsini+0xae8>
mov    0x158(%rsp),%rax
cmpl   $0x0,(%rax)
jle    1c28 <resultsini+0xae8>
xor    %ebx,%ebx
lea    0x475(%rip),%r13
mov    0x160(%rsp),%rbp
jmp    1c08 <resultsini+0xac8>
nopl   0x0(%rax)
add    $0x1,%rbx
mov    0x158(%rsp),%rax
movslq (%rax),%rax
add    $0x6,%rbp
cmp    %rax,%rbx
jge    1c28 <resultsini+0xae8>
mov    %rbp,%rdi
mov    %r13,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
jne    1bf0 <resultsini+0xab0>
mov    0x190(%rsp),%rax
movl   $0x1,(%rax)
jmp    1bf0 <resultsini+0xab0>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%r15)
movl   $0x1,(%r12)
movl   $0x1,(%r14)
mov    0x108(%rsp),%rax
mov    (%rax),%eax
and    $0xfffffffe,%eax
cmp    $0x4,%eax
jne    1fbd <resultsini+0xe7d>
mov    0x10(%rsp),%rax
cmpl   $0x1,(%rax)
jg     1fbd <resultsini+0xe7d>
movl   $0x0,(%r12)
mov    0x48(%rsp),%rbp
lea    0xae(%rbp),%rdi
lea    0x3f8(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x105(%rbp),%rdi
lea    0x3bf(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x15c(%rbp),%rdi
lea    0x3a5(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x1b3(%rbp),%rdi
lea    0x38c(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x20a(%rbp),%rdi
lea    0x375(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x261(%rbp),%rdi
lea    0x35e(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x414(%rbp),%rbx
lea    0x346(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x332(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x5c7(%rbp),%rdi
lea    0x317(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x675(%rbp),%rdi
lea    0x2ff(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x87f(%rbp),%rdi
lea    0x2e8(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
lea    0x8d6(%rbp),%rdi
lea    0x2d1(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
cmpl   $0x1,(%r12)
je     1eee <resultsini+0xdae>
mov    0x158(%rsp),%rax
cmpl   $0x0,(%rax)
jle    1eee <resultsini+0xdae>
xor    %ebp,%ebp
lea    0x292(%rip),%rbx
lea    0x26e(%rip),%r15
mov    0x160(%rsp),%r13
mov    %r13,%rdi
mov    %rbx,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
mov    %r15,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x239(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x226(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x201(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x21a(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x20b(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x1ed(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x1bf(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
mov    %r13,%rdi
lea    0x19e(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1ee6 <resultsini+0xda6>
add    $0x1,%rbp
mov    0x158(%rsp),%rax
movslq (%rax),%rax
add    $0x6,%r13
cmp    %rax,%rbp
jl     1df4 <resultsini+0xcb4>
jmp    1eee <resultsini+0xdae>
movl   $0x1,(%r12)
movl   $0x0,(%r14)
mov    0x48(%rsp),%rbp
lea    0x2b8(%rbp),%rdi
lea    0x18a(%rip),%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
mov    0x160(%rsp),%rbx
je     1f9a <resultsini+0xe5a>
add    $0x30f,%rbp
lea    0x16a(%rip),%rsi
mov    %rbp,%rdi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1f9a <resultsini+0xe5a>
cmpl   $0x1,(%r14)
je     1fa1 <resultsini+0xe61>
mov    0x158(%rsp),%rax
cmpl   $0x0,(%rax)
jle    1fa1 <resultsini+0xe61>
xor    %ebp,%ebp
lea    0x13d(%rip),%r13
lea    0x13a(%rip),%r15
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %r13,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1f9a <resultsini+0xe5a>
mov    %rbx,%rdi
mov    %r15,%rsi
call   1030 <strcmp1@plt>
test   %rax,%rax
je     1f9a <resultsini+0xe5a>
add    $0x1,%rbp
mov    0x158(%rsp),%rax
movslq (%rax),%rax
add    $0x6,%rbx
cmp    %rax,%rbp
jl     1f60 <resultsini+0xe20>
jmp    1fa1 <resultsini+0xe61>
movl   $0x1,(%r14)
mov    0x170(%rsp),%rax
cmpl   $0x1,(%rax)
jne    1fbd <resultsini+0xe7d>
movl   $0x1,(%r12)
movl   $0x1,(%r14)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"RF \00"
@.str.1 = [5 x i8] c"RFL \00"
@.str.2 = [6 x i8] c"FLUID\00"
@.str.3 = [21 x i8] c" \00"
@.str.4 = [7 x i8] c"CYCLIC\00"
@.str.5 = [10 x i8] c"SUBCYCLIC\00"
@.str.6 = [5 x i8] c"ELKE\00"
@.str.7 = [2 x i8] c"S\00"
@.str.8 = [2 x i8] c"E\00"
@.str.9 = [3 x i8] c"RF\00"
@.str.10 = [5 x i8] c"PEEQ\00"
@.str.11 = [5 x i8] c"ENER\00"
@.str.12 = [4 x i8] c"SDV\00"
@.str.13 = [4 x i8] c"ZZS\00"
@.str.14 = [4 x i8] c"ERR\00"
@.str.15 = [4 x i8] c"PHS\00"
@.str.16 = [5 x i8] c"MAXS\00"
@.str.17 = [5 x i8] c"CONT\00"
@.str.18 = [5 x i8] c"CELS\00"
@.str.19 = [5 x i8] c"CDIS\00"
@.str.20 = [5 x i8] c"CSTR\00"
@.str.21 = [4 x i8] c"HFL\00"
@.str.22 = [4 x i8] c"RFL\00"
define void @resultsini(i32* %0, double* %1, i32* %2, i8* %3, i32* %4, double* %5, double* %6, i32* %7, i32* %8, double* %9, double* %10, double* %11, i32* %12, i32* %13, double* %14, i32* %15, i32* %16, i32* %17, double* %18, i8* %19, i32* %20, i32* %21, double* %22, i32* %23, double* %24, double* %25, double* %26, double* %27, double* %28, i32* %29, double* %30, i32* %31, i8* %32, i32* %33, i32* %34, i32* %35, i32* %36, i32* %37, i32* %38, i32* %39, i8* %40, i32* %41) {
%43 = alloca i32*
%44 = alloca double*
%45 = alloca i32*
%46 = alloca i8*
%47 = alloca i32*
%48 = alloca double*
%49 = alloca double*
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca double*
%53 = alloca double*
%54 = alloca double*
%55 = alloca i32*
%56 = alloca i32*
%57 = alloca double*
%58 = alloca i32*
%59 = alloca i32*
%60 = alloca i32*
%61 = alloca double*
%62 = alloca i8*
%63 = alloca i32*
%64 = alloca i32*
%65 = alloca double*
%66 = alloca i32*
%67 = alloca double*
%68 = alloca double*
%69 = alloca double*
%70 = alloca double*
%71 = alloca double*
%72 = alloca i32*
%73 = alloca double*
%74 = alloca i32*
%75 = alloca i8*
%76 = alloca i32*
%77 = alloca i32*
%78 = alloca i32*
%79 = alloca i32*
%80 = alloca i32*
%81 = alloca i32*
%82 = alloca i32*
%83 = alloca i8*
%84 = alloca i32*
%85 = alloca i32
%86 = alloca i32
%87 = alloca i32
%88 = alloca i32
%89 = alloca i32
%90 = alloca i32
%91 = alloca i32
%92 = alloca i32
%93 = alloca double
%94 = alloca double
%95 = alloca double
%96 = alloca double
store i32* %0, i32** %43
store double* %1, double** %44
store i32* %2, i32** %45
store i8* %3, i8** %46
store i32* %4, i32** %47
store double* %5, double** %48
store double* %6, double** %49
store i32* %7, i32** %50
store i32* %8, i32** %51
store double* %9, double** %52
store double* %10, double** %53
store double* %11, double** %54
store i32* %12, i32** %55
store i32* %13, i32** %56
store double* %14, double** %57
store i32* %15, i32** %58
store i32* %16, i32** %59
store i32* %17, i32** %60
store double* %18, double** %61
store i8* %19, i8** %62
store i32* %20, i32** %63
store i32* %21, i32** %64
store double* %22, double** %65
store i32* %23, i32** %66
store double* %24, double** %67
store double* %25, double** %68
store double* %26, double** %69
store double* %27, double** %70
store double* %28, double** %71
store i32* %29, i32** %72
store double* %30, double** %73
store i32* %31, i32** %74
store i8* %32, i8** %75
store i32* %33, i32** %76
store i32* %34, i32** %77
store i32* %35, i32** %78
store i32* %36, i32** %79
store i32* %37, i32** %80
store i32* %38, i32** %81
store i32* %39, i32** %82
store i8* %40, i8** %83
store i32* %41, i32** %84
%97 = load i32*, i32** %72
%98 = getelementptr inbounds i32, i32* %97, i64 1
%99 = load i32, i32* %98
%100 = add nsw i32 %99, 1
store i32 %100, i32* %85
%101 = load i32*, i32** %51
%102 = load i32, i32* %101
%103 = icmp ne i32 %102, 2
br i1 %103, label %104, label %436
104: ; preds = %42
%105 = load i32*, i32** %51
%106 = load i32, i32* %105
%107 = icmp sgt i32 %106, -1
br i1 %107, label %108, label %436
108: ; preds = %104
%109 = load i32*, i32** %64
%110 = load i32, i32* %109
%111 = icmp ne i32 %110, 4
br i1 %111, label %117, label %112
112: ; preds = %108
%113 = load i32*, i32** %47
%114 = getelementptr inbounds i32, i32* %113, i64 0
%115 = load i32, i32* %114
%116 = icmp sle i32 %115, 1
br i1 %116, label %117, label %299
117: ; preds = %112, %108
%118 = load i32*, i32** %45
%119 = getelementptr inbounds i32, i32* %118, i64 0
%120 = load i32, i32* %119
%121 = icmp ne i32 %120, 2
br i1 %121, label %122, label %216
122: ; preds = %117
store i32 0, i32* %86
br label %123
123: ; preds = %212, %122
%124 = load i32, i32* %86
%125 = load i32*, i32** %43
%126 = load i32, i32* %125
%127 = icmp slt i32 %124, %126
br i1 %127, label %128, label %215
128: ; preds = %123
store i32 1, i32* %87
br label %129
129: ; preds = %208, %128
%130 = load i32, i32* %87
%131 = load i32, i32* %85
%132 = icmp slt i32 %130, %131
br i1 %132, label %133, label %211
133: ; preds = %129
%134 = load i32*, i32** %50
%135 = load i32, i32* %85
%136 = load i32, i32* %86
%137 = mul nsw i32 %135, %136
%138 = load i32, i32* %87
%139 = add nsw i32 %137, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %134, i64 %140
%142 = load i32, i32* %141
%143 = icmp sgt i32 %142, 0
br i1 %143, label %144, label %159
144: ; preds = %133
%145 = load double*, double** %54
%146 = load i32*, i32** %50
%147 = load i32, i32* %85
%148 = load i32, i32* %86
%149 = mul nsw i32 %147, %148
%150 = load i32, i32* %87
%151 = add nsw i32 %149, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i32, i32* %146, i64 %152
%154 = load i32, i32* %153
%155 = sub nsw i32 %154, 1
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %145, i64 %156
%158 = load double, double* %157
store double %158, double* %93
br label %160
159: ; preds = %133
br label %208
160: ; preds = %144
%161 = load double, double* %93
%162 = load double*, double** %44
%163 = load i32, i32* %85
%164 = load i32, i32* %86
%165 = mul nsw i32 %163, %164
%166 = load i32, i32* %87
%167 = add nsw i32 %165, %166
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %162, i64 %168
%170 = load double, double* %169
%171 = fadd double %170, %161
store double %171, double* %169
%172 = load i32*, i32** %47
%173 = getelementptr inbounds i32, i32* %172, i64 0
%174 = load i32, i32* %173
%175 = icmp ne i32 %174, 0
br i1 %175, label %176, label %207
176: ; preds = %160
%177 = load i32*, i32** %64
%178 = load i32, i32* %177
%179 = call i32 @abs(i32 %178)
%180 = icmp eq i32 %179, 1
br i1 %180, label %181, label %207
181: ; preds = %176
%182 = load double, double* %93
%183 = call double @llvm.fabs.f64(double %182)
%184 = load double*, double** %65
%185 = getelementptr inbounds double, double* %184, i64 0
%186 = load double, double* %185
%187 = fcmp ogt double %183, %186
br i1 %187, label %188, label %206
188: ; preds = %181
%189 = load double, double* %93
%190 = call double @llvm.fabs.f64(double %189)
%191 = load double*, double** %65
%192 = getelementptr inbounds double, double* %191, i64 0
store double %190, double* %192
%193 = load i32*, i32** %50
%194 = load i32, i32* %85
%195 = load i32, i32* %86
%196 = mul nsw i32 %194, %195
%197 = load i32, i32* %87
%198 = add nsw i32 %196, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %193, i64 %199
%201 = load i32, i32* %200
%202 = sitofp i32 %201 to double
%203 = fsub double %202, 5.000000e-01
%204 = load double*, double** %65
%205 = getelementptr inbounds double, double* %204, i64 3
store double %203, double* %205
br label %206
206: ; preds = %188, %181
br label %207
207: ; preds = %206, %176, %160
br label %208
208: ; preds = %207, %159
%209 = load i32, i32* %87
%210 = add nsw i32 %209, 1
store i32 %210, i32* %87
br label %129
211: ; preds = %129
br label %212
212: ; preds = %211
%213 = load i32, i32* %86
%214 = add nsw i32 %213, 1
store i32 %214, i32* %86
br label %123
215: ; preds = %123
br label %216
216: ; preds = %215, %117
%217 = load i32*, i32** %45
%218 = getelementptr inbounds i32, i32* %217, i64 0
%219 = load i32, i32* %218
%220 = icmp sgt i32 %219, 1
br i1 %220, label %221, label %298
221: ; preds = %216
store i32 0, i32* %86
br label %222
222: ; preds = %294, %221
%223 = load i32, i32* %86
%224 = load i32*, i32** %43
%225 = load i32, i32* %224
%226 = icmp slt i32 %223, %225
br i1 %226, label %227, label %297
227: ; preds = %222
%228 = load i32*, i32** %50
%229 = load i32, i32* %85
%230 = load i32, i32* %86
%231 = mul nsw i32 %229, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %228, i64 %232
%234 = load i32, i32* %233
%235 = icmp sgt i32 %234, 0
br i1 %235, label %236, label %249
236: ; preds = %227
%237 = load double*, double** %54
%238 = load i32*, i32** %50
%239 = load i32, i32* %85
%240 = load i32, i32* %86
%241 = mul nsw i32 %239, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds i32, i32* %238, i64 %242
%244 = load i32, i32* %243
%245 = sub nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %237, i64 %246
%248 = load double, double* %247
store double %248, double* %93
br label %250
249: ; preds = %227
br label %294
250: ; preds = %236
%251 = load double, double* %93
%252 = load double*, double** %44
%253 = load i32, i32* %85
%254 = load i32, i32* %86
%255 = mul nsw i32 %253, %254
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %252, i64 %256
%258 = load double, double* %257
%259 = fadd double %258, %251
store double %259, double* %257
%260 = load i32*, i32** %47
%261 = getelementptr inbounds i32, i32* %260, i64 0
%262 = load i32, i32* %261
%263 = icmp ne i32 %262, 0
br i1 %263, label %264, label %293
264: ; preds = %250
%265 = load i32*, i32** %64
%266 = load i32, i32* %265
%267 = call i32 @abs(i32 %266)
%268 = icmp eq i32 %267, 1
br i1 %268, label %269, label %293
269: ; preds = %264
%270 = load double, double* %93
%271 = call double @llvm.fabs.f64(double %270)
%272 = load double*, double** %65
%273 = getelementptr inbounds double, double* %272, i64 1
%274 = load double, double* %273
%275 = fcmp ogt double %271, %274
br i1 %275, label %276, label %292
276: ; preds = %269
%277 = load double, double* %93
%278 = call double @llvm.fabs.f64(double %277)
%279 = load double*, double** %65
%280 = getelementptr inbounds double, double* %279, i64 1
store double %278, double* %280
%281 = load i32*, i32** %50
%282 = load i32, i32* %85
%283 = load i32, i32* %86
%284 = mul nsw i32 %282, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %281, i64 %285
%287 = load i32, i32* %286
%288 = sitofp i32 %287 to double
%289 = fsub double %288, 5.000000e-01
%290 = load double*, double** %65
%291 = getelementptr inbounds double, double* %290, i64 4
store double %289, double* %291
br label %292
292: ; preds = %276, %269
br label %293
293: ; preds = %292, %264, %250
br label %294
294: ; preds = %293, %249
%295 = load i32, i32* %86
%296 = add nsw i32 %295, 1
store i32 %296, i32* %86
br label %222
297: ; preds = %222
br label %298
298: ; preds = %297, %216
br label %435
299: ; preds = %112
%300 = load i32*, i32** %45
%301 = getelementptr inbounds i32, i32* %300, i64 0
%302 = load i32, i32* %301
%303 = icmp ne i32 %302, 2
br i1 %303, label %304, label %317
304: ; preds = %299
%305 = load i32*, i32** %50
%306 = load double*, double** %54
%307 = load double*, double** %44
%308 = load double*, double** %67
%309 = load double*, double** %68
%310 = load double*, double** %69
%311 = load double*, double** %70
%312 = load double*, double** %71
%313 = load double*, double** %65
%314 = load i32*, i32** %43
%315 = load i32*, i32** %84
%316 = call i32 @iniparll(i32* %85, i32* %305, double* %306, double* %307, double* %308, double* %309, double* %310, double* %311, double* %312, double* %313, i32* %314, i32* %315)
br label %317
317: ; preds = %304, %299
%318 = load i32*, i32** %45
%319 = getelementptr inbounds i32, i32* %318, i64 0
%320 = load i32, i32* %319
%321 = icmp sgt i32 %320, 1
br i1 %321, label %322, label %434
322: ; preds = %317
store i32 0, i32* %86
br label %323
323: ; preds = %430, %322
%324 = load i32, i32* %86
%325 = load i32*, i32** %43
%326 = load i32, i32* %325
%327 = icmp slt i32 %324, %326
br i1 %327, label %328, label %433
328: ; preds = %323
%329 = load double*, double** %67
%330 = load i32, i32* %85
%331 = load i32, i32* %86
%332 = mul nsw i32 %330, %331
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %329, i64 %333
store double 0.000000e+00, double* %334
%335 = load i32*, i32** %50
%336 = load i32, i32* %85
%337 = load i32, i32* %86
%338 = mul nsw i32 %336, %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %335, i64 %339
%341 = load i32, i32* %340
%342 = icmp sgt i32 %341, 0
br i1 %342, label %343, label %356
343: ; preds = %328
%344 = load double*, double** %54
%345 = load i32*, i32** %50
%346 = load i32, i32* %85
%347 = load i32, i32* %86
%348 = mul nsw i32 %346, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds i32, i32* %345, i64 %349
%351 = load i32, i32* %350
%352 = sub nsw i32 %351, 1
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double, double* %344, i64 %353
%355 = load double, double* %354
store double %355, double* %93
br label %357
356: ; preds = %328
br label %430
357: ; preds = %343
%358 = load double, double* %93
%359 = load double*, double** %44
%360 = load i32, i32* %85
%361 = load i32, i32* %86
%362 = mul nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %359, i64 %363
%365 = load double, double* %364
%366 = fadd double %365, %358
store double %366, double* %364
%367 = load double, double* %93
%368 = call double @llvm.fabs.f64(double %367)
%369 = load double*, double** %65
%370 = getelementptr inbounds double, double* %369, i64 1
%371 = load double, double* %370
%372 = fcmp ogt double %368, %371
br i1 %372, label %373, label %389
373: ; preds = %357
%374 = load double, double* %93
%375 = call double @llvm.fabs.f64(double %374)
%376 = load double*, double** %65
%377 = getelementptr inbounds double, double* %376, i64 1
store double %375, double* %377
%378 = load i32*, i32** %50
%379 = load i32, i32* %85
%380 = load i32, i32* %86
%381 = mul nsw i32 %379, %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %378, i64 %382
%384 = load i32, i32* %383
%385 = sitofp i32 %384 to double
%386 = fsub double %385, 5.000000e-01
%387 = load double*, double** %65
%388 = getelementptr inbounds double, double* %387, i64 4
store double %386, double* %388
br label %389
389: ; preds = %373, %357
%390 = load double*, double** %65
%391 = getelementptr inbounds double, double* %390, i64 2
%392 = load double, double* %391
%393 = load double*, double** %44
%394 = load i32, i32* %85
%395 = load i32, i32* %86
%396 = mul nsw i32 %394, %395
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %393, i64 %397
%399 = load double, double* %398
%400 = load double*, double** %73
%401 = load i32, i32* %85
%402 = load i32, i32* %86
%403 = mul nsw i32 %401, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %400, i64 %404
%406 = load double, double* %405
%407 = fsub double %399, %406
%408 = call double @llvm.fabs.f64(double %407)
%409 = fcmp olt double %392, %408
br i1 %409, label %410, label %429
410: ; preds = %389
%411 = load double*, double** %44
%412 = load i32, i32* %85
%413 = load i32, i32* %86
%414 = mul nsw i32 %412, %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %411, i64 %415
%417 = load double, double* %416
%418 = load double*, double** %73
%419 = load i32, i32* %85
%420 = load i32, i32* %86
%421 = mul nsw i32 %419, %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %418, i64 %422
%424 = load double, double* %423
%425 = fsub double %417, %424
%426 = call double @llvm.fabs.f64(double %425)
%427 = load double*, double** %65
%428 = getelementptr inbounds double, double* %427, i64 2
store double %426, double* %428
br label %429
429: ; preds = %410, %389
br label %430
430: ; preds = %429, %356
%431 = load i32, i32* %86
%432 = add nsw i32 %431, 1
store i32 %432, i32* %86
br label %323
433: ; preds = %323
br label %434
434: ; preds = %433, %317
br label %435
435: ; preds = %434, %298
br label %436
436: ; preds = %435, %104, %42
%437 = load i32*, i32** %77
store i32 0, i32* %437
%438 = load i32*, i32** %78
store i32 0, i32* %438
%439 = load i32*, i32** %79
store i32 0, i32* %439
%440 = load i32*, i32** %80
store i32 0, i32* %440
%441 = load i32*, i32** %47
%442 = getelementptr inbounds i32, i32* %441, i64 0
%443 = load i32, i32* %442
%444 = icmp sge i32 %443, 2
br i1 %444, label %454, label %445
445: ; preds = %436
%446 = load i32*, i32** %47
%447 = getelementptr inbounds i32, i32* %446, i64 0
%448 = load i32, i32* %447
%449 = icmp sle i32 %448, 0
br i1 %449, label %450, label %479
450: ; preds = %445
%451 = load i32*, i32** %51
%452 = load i32, i32* %451
%453 = icmp slt i32 %452, 0
br i1 %453, label %454, label %479
454: ; preds = %450, %436
%455 = load i32*, i32** %51
%456 = load i32, i32* %455
%457 = icmp slt i32 %456, 1
br i1 %457, label %458, label %466
458: ; preds = %454
%459 = load i32*, i32** %51
%460 = load i32, i32* %459
%461 = icmp sgt i32 %460, -2
br i1 %461, label %462, label %466
462: ; preds = %458
%463 = load i32*, i32** %77
store i32 1, i32* %463
%464 = load i32*, i32** %78
store i32 1, i32* %464
%465 = load i32*, i32** %79
store i32 1, i32* %465
br label %478
466: ; preds = %458, %454
%467 = load i32*, i32** %51
%468 = load i32, i32* %467
%469 = icmp ne i32 %468, -2
br i1 %469, label %470, label %477
470: ; preds = %466
%471 = load i32*, i32** %47
%472 = getelementptr inbounds i32, i32* %471, i64 1
%473 = load i32, i32* %472
%474 = icmp eq i32 %473, 1
br i1 %474, label %475, label %477
475: ; preds = %470
%476 = load i32*, i32** %80
store i32 1, i32* %476
br label %477
477: ; preds = %475, %470, %466
br label %478
478: ; preds = %477, %462
br label %479
479: ; preds = %478, %450, %445
%480 = load i32*, i32** %51
%481 = load i32, i32* %480
%482 = icmp sgt i32 %481, 0
br i1 %482, label %483, label %529
483: ; preds = %479
%484 = load i8*, i8** %46
%485 = getelementptr inbounds i8, i8* %484, i64 348
%486 = call i64 @strcmp1(i8* %485, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%487 = icmp eq i64 %486, 0
br i1 %487, label %493, label %488
488: ; preds = %483
%489 = load i8*, i8** %46
%490 = getelementptr inbounds i8, i8* %489, i64 783
%491 = call i64 @strcmp1(i8* %490, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%492 = icmp eq i64 %491, 0
br i1 %492, label %493, label %495
493: ; preds = %488, %483
%494 = load i32*, i32** %77
store i32 1, i32* %494
br label %495
495: ; preds = %493, %488
%496 = load i32*, i32** %77
%497 = load i32, i32* %496
%498 = icmp ne i32 %497, 1
br i1 %498, label %499, label %528
499: ; preds = %495
store i32 0, i32* %86
br label %500
500: ; preds = %524, %499
%501 = load i32, i32* %86
%502 = load i32*, i32** %74
%503 = load i32, i32* %502
%504 = icmp slt i32 %501, %503
br i1 %504, label %505, label %527
505: ; preds = %500
%506 = load i8*, i8** %75
%507 = load i32, i32* %86
%508 = mul nsw i32 6, %507
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds i8, i8* %506, i64 %509
%511 = call i64 @strcmp1(i8* %510, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%512 = icmp eq i64 %511, 0
br i1 %512, label %521, label %513
513: ; preds = %505
%514 = load i8*, i8** %75
%515 = load i32, i32* %86
%516 = mul nsw i32 6, %515
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds i8, i8* %514, i64 %517
%519 = call i64 @strcmp1(i8* %518, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%520 = icmp eq i64 %519, 0
br i1 %520, label %521, label %523
521: ; preds = %513, %505
%522 = load i32*, i32** %77
store i32 1, i32* %522
br label %527
523: ; preds = %513
br label %524
524: ; preds = %523
%525 = load i32, i32* %86
%526 = add nsw i32 %525, 1
store i32 %526, i32* %86
br label %500
527: ; preds = %521, %500
br label %528
528: ; preds = %527, %495
br label %529
529: ; preds = %528, %479
%530 = load i32*, i32** %77
%531 = load i32, i32* %530
%532 = icmp eq i32 %531, 1
br i1 %532, label %533, label %542
533: ; preds = %529
%534 = load double*, double** %49
%535 = load i32, i32* %85
%536 = load i32*, i32** %43
%537 = load i32, i32* %536
%538 = mul nsw i32 %535, %537
%539 = load i32*, i32** %84
%540 = load i32, i32* %539
%541 = call i32 @setpardou(double* %534, i32 0, i32 %538, i32 %540)
br label %542
542: ; preds = %533, %529
%543 = load i32*, i32** %78
%544 = load i32, i32* %543
%545 = icmp eq i32 %544, 1
br i1 %545, label %546, label %553
546: ; preds = %542
%547 = load double*, double** %48
%548 = load i32*, i32** %66
%549 = load i32, i32* %548
%550 = load i32*, i32** %84
%551 = load i32, i32* %550
%552 = call i32 @setpardou(double* %547, i32 0, i32 %549, i32 %551)
br label %553
553: ; preds = %546, %542
%554 = load i32*, i32** %51
%555 = load i32, i32* %554
%556 = call i32 @abs(i32 %555)
%557 = icmp slt i32 %556, 2
br i1 %557, label %558, label %1015
558: ; preds = %553
store i32 0, i32* %86
br label %559
559: ; preds = %690, %558
%560 = load i32, i32* %86
%561 = load i32*, i32** %58
%562 = load i32, i32* %561
%563 = icmp slt i32 %560, %562
br i1 %563, label %564, label %693
564: ; preds = %559
%565 = load i32*, i32** %56
%566 = load i32, i32* %86
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i32, i32* %565, i64 %567
%569 = load i32, i32* %568
%570 = load i32*, i32** %72
%571 = getelementptr inbounds i32, i32* %570, i64 1
%572 = load i32, i32* %571
%573 = icmp sgt i32 %569, %572
br i1 %573, label %582, label %574
574: ; preds = %564
%575 = load i8*, i8** %83
%576 = load i32, i32* %86
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds i8, i8* %575, i64 %577
%579 = load i8, i8* %578
%580 = sext i8 %579 to i32
%581 = icmp eq i32 %580, 70
br i1 %581, label %582, label %583
582: ; preds = %574, %564
br label %690
583: ; preds = %574
%584 = load double*, double** %57
%585 = load i32, i32* %86
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %584, i64 %586
%588 = load double, double* %587
store double %588, double* %96
%589 = load i32*, i32** %64
%590 = load i32, i32* %589
%591 = icmp eq i32 %590, 4
br i1 %591, label %592, label %671
592: ; preds = %583
%593 = load i32*, i32** %47
%594 = getelementptr inbounds i32, i32* %593, i64 0
%595 = load i32, i32* %594
%596 = icmp sgt i32 %595, 1
br i1 %596, label %597, label %671
597: ; preds = %592
%598 = load i32*, i32** %56
%599 = load i32, i32* %86
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds i32, i32* %598, i64 %600
%602 = load i32, i32* %601
store i32 %602, i32* %89
%603 = load i32*, i32** %55
%604 = load i32, i32* %86
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds i32, i32* %603, i64 %605
%607 = load i32, i32* %606
%608 = sub nsw i32 %607, 1
store i32 %608, i32* %88
%609 = load i32, i32* %89
%610 = icmp sgt i32 %609, 0
br i1 %610, label %611, label %670
611: ; preds = %597
%612 = load double*, double** %57
%613 = load i32, i32* %86
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %612, i64 %614
%616 = load double, double* %615
%617 = load double*, double** %44
%618 = load i32, i32* %85
%619 = load i32, i32* %88
%620 = mul nsw i32 %618, %619
%621 = load i32, i32* %89
%622 = add nsw i32 %620, %621
%623 = sext i32 %622 to i64
%624 = getelementptr inbounds double, double* %617, i64 %623
%625 = load double, double* %624
%626 = fsub double %616, %625
%627 = load double*, double** %69
%628 = load double, double* %627
%629 = load double*, double** %71
%630 = load double, double* %629
%631 = fmul double %628, %630
%632 = load double*, double** %71
%633 = load double, double* %632
%634 = fmul double %631, %633
%635 = fdiv double %626, %634
store double %635, double* %93
%636 = load double*, double** %71
%637 = load double, double* %636
%638 = call double @llvm.fmuladd.f64(double %637, double 0x45C027E72F1F1281, double 5.000000e-01)
%639 = call i32 @floor(double %638)
%640 = icmp ne i32 %639, 123571113
br i1 %640, label %641, label %669
641: ; preds = %611
%642 = load double*, double** %70
%643 = load double, double* %642
%644 = load double*, double** %71
%645 = load double, double* %644
%646 = fmul double %643, %645
%647 = load double, double* %93
%648 = load double*, double** %67
%649 = load i32, i32* %85
%650 = load i32, i32* %88
%651 = mul nsw i32 %649, %650
%652 = load i32, i32* %89
%653 = add nsw i32 %651, %652
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %648, i64 %654
%656 = load double, double* %655
%657 = call double @llvm.fmuladd.f64(double %646, double %647, double %656)
store double %657, double* %655
%658 = load double, double* %93
%659 = load double*, double** %68
%660 = load i32, i32* %85
%661 = load i32, i32* %88
%662 = mul nsw i32 %660, %661
%663 = load i32, i32* %89
%664 = add nsw i32 %662, %663
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %659, i64 %665
%667 = load double, double* %666
%668 = fadd double %667, %658
store double %668, double* %666
br label %669
669: ; preds = %641, %611
br label %670
670: ; preds = %669, %597
br label %671
671: ; preds = %670, %592, %583
%672 = load double, double* %96
%673 = load double*, double** %44
%674 = load i32, i32* %85
%675 = load i32*, i32** %55
%676 = load i32, i32* %86
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds i32, i32* %675, i64 %677
%679 = load i32, i32* %678
%680 = sub nsw i32 %679, 1
%681 = mul nsw i32 %674, %680
%682 = load i32*, i32** %56
%683 = load i32, i32* %86
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds i32, i32* %682, i64 %684
%686 = load i32, i32* %685
%687 = add nsw i32 %681, %686
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds double, double* %673, i64 %688
store double %672, double* %689
br label %690
690: ; preds = %671, %582
%691 = load i32, i32* %86
%692 = add nsw i32 %691, 1
store i32 %692, i32* %86
br label %559
693: ; preds = %559
store i32 0, i32* %86
br label %694
694: ; preds = %1011, %693
%695 = load i32, i32* %86
%696 = load i32*, i32** %63
%697 = load i32, i32* %696
%698 = icmp slt i32 %695, %697
br i1 %698, label %699, label %1014
699: ; preds = %694
%700 = load i8*, i8** %62
%701 = load i32, i32* %86
%702 = mul nsw i32 20, %701
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds i8, i8* %700, i64 %703
%705 = call i64 @strcmp1(i8* %704, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
%706 = icmp eq i64 %705, 0
br i1 %706, label %707, label %708
707: ; preds = %699
br label %1011
708: ; preds = %699
%709 = load i8*, i8** %62
%710 = load i32, i32* %86
%711 = mul nsw i32 20, %710
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds i8, i8* %709, i64 %712
%714 = call i64 @strcmp1(i8* %713, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.3, i64 0, i64 0))
%715 = icmp eq i64 %714, 0
br i1 %715, label %732, label %716
716: ; preds = %708
%717 = load i8*, i8** %62
%718 = load i32, i32* %86
%719 = mul nsw i32 20, %718
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds i8, i8* %717, i64 %720
%722 = call i64 @strcmp1(i8* %721, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0))
%723 = icmp eq i64 %722, 0
br i1 %723, label %732, label %724
724: ; preds = %716
%725 = load i8*, i8** %62
%726 = load i32, i32* %86
%727 = mul nsw i32 20, %726
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds i8, i8* %725, i64 %728
%730 = call i64 @strcmp1(i8* %729, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.5, i64 0, i64 0))
%731 = icmp eq i64 %730, 0
br i1 %731, label %732, label %733
732: ; preds = %724, %716, %708
store i32 0, i32* %92
br label %754
733: ; preds = %724
%734 = load i32*, i32** %64
%735 = load i32, i32* %734
%736 = icmp eq i32 %735, 2
br i1 %736, label %751, label %737
737: ; preds = %733
%738 = load i32*, i32** %64
%739 = load i32, i32* %738
%740 = icmp eq i32 %739, 3
br i1 %740, label %751, label %741
741: ; preds = %737
%742 = load i32*, i32** %47
%743 = getelementptr inbounds i32, i32* %742, i64 0
%744 = load i32, i32* %743
%745 = icmp eq i32 %744, 0
br i1 %745, label %746, label %752
746: ; preds = %741
%747 = load i32*, i32** %64
%748 = load i32, i32* %747
%749 = call i32 @abs(i32 %748)
%750 = icmp eq i32 %749, 1
br i1 %750, label %751, label %752
751: ; preds = %746, %737, %733
store i32 0, i32* %92
br label %753
752: ; preds = %746, %741
store i32 1, i32* %92
br label %753
753: ; preds = %752, %751
br label %754
754: ; preds = %753, %732
%755 = load i32*, i32** %59
%756 = load i32, i32* %86
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds i32, i32* %755, i64 %757
%759 = load i32, i32* %758
%760 = sub nsw i32 %759, 1
store i32 %760, i32* %90
%761 = load i32*, i32** %60
%762 = load i32, i32* %90
%763 = mul nsw i32 3, %762
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds i32, i32* %761, i64 %764
%766 = load i32, i32* %765
%767 = sub nsw i32 %766, 1
store i32 %767, i32* %88
%768 = load i32*, i32** %60
%769 = load i32, i32* %90
%770 = mul nsw i32 3, %769
%771 = add nsw i32 %770, 1
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds i32, i32* %768, i64 %772
%774 = load i32, i32* %773
store i32 %774, i32* %89
%775 = load i32, i32* %89
%776 = icmp eq i32 %775, 0
br i1 %776, label %777, label %784
777: ; preds = %754
%778 = load i32*, i32** %45
%779 = getelementptr inbounds i32, i32* %778, i64 0
%780 = load i32, i32* %779
%781 = icmp slt i32 %780, 2
br i1 %781, label %782, label %783
782: ; preds = %777
br label %1011
783: ; preds = %777
br label %799
784: ; preds = %754
%785 = load i32, i32* %89
%786 = load i32*, i32** %72
%787 = getelementptr inbounds i32, i32* %786, i64 1
%788 = load i32, i32* %787
%789 = icmp sgt i32 %785, %788
br i1 %789, label %790, label %791
790: ; preds = %784
br label %1011
791: ; preds = %784
%792 = load i32*, i32** %45
%793 = getelementptr inbounds i32, i32* %792, i64 0
%794 = load i32, i32* %793
%795 = icmp eq i32 %794, 2
br i1 %795, label %796, label %797
796: ; preds = %791
br label %1011
797: ; preds = %791
br label %798
798: ; preds = %797
br label %799
799: ; preds = %798, %783
%800 = load i32*, i32** %60
%801 = load i32, i32* %90
%802 = mul nsw i32 3, %801
%803 = add nsw i32 %802, 2
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds i32, i32* %800, i64 %804
%806 = load i32, i32* %805
%807 = sub nsw i32 %806, 1
store i32 %807, i32* %91
store double 0.000000e+00, double* %96
%808 = load i32, i32* %91
%809 = icmp ne i32 %808, -1
br i1 %809, label %810, label %911
810: ; preds = %799
br label %811
811: ; preds = %909, %810
%812 = load i32, i32* %92
%813 = icmp eq i32 %812, 0
br i1 %813, label %814, label %844
814: ; preds = %811
%815 = load double*, double** %61
%816 = load i32, i32* %91
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds double, double* %815, i64 %817
%819 = load double, double* %818
%820 = load double*, double** %44
%821 = load i32, i32* %85
%822 = load i32*, i32** %60
%823 = load i32, i32* %91
%824 = mul nsw i32 3, %823
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds i32, i32* %822, i64 %825
%827 = load i32, i32* %826
%828 = sub nsw i32 %827, 1
%829 = mul nsw i32 %821, %828
%830 = load i32*, i32** %60
%831 = load i32, i32* %91
%832 = mul nsw i32 3, %831
%833 = add nsw i32 %832, 1
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds i32, i32* %830, i64 %834
%836 = load i32, i32* %835
%837 = add nsw i32 %829, %836
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds double, double* %820, i64 %838
%840 = load double, double* %839
%841 = load double, double* %96
%842 = fneg double %819
%843 = call double @llvm.fmuladd.f64(double %842, double %840, double %841)
store double %843, double* %96
br label %896
844: ; preds = %811
%845 = load double*, double** %61
%846 = load i32, i32* %91
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds double, double* %845, i64 %847
%849 = load double, double* %848
%850 = load double*, double** %44
%851 = load i32, i32* %85
%852 = load i32*, i32** %60
%853 = load i32, i32* %91
%854 = mul nsw i32 3, %853
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds i32, i32* %852, i64 %855
%857 = load i32, i32* %856
%858 = sub nsw i32 %857, 1
%859 = mul nsw i32 %851, %858
%860 = load i32*, i32** %60
%861 = load i32, i32* %91
%862 = mul nsw i32 3, %861
%863 = add nsw i32 %862, 1
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds i32, i32* %860, i64 %864
%866 = load i32, i32* %865
%867 = add nsw i32 %859, %866
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds double, double* %850, i64 %868
%870 = load double, double* %869
%871 = load double*, double** %53
%872 = load i32, i32* %85
%873 = load i32*, i32** %60
%874 = load i32, i32* %91
%875 = mul nsw i32 3, %874
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds i32, i32* %873, i64 %876
%878 = load i32, i32* %877
%879 = sub nsw i32 %878, 1
%880 = mul nsw i32 %872, %879
%881 = load i32*, i32** %60
%882 = load i32, i32* %91
%883 = mul nsw i32 3, %882
%884 = add nsw i32 %883, 1
%885 = sext i32 %884 to i64
%886 = getelementptr inbounds i32, i32* %881, i64 %885
%887 = load i32, i32* %886
%888 = add nsw i32 %880, %887
%889 = sext i32 %888 to i64
%890 = getelementptr inbounds double, double* %871, i64 %889
%891 = load double, double* %890
%892 = fsub double %870, %891
%893 = load double, double* %96
%894 = fneg double %849
%895 = call double @llvm.fmuladd.f64(double %894, double %892, double %893)
store double %895, double* %96
br label %896
896: ; preds = %844, %814
%897 = load i32*, i32** %60
%898 = load i32, i32* %91
%899 = mul nsw i32 3, %898
%900 = add nsw i32 %899, 2
%901 = sext i32 %900 to i64
%902 = getelementptr inbounds i32, i32* %897, i64 %901
%903 = load i32, i32* %902
%904 = sub nsw i32 %903, 1
store i32 %904, i32* %91
%905 = load i32, i32* %91
%906 = icmp eq i32 %905, -1
br i1 %906, label %907, label %908
907: ; preds = %896
br label %910
908: ; preds = %896
br label %909
909: ; preds = %908
br i1 true, label %811, label %910
910: ; preds = %909, %907
br label %911
911: ; preds = %910, %799
%912 = load double*, double** %61
%913 = load i32, i32* %90
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds double, double* %912, i64 %914
%916 = load double, double* %915
%917 = load double, double* %96
%918 = fdiv double %917, %916
store double %918, double* %96
%919 = load i32, i32* %92
%920 = icmp eq i32 %919, 1
br i1 %920, label %921, label %933
921: ; preds = %911
%922 = load double*, double** %53
%923 = load i32, i32* %85
%924 = load i32, i32* %88
%925 = mul nsw i32 %923, %924
%926 = load i32, i32* %89
%927 = add nsw i32 %925, %926
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds double, double* %922, i64 %928
%930 = load double, double* %929
%931 = load double, double* %96
%932 = fadd double %931, %930
store double %932, double* %96
br label %933
933: ; preds = %921, %911
%934 = load i32*, i32** %64
%935 = load i32, i32* %934
%936 = icmp eq i32 %935, 4
br i1 %936, label %937, label %1001
937: ; preds = %933
%938 = load i32*, i32** %47
%939 = getelementptr inbounds i32, i32* %938, i64 0
%940 = load i32, i32* %939
%941 = icmp sgt i32 %940, 1
br i1 %941, label %942, label %1001
942: ; preds = %937
%943 = load i32, i32* %89
%944 = icmp sgt i32 %943, 0
br i1 %944, label %945, label %1000
945: ; preds = %942
%946 = load double, double* %96
%947 = load double*, double** %44
%948 = load i32, i32* %85
%949 = load i32, i32* %88
%950 = mul nsw i32 %948, %949
%951 = load i32, i32* %89
%952 = add nsw i32 %950, %951
%953 = sext i32 %952 to i64
%954 = getelementptr inbounds double, double* %947, i64 %953
%955 = load double, double* %954
%956 = fsub double %946, %955
%957 = load double*, double** %69
%958 = load double, double* %957
%959 = load double*, double** %71
%960 = load double, double* %959
%961 = fmul double %958, %960
%962 = load double*, double** %71
%963 = load double, double* %962
%964 = fmul double %961, %963
%965 = fdiv double %956, %964
store double %965, double* %93
%966 = load double*, double** %71
%967 = load double, double* %966
%968 = call double @llvm.fmuladd.f64(double %967, double 0x45C027E72F1F1281, double 5.000000e-01)
%969 = call i32 @floor(double %968)
%970 = icmp ne i32 %969, 123571113
br i1 %970, label %971, label %988
971: ; preds = %945
%972 = load double*, double** %70
%973 = load double, double* %972
%974 = load double*, double** %71
%975 = load double, double* %974
%976 = fmul double %973, %975
%977 = load double, double* %93
%978 = load double*, double** %67
%979 = load i32, i32* %85
%980 = load i32, i32* %88
%981 = mul nsw i32 %979, %980
%982 = load i32, i32* %89
%983 = add nsw i32 %981, %982
%984 = sext i32 %983 to i64
%985 = getelementptr inbounds double, double* %978, i64 %984
%986 = load double, double* %985
%987 = call double @llvm.fmuladd.f64(double %976, double %977, double %986)
store double %987, double* %985
br label %988
988: ; preds = %971, %945
%989 = load double, double* %93
%990 = load double*, double** %68
%991 = load i32, i32* %85
%992 = load i32, i32* %88
%993 = mul nsw i32 %991, %992
%994 = load i32, i32* %89
%995 = add nsw i32 %993, %994
%996 = sext i32 %995 to i64
%997 = getelementptr inbounds double, double* %990, i64 %996
%998 = load double, double* %997
%999 = fadd double %998, %989
store double %999, double* %997
br label %1000
1000: ; preds = %988, %942
br label %1001
1001: ; preds = %1000, %937, %933
%1002 = load double, double* %96
%1003 = load double*, double** %44
%1004 = load i32, i32* %85
%1005 = load i32, i32* %88
%1006 = mul nsw i32 %1004, %1005
%1007 = load i32, i32* %89
%1008 = add nsw i32 %1006, %1007
%1009 = sext i32 %1008 to i64
%1010 = getelementptr inbounds double, double* %1003, i64 %1009
store double %1002, double* %1010
br label %1011
1011: ; preds = %1001, %796, %790, %782, %707
%1012 = load i32, i32* %86
%1013 = add nsw i32 %1012, 1
store i32 %1013, i32* %86
br label %694
1014: ; preds = %694
br label %1015
1015: ; preds = %1014, %553
%1016 = load i32*, i32** %81
store i32 0, i32* %1016
%1017 = load i32*, i32** %64
%1018 = load i32, i32* %1017
%1019 = icmp eq i32 %1018, 4
br i1 %1019, label %1020, label %1032
1020: ; preds = %1015
%1021 = load i32*, i32** %47
%1022 = getelementptr inbounds i32, i32* %1021, i64 0
%1023 = load i32, i32* %1022
%1024 = icmp sgt i32 %1023, 1
br i1 %1024, label %1025, label %1032
1025: ; preds = %1020
%1026 = load i32*, i32** %45
%1027 = getelementptr inbounds i32, i32* %1026, i64 0
%1028 = load i32, i32* %1027
%1029 = icmp sle i32 %1028, 1
br i1 %1029, label %1030, label %1032
1030: ; preds = %1025
%1031 = load i32*, i32** %81
store i32 1, i32* %1031
br label %1032
1032: ; preds = %1030, %1025, %1020, %1015
%1033 = load i32*, i32** %81
%1034 = load i32, i32* %1033
%1035 = icmp ne i32 %1034, 1
br i1 %1035, label %1036, label %1057
1036: ; preds = %1032
store i32 0, i32* %86
br label %1037
1037: ; preds = %1053, %1036
%1038 = load i32, i32* %86
%1039 = load i32*, i32** %74
%1040 = load i32, i32* %1039
%1041 = icmp slt i32 %1038, %1040
br i1 %1041, label %1042, label %1056
1042: ; preds = %1037
%1043 = load i8*, i8** %75
%1044 = load i32, i32* %86
%1045 = mul nsw i32 6, %1044
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds i8, i8* %1043, i64 %1046
%1048 = call i64 @strcmp1(i8* %1047, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%1049 = icmp eq i64 %1048, 0
br i1 %1049, label %1050, label %1052
1050: ; preds = %1042
%1051 = load i32*, i32** %81
store i32 1, i32* %1051
br label %1052
1052: ; preds = %1050, %1042
br label %1053
1053: ; preds = %1052
%1054 = load i32, i32* %86
%1055 = add nsw i32 %1054, 1
store i32 %1055, i32* %86
br label %1037
1056: ; preds = %1037
br label %1057
1057: ; preds = %1056, %1032
%1058 = load double*, double** %52
%1059 = getelementptr inbounds double, double* %1058, i64 0
store double 0.000000e+00, double* %1059
%1060 = load double*, double** %52
%1061 = getelementptr inbounds double, double* %1060, i64 1
store double 0.000000e+00, double* %1061
%1062 = load i32*, i32** %76
store i32 1, i32* %1062
%1063 = load i32*, i32** %82
store i32 1, i32* %1063
%1064 = load i32*, i32** %64
%1065 = load i32, i32* %1064
%1066 = icmp sge i32 %1065, 4
br i1 %1066, label %1067, label %1290
1067: ; preds = %1057
%1068 = load i32*, i32** %64
%1069 = load i32, i32* %1068
%1070 = icmp sle i32 %1069, 5
br i1 %1070, label %1071, label %1290
1071: ; preds = %1067
%1072 = load i32*, i32** %47
%1073 = getelementptr inbounds i32, i32* %1072, i64 0
%1074 = load i32, i32* %1073
%1075 = icmp slt i32 %1074, 2
br i1 %1075, label %1076, label %1290
1076: ; preds = %1071
%1077 = load i32*, i32** %76
store i32 0, i32* %1077
%1078 = load i8*, i8** %46
%1079 = getelementptr inbounds i8, i8* %1078, i64 174
%1080 = call i64 @strcmp1(i8* %1079, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%1081 = icmp eq i64 %1080, 0
br i1 %1081, label %1137, label %1082
1082: ; preds = %1076
%1083 = load i8*, i8** %46
%1084 = getelementptr inbounds i8, i8* %1083, i64 261
%1085 = call i64 @strcmp1(i8* %1084, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%1086 = icmp eq i64 %1085, 0
br i1 %1086, label %1137, label %1087
1087: ; preds = %1082
%1088 = load i8*, i8** %46
%1089 = getelementptr inbounds i8, i8* %1088, i64 348
%1090 = call i64 @strcmp1(i8* %1089, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0))
%1091 = icmp eq i64 %1090, 0
br i1 %1091, label %1137, label %1092
1092: ; preds = %1087
%1093 = load i8*, i8** %46
%1094 = getelementptr inbounds i8, i8* %1093, i64 435
%1095 = call i64 @strcmp1(i8* %1094, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%1096 = icmp eq i64 %1095, 0
br i1 %1096, label %1137, label %1097
1097: ; preds = %1092
%1098 = load i8*, i8** %46
%1099 = getelementptr inbounds i8, i8* %1098, i64 522
%1100 = call i64 @strcmp1(i8* %1099, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%1101 = icmp eq i64 %1100, 0
br i1 %1101, label %1137, label %1102
1102: ; preds = %1097
%1103 = load i8*, i8** %46
%1104 = getelementptr inbounds i8, i8* %1103, i64 609
%1105 = call i64 @strcmp1(i8* %1104, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0))
%1106 = icmp eq i64 %1105, 0
br i1 %1106, label %1137, label %1107
1107: ; preds = %1102
%1108 = load i8*, i8** %46
%1109 = getelementptr inbounds i8, i8* %1108, i64 1044
%1110 = call i64 @strcmp1(i8* %1109, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0))
%1111 = icmp eq i64 %1110, 0
br i1 %1111, label %1137, label %1112
1112: ; preds = %1107
%1113 = load i8*, i8** %46
%1114 = getelementptr inbounds i8, i8* %1113, i64 1044
%1115 = call i64 @strcmp1(i8* %1114, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0))
%1116 = icmp eq i64 %1115, 0
br i1 %1116, label %1137, label %1117
1117: ; preds = %1112
%1118 = load i8*, i8** %46
%1119 = getelementptr inbounds i8, i8* %1118, i64 1479
%1120 = call i64 @strcmp1(i8* %1119, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%1121 = icmp eq i64 %1120, 0
br i1 %1121, label %1137, label %1122
1122: ; preds = %1117
%1123 = load i8*, i8** %46
%1124 = getelementptr inbounds i8, i8* %1123, i64 1653
%1125 = call i64 @strcmp1(i8* %1124, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%1126 = icmp eq i64 %1125, 0
br i1 %1126, label %1137, label %1127
1127: ; preds = %1122
%1128 = load i8*, i8** %46
%1129 = getelementptr inbounds i8, i8* %1128, i64 2175
%1130 = call i64 @strcmp1(i8* %1129, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%1131 = icmp eq i64 %1130, 0
br i1 %1131, label %1137, label %1132
1132: ; preds = %1127
%1133 = load i8*, i8** %46
%1134 = getelementptr inbounds i8, i8* %1133, i64 2262
%1135 = call i64 @strcmp1(i8* %1134, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%1136 = icmp eq i64 %1135, 0
br i1 %1136, label %1137, label %1139
1137: ; preds = %1132, %1127, %1122, %1117, %1112, %1107, %1102, %1097, %1092, %1087, %1082, %1076
%1138 = load i32*, i32** %76
store i32 1, i32* %1138
br label %1139
1139: ; preds = %1137, %1132
%1140 = load i32*, i32** %76
%1141 = load i32, i32* %1140
%1142 = icmp ne i32 %1141, 1
br i1 %1142, label %1143, label %1236
1143: ; preds = %1139
store i32 0, i32* %86
br label %1144
1144: ; preds = %1232, %1143
%1145 = load i32, i32* %86
%1146 = load i32*, i32** %74
%1147 = load i32, i32* %1146
%1148 = icmp slt i32 %1145, %1147
br i1 %1148, label %1149, label %1235
1149: ; preds = %1144
%1150 = load i8*, i8** %75
%1151 = load i32, i32* %86
%1152 = mul nsw i32 6, %1151
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds i8, i8* %1150, i64 %1153
%1155 = call i64 @strcmp1(i8* %1154, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%1156 = icmp eq i64 %1155, 0
br i1 %1156, label %1229, label %1157
1157: ; preds = %1149
%1158 = load i8*, i8** %75
%1159 = load i32, i32* %86
%1160 = mul nsw i32 6, %1159
%1161 = sext i32 %1160 to i64
%1162 = getelementptr inbounds i8, i8* %1158, i64 %1161
%1163 = call i64 @strcmp1(i8* %1162, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%1164 = icmp eq i64 %1163, 0
br i1 %1164, label %1229, label %1165
1165: ; preds = %1157
%1166 = load i8*, i8** %75
%1167 = load i32, i32* %86
%1168 = mul nsw i32 6, %1167
%1169 = sext i32 %1168 to i64
%1170 = getelementptr inbounds i8, i8* %1166, i64 %1169
%1171 = call i64 @strcmp1(i8* %1170, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%1172 = icmp eq i64 %1171, 0
br i1 %1172, label %1229, label %1173
1173: ; preds = %1165
%1174 = load i8*, i8** %75
%1175 = load i32, i32* %86
%1176 = mul nsw i32 6, %1175
%1177 = sext i32 %1176 to i64
%1178 = getelementptr inbounds i8, i8* %1174, i64 %1177
%1179 = call i64 @strcmp1(i8* %1178, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%1180 = icmp eq i64 %1179, 0
br i1 %1180, label %1229, label %1181
1181: ; preds = %1173
%1182 = load i8*, i8** %75
%1183 = load i32, i32* %86
%1184 = mul nsw i32 6, %1183
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds i8, i8* %1182, i64 %1185
%1187 = call i64 @strcmp1(i8* %1186, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
%1188 = icmp eq i64 %1187, 0
br i1 %1188, label %1229, label %1189
1189: ; preds = %1181
%1190 = load i8*, i8** %75
%1191 = load i32, i32* %86
%1192 = mul nsw i32 6, %1191
%1193 = sext i32 %1192 to i64
%1194 = getelementptr inbounds i8, i8* %1190, i64 %1193
%1195 = call i64 @strcmp1(i8* %1194, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
%1196 = icmp eq i64 %1195, 0
br i1 %1196, label %1229, label %1197
1197: ; preds = %1189
%1198 = load i8*, i8** %75
%1199 = load i32, i32* %86
%1200 = mul nsw i32 6, %1199
%1201 = sext i32 %1200 to i64
%1202 = getelementptr inbounds i8, i8* %1198, i64 %1201
%1203 = call i64 @strcmp1(i8* %1202, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.20, i64 0, i64 0))
%1204 = icmp eq i64 %1203, 0
br i1 %1204, label %1229, label %1205
1205: ; preds = %1197
%1206 = load i8*, i8** %75
%1207 = load i32, i32* %86
%1208 = mul nsw i32 6, %1207
%1209 = sext i32 %1208 to i64
%1210 = getelementptr inbounds i8, i8* %1206, i64 %1209
%1211 = call i64 @strcmp1(i8* %1210, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%1212 = icmp eq i64 %1211, 0
br i1 %1212, label %1229, label %1213
1213: ; preds = %1205
%1214 = load i8*, i8** %75
%1215 = load i32, i32* %86
%1216 = mul nsw i32 6, %1215
%1217 = sext i32 %1216 to i64
%1218 = getelementptr inbounds i8, i8* %1214, i64 %1217
%1219 = call i64 @strcmp1(i8* %1218, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0))
%1220 = icmp eq i64 %1219, 0
br i1 %1220, label %1229, label %1221
1221: ; preds = %1213
%1222 = load i8*, i8** %75
%1223 = load i32, i32* %86
%1224 = mul nsw i32 6, %1223
%1225 = sext i32 %1224 to i64
%1226 = getelementptr inbounds i8, i8* %1222, i64 %1225
%1227 = call i64 @strcmp1(i8* %1226, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0))
%1228 = icmp eq i64 %1227, 0
br i1 %1228, label %1229, label %1231
1229: ; preds = %1221, %1213, %1205, %1197, %1189, %1181, %1173, %1165, %1157, %1149
%1230 = load i32*, i32** %76
store i32 1, i32* %1230
br label %1235
1231: ; preds = %1221
br label %1232
1232: ; preds = %1231
%1233 = load i32, i32* %86
%1234 = add nsw i32 %1233, 1
store i32 %1234, i32* %86
br label %1144
1235: ; preds = %1229, %1144
br label %1236
1236: ; preds = %1235, %1139
%1237 = load i32*, i32** %82
store i32 0, i32* %1237
%1238 = load i8*, i8** %46
%1239 = getelementptr inbounds i8, i8* %1238, i64 696
%1240 = call i64 @strcmp1(i8* %1239, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0))
%1241 = icmp eq i64 %1240, 0
br i1 %1241, label %1247, label %1242
1242: ; preds = %1236
%1243 = load i8*, i8** %46
%1244 = getelementptr inbounds i8, i8* %1243, i64 783
%1245 = call i64 @strcmp1(i8* %1244, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.22, i64 0, i64 0))
%1246 = icmp eq i64 %1245, 0
br i1 %1246, label %1247, label %1249
1247: ; preds = %1242, %1236
%1248 = load i32*, i32** %82
store i32 1, i32* %1248
br label %1249
1249: ; preds = %1247, %1242
%1250 = load i32*, i32** %82
%1251 = load i32, i32* %1250
%1252 = icmp ne i32 %1251, 1
br i1 %1252, label %1253, label %1282
1253: ; preds = %1249
store i32 0, i32* %86
br label %1254
1254: ; preds = %1278, %1253
%1255 = load i32, i32* %86
%1256 = load i32*, i32** %74
%1257 = load i32, i32* %1256
%1258 = icmp slt i32 %1255, %1257
br i1 %1258, label %1259, label %1281
1259: ; preds = %1254
%1260 = load i8*, i8** %75
%1261 = load i32, i32* %86
%1262 = mul nsw i32 6, %1261
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds i8, i8* %1260, i64 %1263
%1265 = call i64 @strcmp1(i8* %1264, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0))
%1266 = icmp eq i64 %1265, 0
br i1 %1266, label %1275, label %1267
1267: ; preds = %1259
%1268 = load i8*, i8** %75
%1269 = load i32, i32* %86
%1270 = mul nsw i32 6, %1269
%1271 = sext i32 %1270 to i64
%1272 = getelementptr inbounds i8, i8* %1268, i64 %1271
%1273 = call i64 @strcmp1(i8* %1272, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.22, i64 0, i64 0))
%1274 = icmp eq i64 %1273, 0
br i1 %1274, label %1275, label %1277
1275: ; preds = %1267, %1259
%1276 = load i32*, i32** %82
store i32 1, i32* %1276
br label %1281
1277: ; preds = %1267
br label %1278
1278: ; preds = %1277
%1279 = load i32, i32* %86
%1280 = add nsw i32 %1279, 1
store i32 %1280, i32* %86
br label %1254
1281: ; preds = %1275, %1254
br label %1282
1282: ; preds = %1281, %1249
%1283 = load i32*, i32** %77
%1284 = load i32, i32* %1283
%1285 = icmp eq i32 %1284, 1
br i1 %1285, label %1286, label %1289
1286: ; preds = %1282
%1287 = load i32*, i32** %76
store i32 1, i32* %1287
%1288 = load i32*, i32** %82
store i32 1, i32* %1288
br label %1289
1289: ; preds = %1286, %1282
br label %1290
1290: ; preds = %1289, %1071, %1067, %1057
ret void
}

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