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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ preparll(int *, double *, double *, double *, double *,
                            double *, int *, double *, double *, double *,
                            int *, int *);
void prediction(double *uam, int *nmethod, double *bet, double *gam,
                double *dtime, int *ithermal, int *nk, double *veold,
                double *accold, double *v, int *iinc, int *idiscon,
                double *vold, int *nactdof, int *mi, int *num_cpus) {
  int j, k, mt = mi[1] + 1;
  double dextrapol, scal1, scal2;
  uam[0] = 0.;
  uam[1] = 0.;
  if (*nmethod == 4) {
    scal1 = 0.5 * (1. - 2. * *bet) * *dtime * *dtime;
    scal2 = (1. - *gam) * *dtime;
    if (*ithermal < 2) {
      preparll(&mt, dtime, veold, &scal1, accold, uam, nactdof, v, vold, &scal2,
               nk, num_cpus);
    } else if (*ithermal == 2) {
      for (k = 0; k < *nk; ++k) {
        for (j = 0; j < mt; j++) {
          v[mt * k + j] = vold[mt * k + j];
        }
      }
      for (k = 0; k < *nk; ++k) {
        dextrapol = *dtime * veold[mt * k];
        if (fabs(dextrapol) > 100.)
          dextrapol = 100. * dextrapol / fabs(dextrapol);
        if ((fabs(dextrapol) > uam[1]) && (nactdof[mt * k] > 0)) {
          uam[1] = fabs(dextrapol);
        }
        v[mt * k] += dextrapol;
      }
    } else {
      for (k = 0; k < *nk; ++k) {
        for (j = 0; j < mt; ++j) {
          dextrapol = *dtime * veold[mt * k + j] + scal1 * accold[mt * k + j];
          if ((j == 0) && fabs(dextrapol) > 100.)
            dextrapol = 100. * dextrapol / fabs(dextrapol);
          if (j == 0) {
            if ((fabs(dextrapol) > uam[1]) && (nactdof[mt * k] > 0)) {
              uam[1] = fabs(dextrapol);
            }
          } else {
            if ((fabs(dextrapol) > uam[0]) && (nactdof[mt * k + j] > 0)) {
              uam[0] = fabs(dextrapol);
            }
          }
          v[mt * k + j] = vold[mt * k + j] + dextrapol;
          veold[mt * k + j] = veold[mt * k + j] + scal2 * accold[mt * k + j];
          accold[mt * k + j] = 0.;
        }
      }
    }
  } else {
    if (*iinc > 1) {
      if (*ithermal < 2) {
        for (k = 0; k < *nk; ++k) {
          for (j = 1; j < mt; ++j) {
            if (*idiscon == 0) {
              dextrapol = *dtime * veold[mt * k + j];
              if ((fabs(dextrapol) > uam[0]) && (nactdof[mt * k + j] > 0)) {
                uam[0] = fabs(dextrapol);
              }
              v[mt * k + j] = vold[mt * k + j] + dextrapol;
            } else {
              v[mt * k + j] = vold[mt * k + j];
            }
          }
        }
      } else if (*ithermal == 2) {
        for (k = 0; k < *nk; ++k) {
          for (j = 0; j < mt; ++j) {
            v[mt * k + j] = vold[mt * k + j];
          }
        }
        for (k = 0; k < *nk; ++k) {
          if (*idiscon == 0) {
            dextrapol = *dtime * veold[mt * k];
            if (fabs(dextrapol) > 100.)
              dextrapol = 100. * dextrapol / fabs(dextrapol);
            if ((fabs(dextrapol) > uam[1]) && (nactdof[mt * k] > 0)) {
              uam[1] = fabs(dextrapol);
            }
            v[mt * k] += dextrapol;
          }
        }
      } else {
        for (k = 0; k < *nk; ++k) {
          for (j = 0; j < mt; ++j) {
            if (*idiscon == 0) {
              dextrapol = *dtime * veold[mt * k + j];
              if ((j == 0) && fabs(dextrapol) > 100.)
                dextrapol = 100. * dextrapol / fabs(dextrapol);
              if (j == 0) {
                if ((fabs(dextrapol) > uam[1]) && (nactdof[mt * k + j] > 0)) {
                  uam[1] = fabs(dextrapol);
                }
              } else {
                if ((fabs(dextrapol) > uam[0]) && (nactdof[mt * k + j] > 0)) {
                  uam[0] = fabs(dextrapol);
                }
              }
              v[mt * k + j] = vold[mt * k + j] + dextrapol;
            } else {
              v[mt * k + j] = vold[mt * k + j];
            }
          }
        }
      }
    } else {
      for (k = 0; k < *nk; ++k) {
        for (j = 0; j < mt; ++j) {
          v[mt * k + j] = vold[mt * k + j];
        }
      }
    }
  }
  *idiscon = 0;
  return;
}


x86 assembly (clang, -O0):
<prediction>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x88,%rsp
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    0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
cmpl   $0x4,(%rax)
jne    160b <prediction+0x4fb>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
addsd  %xmm0,%xmm0
movsd  0xe63(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xe5f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
movsd  0xe32(%rip),%xmm0
subsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%rax
cmpl   $0x2,(%rax)
jge    124b <prediction+0x13b>
mov    -0x40(%rbp),%rsi
mov    0x18(%rbp),%rdx
mov    0x20(%rbp),%r8
mov    -0x20(%rbp),%r9
mov    0x48(%rbp),%r15
mov    0x28(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x10(%rbp),%r10
mov    0x58(%rbp),%rax
lea    -0x54(%rbp),%rdi
lea    -0x68(%rbp),%rcx
lea    -0x70(%rbp),%r11
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1030 <preparll@plt>
jmp    1606 <prediction+0x4f6>
mov    -0x48(%rbp),%rax
cmpl   $0x2,(%rax)
jne    13cc <prediction+0x2bc>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    12ce <prediction+0x1be>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    12bb <prediction+0x1ab>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1275 <prediction+0x165>
jmp    12c0 <prediction+0x1b0>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    125f <prediction+0x14f>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    13c7 <prediction+0x2b7>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0xd10(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xce4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    134c <prediction+0x23c>
movsd  0xcd2(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movaps 0xce1(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0xcc8(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    139c <prediction+0x28c>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    139c <prediction+0x28c>
movsd  -0x60(%rbp),%xmm0
movaps 0xc91(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12d5 <prediction+0x1c5>
jmp    1601 <prediction+0x4f1>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    15fc <prediction+0x4ec>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    15e9 <prediction+0x4d9>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    148d <prediction+0x37d>
movsd  -0x60(%rbp),%xmm0
movaps 0xbcf(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xba3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    148d <prediction+0x37d>
movsd  0xb91(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movaps 0xba0(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    14ec <prediction+0x3dc>
movsd  -0x60(%rbp),%xmm0
movaps 0xb7d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    14e7 <prediction+0x3d7>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    14e7 <prediction+0x3d7>
movsd  -0x60(%rbp),%xmm0
movaps 0xb46(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1542 <prediction+0x432>
movsd  -0x60(%rbp),%xmm0
movaps 0xb28(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    153d <prediction+0x42d>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    153d <prediction+0x42d>
movsd  -0x60(%rbp),%xmm0
movaps 0xaef(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1542 <prediction+0x432>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13e9 <prediction+0x2d9>
jmp    15ee <prediction+0x4de>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13d3 <prediction+0x2c3>
jmp    1601 <prediction+0x4f1>
jmp    1606 <prediction+0x4f6>
jmp    1b69 <prediction+0xa59>
mov    0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1ae9 <prediction+0x9d9>
mov    -0x48(%rbp),%rax
cmpl   $0x2,(%rax)
jge    175c <prediction+0x64c>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1757 <prediction+0x647>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1744 <prediction+0x634>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1705 <prediction+0x5f5>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x996(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    16cf <prediction+0x5bf>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    16cf <prediction+0x5bf>
movsd  -0x60(%rbp),%xmm0
movaps 0x95d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1731 <prediction+0x621>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1736 <prediction+0x626>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1642 <prediction+0x532>
jmp    1749 <prediction+0x639>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    162c <prediction+0x51c>
jmp    1ae4 <prediction+0x9d4>
mov    -0x48(%rbp),%rax
cmpl   $0x2,(%rax)
jne    18ef <prediction+0x7df>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    17df <prediction+0x6cf>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    17cc <prediction+0x6bc>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1786 <prediction+0x676>
jmp    17d1 <prediction+0x6c1>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1770 <prediction+0x660>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    18ea <prediction+0x7da>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    18d7 <prediction+0x7c7>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x7f2(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x7c6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    186a <prediction+0x75a>
movsd  0x7b4(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movaps 0x7c3(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0x7aa(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    18ba <prediction+0x7aa>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    18ba <prediction+0x7aa>
movsd  -0x60(%rbp),%xmm0
movaps 0x773(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    18dc <prediction+0x7cc>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    17e6 <prediction+0x6d6>
jmp    1adf <prediction+0x9cf>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1ada <prediction+0x9ca>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1ac7 <prediction+0x9b7>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1a88 <prediction+0x978>
mov    -0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    199a <prediction+0x88a>
movsd  -0x60(%rbp),%xmm0
movaps 0x6c2(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x696(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    199a <prediction+0x88a>
movsd  0x684(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movaps 0x693(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    19fc <prediction+0x8ec>
movsd  -0x60(%rbp),%xmm0
movaps 0x670(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    19f7 <prediction+0x8e7>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    19f7 <prediction+0x8e7>
movsd  -0x60(%rbp),%xmm0
movaps 0x636(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1a52 <prediction+0x942>
movsd  -0x60(%rbp),%xmm0
movaps 0x618(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    1a4d <prediction+0x93d>
mov    0x48(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1a4d <prediction+0x93d>
movsd  -0x60(%rbp),%xmm0
movaps 0x5df(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1a52 <prediction+0x942>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ab4 <prediction+0x9a4>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ab9 <prediction+0x9a9>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    190c <prediction+0x7fc>
jmp    1acc <prediction+0x9bc>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    18f6 <prediction+0x7e6>
jmp    1adf <prediction+0x9cf>
jmp    1ae4 <prediction+0x9d4>
jmp    1b64 <prediction+0xa54>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1b5f <prediction+0xa4f>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1b4c <prediction+0xa3c>
mov    0x40(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1b06 <prediction+0x9f6>
jmp    1b51 <prediction+0xa41>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1af0 <prediction+0x9e0>
jmp    1b64 <prediction+0xa54>
jmp    1b69 <prediction+0xa59>
mov    0x38(%rbp),%rax
movl   $0x0,(%rax)
add    $0x88,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<prediction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,%rax
mov    %rdx,%r11
mov    %rdi,%r9
mov    0xf8(%rsp),%rdx
mov    %rdx,0x40(%rsp)
mov    0xf0(%rsp),%r12
mov    0xd8(%rsp),%rbp
mov    0xc8(%rsp),%rdx
mov    %rdx,0x38(%rsp)
mov    0xc0(%rsp),%rbx
mov    0x100(%rsp),%rdx
mov    0x4(%rdx),%edx
mov    %rdx,0x10(%rsp)
add    $0x1,%edx
mov    %edx,(%rsp)
mov    %edx,0x74(%rsp)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rdi)
cmpl   $0x4,(%rsi)
mov    %r8,0x8(%rsp)
jne    1225 <prediction+0x115>
mov    0xd0(%rsp),%r10
movsd  (%r11),%xmm2
addsd  %xmm2,%xmm2
movsd  0xe73(%rip),%xmm0
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
mulsd  0xe6b(%rip),%xmm1
movsd  (%r8),%xmm2
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x80(%rsp)
subsd  (%rcx),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    (%rax),%eax
cmp    $0x1,%eax
jg     133f <prediction+0x22f>
lea    0x78(%rsp),%rax
lea    0x74(%rsp),%rdi
lea    0x80(%rsp),%rcx
mov    %r8,%rsi
mov    0xc8(%rsp),%rdx
mov    %r10,%r8
push   0x108(%rsp)
push   %rbx
push   %rax
push   %r12
push   %rbp
push   0x120(%rsp)
call   1030 <preparll@plt>
add    $0x30,%rsp
jmp    1f27 <prediction+0xe17>
mov    0xe0(%rsp),%rcx
cmpl   $0x1,(%rcx)
jle    15c0 <prediction+0x4b0>
mov    (%rax),%eax
cmp    $0x1,%eax
jg     1834 <prediction+0x724>
mov    (%rbx),%r10d
test   %r10d,%r10d
jle    1f27 <prediction+0xe17>
mov    (%rsp),%eax
movslq %eax,%r14
mov    %eax,%esi
add    $0x8,%r12
lea    0x0(,%r14,8),%r15
addq   $0x8,0x38(%rsp)
addq   $0x4,0x40(%rsp)
lea    0x0(,%r14,4),%r11
add    $0xffffffffffffffff,%rsi
mov    $0x1,%ebx
xor    %r13d,%r13d
movapd 0xd77(%rip),%xmm0
jmp    12ad <prediction+0x19d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    %r14,%rbx
add    %r15,%r12
add    %r15,0x38(%rsp)
add    %r11,0x40(%rsp)
cmp    %r10,%r13
je     1f27 <prediction+0xe17>
cmpl   $0x0,0x10(%rsp)
mov    0xd8(%rsp),%r8
jle    1290 <prediction+0x180>
mov    0xe8(%rsp),%rax
mov    (%rax),%ebp
mov    %r13,%rax
imul   %r14,%rax
mov    $0x1,%edi
xor    %ecx,%ecx
jmp    12fd <prediction+0x1ed>
cs nopw 0x0(%rax,%rax,1)
lea    (%rbx,%rcx,1),%rdx
movsd  (%r12,%rcx,8),%xmm1
movsd  %xmm1,(%r8,%rdx,8)
add    $0x1,%rdi
add    $0x1,%rcx
cmp    %rcx,%rsi
je     1290 <prediction+0x180>
test   %ebp,%ebp
jne    12e0 <prediction+0x1d0>
mov    0x8(%rsp),%rdx
movsd  (%rdx),%xmm1
mov    0x38(%rsp),%rdx
mulsd  (%rdx,%rcx,8),%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
ucomisd (%r9),%xmm2
jbe    1333 <prediction+0x223>
mov    0x40(%rsp),%rdx
cmpl   $0x0,(%rdx,%rcx,4)
jle    1333 <prediction+0x223>
movsd  %xmm2,(%r9)
lea    (%rdi,%rax,1),%rdx
addsd  (%r12,%rcx,8),%xmm1
jmp    12ea <prediction+0x1da>
mov    (%rbx),%r8d
cmp    $0x2,%eax
jne    1ac4 <prediction+0x9b4>
test   %r8d,%r8d
jle    1f27 <prediction+0xe17>
mov    %r8,0x30(%rsp)
mov    (%rsp),%eax
movslq %eax,%r11
mov    %eax,%esi
mov    %esi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x28(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x68(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
mov    %esi,%edx
and    $0x3,%edx
mov    0xd8(%rsp),%r15
lea    0x70(%r15),%r14
lea    0x0(,%r11,8),%rax
lea    0x70(%r12),%rbp
lea    0x10(%r15),%r10
lea    0x10(%r12),%r8
mov    %rcx,0x60(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x58(%rsp)
xor    %r13d,%r13d
mov    %r12,%rbx
mov    %rdx,0x20(%rsp)
mov    %rax,0x48(%rsp)
mov    %r11,0x18(%rsp)
jmp    1401 <prediction+0x2f1>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
add    %rax,%r14
add    %rax,%rbp
add    %rax,%r10
add    %rax,%r8
add    %rax,%r15
add    %rax,%rbx
cmp    0x30(%rsp),%r13
je     1c97 <prediction+0xb87>
cmpl   $0x0,0x10(%rsp)
js     13e0 <prediction+0x2d0>
cmpl   $0x4,(%rsp)
jae    1420 <prediction+0x310>
xor    %ecx,%ecx
jmp    1540 <prediction+0x430>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rcx
imul   %r11,%rcx
lea    (%rcx,%rsi,1),%rdx
mov    0xd8(%rsp),%rdi
lea    (%rdi,%rcx,8),%r11
lea    (%r12,%rdx,8),%rdi
cmp    %rdi,%r11
jae    1466 <prediction+0x356>
mov    0xd8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
lea    (%r12,%rcx,8),%rcx
cmp    %rdx,%rcx
jae    1466 <prediction+0x356>
xor    %ecx,%ecx
mov    0x18(%rsp),%r11
mov    0x20(%rsp),%rdx
jmp    1540 <prediction+0x430>
cmpq   $0xc,0x68(%rsp)
jae    1472 <prediction+0x362>
xor    %ecx,%ecx
jmp    14e5 <prediction+0x3d5>
mov    0x50(%rsp),%r11
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x70(%rbp,%rcx,8),%xmm0
movups -0x60(%rbp,%rcx,8),%xmm1
movups %xmm0,-0x70(%r14,%rcx,8)
movups %xmm1,-0x60(%r14,%rcx,8)
movups -0x50(%rbp,%rcx,8),%xmm0
movups -0x40(%rbp,%rcx,8),%xmm1
movups %xmm0,-0x50(%r14,%rcx,8)
movups %xmm1,-0x40(%r14,%rcx,8)
movups -0x30(%rbp,%rcx,8),%xmm0
movups -0x20(%rbp,%rcx,8),%xmm1
movups %xmm0,-0x30(%r14,%rcx,8)
movups %xmm1,-0x20(%r14,%rcx,8)
movupd -0x10(%rbp,%rcx,8),%xmm0
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd %xmm0,-0x10(%r14,%rcx,8)
movupd %xmm1,(%r14,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%r11
jne    1480 <prediction+0x370>
cmpq   $0x0,0x60(%rsp)
mov    0x58(%rsp),%rax
je     151f <prediction+0x40f>
lea    (%r10,%rcx,8),%rdi
lea    (%r8,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rcx,%rdx,1),%xmm0
movupd (%rcx,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rdx,1)
movupd %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rax
jne    1500 <prediction+0x3f0>
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rsi,%rdx
mov    0x18(%rsp),%r11
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rax
je     13e0 <prediction+0x2d0>
nop
mov    %rcx,%rdi
not    %rdi
add    %rsi,%rdi
test   %rdx,%rdx
je     1565 <prediction+0x455>
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1550 <prediction+0x440>
cmp    $0x3,%rdi
mov    0x20(%rsp),%rdx
jb     13e0 <prediction+0x2d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,-0x10(%r10,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r10,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r10,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1580 <prediction+0x470>
jmp    13e0 <prediction+0x2d0>
mov    (%rbx),%edx
test   %edx,%edx
jle    1f27 <prediction+0xe17>
mov    (%rsp),%eax
movslq %eax,%rcx
mov    %eax,%r11d
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x30(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rsp)
mov    %r11d,%ebp
and    $0x3,%ebp
mov    0xd8(%rsp),%r15
lea    0x70(%r15),%rsi
mov    %rcx,0x40(%rsp)
lea    0x0(,%rcx,8),%r13
lea    0x70(%r12),%rdi
lea    0x10(%r15),%rax
lea    0x10(%r12),%r8
mov    %r10,0x18(%rsp)
shl    $0x5,%r10
xor    %r9d,%r9d
mov    %r12,%rbx
mov    %rbp,0x8(%rsp)
mov    %rdx,0x38(%rsp)
jmp    166f <prediction+0x55f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r13,%rsi
add    %r13,%rdi
add    %r13,%rax
add    %r13,%r8
add    %r13,%r15
add    %r13,%rbx
cmp    %rdx,%r9
je     1f27 <prediction+0xe17>
cmpl   $0x0,0x10(%rsp)
js     1650 <prediction+0x540>
cmpl   $0x4,(%rsp)
jae    1690 <prediction+0x580>
xor    %r14d,%r14d
jmp    17b0 <prediction+0x6a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r9,%rcx
imul   0x40(%rsp),%rcx
lea    (%rcx,%r11,1),%rdx
mov    0xd8(%rsp),%rbp
lea    0x0(,%rcx,8),%r14
add    %rbp,%r14
lea    (%r12,%rdx,8),%rbp
cmp    %rbp,%r14
jae    16e7 <prediction+0x5d7>
mov    0xd8(%rsp),%rbp
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
lea    (%r12,%rcx,8),%rcx
cmp    %rdx,%rcx
jae    16e7 <prediction+0x5d7>
xor    %r14d,%r14d
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%rbp
jmp    17b0 <prediction+0x6a0>
cmpq   $0xc,0x20(%rsp)
jae    16f3 <prediction+0x5e3>
xor    %ecx,%ecx
jmp    175c <prediction+0x64c>
mov    0x28(%rsp),%rbp
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x70(%rdi,%rcx,8),%xmm0
movups -0x60(%rdi,%rcx,8),%xmm1
movups %xmm0,-0x70(%rsi,%rcx,8)
movups %xmm1,-0x60(%rsi,%rcx,8)
movups -0x50(%rdi,%rcx,8),%xmm0
movups -0x40(%rdi,%rcx,8),%xmm1
movups %xmm0,-0x50(%rsi,%rcx,8)
movups %xmm1,-0x40(%rsi,%rcx,8)
movups -0x30(%rdi,%rcx,8),%xmm0
movups -0x20(%rdi,%rcx,8),%xmm1
movups %xmm0,-0x30(%rsi,%rcx,8)
movups %xmm1,-0x20(%rsi,%rcx,8)
movupd -0x10(%rdi,%rcx,8),%xmm0
movupd (%rdi,%rcx,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rcx,8)
movupd %xmm1,(%rsi,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    1700 <prediction+0x5f0>
cmpq   $0x0,0x18(%rsp)
je     1790 <prediction+0x680>
lea    (%rax,%rcx,8),%rbp
lea    (%r8,%rcx,8),%rcx
xor    %edx,%edx
xchg   %ax,%ax
movupd -0x10(%rcx,%rdx,1),%xmm0
movupd (%rcx,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,1)
movupd %xmm1,0x0(%rbp,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1770 <prediction+0x660>
mov    0x30(%rsp),%rcx
mov    %rcx,%r14
cmp    %r11,%rcx
mov    0x38(%rsp),%rdx
mov    0x8(%rsp),%rbp
je     1650 <prediction+0x540>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rcx
not    %rcx
add    %r11,%rcx
test   %rbp,%rbp
je     17d6 <prediction+0x6c6>
xchg   %ax,%ax
movsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,(%r15,%r14,8)
add    $0x1,%r14
add    $0xffffffffffffffff,%rbp
jne    17c0 <prediction+0x6b0>
cmp    $0x3,%rcx
mov    0x8(%rsp),%rbp
jb     1650 <prediction+0x540>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,-0x10(%rax,%r14,8)
movsd  0x8(%rbx,%r14,8),%xmm0
movsd  %xmm0,-0x8(%rax,%r14,8)
movsd  0x10(%rbx,%r14,8),%xmm0
movsd  %xmm0,(%rax,%r14,8)
movsd  0x18(%rbx,%r14,8),%xmm0
movsd  %xmm0,0x8(%rax,%r14,8)
add    $0x4,%r14
cmp    %r14,%r11
jne    17f0 <prediction+0x6e0>
jmp    1650 <prediction+0x540>
mov    (%rbx),%r13d
cmp    $0x2,%eax
jne    1d31 <prediction+0xc21>
test   %r13d,%r13d
jle    1f27 <prediction+0xe17>
mov    (%rsp),%eax
movslq %eax,%rsi
mov    %eax,%r8d
mov    %r8d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x68(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
mov    %r8d,%edx
and    $0x3,%edx
mov    0xd8(%rsp),%rdi
lea    0x70(%rdi),%r14
lea    0x0(,%rsi,8),%rax
mov    %rax,0x20(%rsp)
lea    0x70(%r12),%rbp
lea    0x10(%rdi),%r10
lea    0x10(%r12),%r11
mov    %rcx,0x58(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x48(%rsp)
xor    %r15d,%r15d
mov    %r12,%rbx
mov    %r13,0x30(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdx,0x28(%rsp)
jmp    18f9 <prediction+0x7e9>
xchg   %ax,%ax
add    $0x1,%r15
mov    0x20(%rsp),%rax
add    %rax,%r14
add    %rax,%rbp
add    %rax,%r10
add    %rax,%r11
add    %rax,%rdi
add    %rax,%rbx
mov    0x30(%rsp),%r13
cmp    %r13,%r15
je     1e84 <prediction+0xd74>
cmpl   $0x0,0x10(%rsp)
js     18d0 <prediction+0x7c0>
cmpl   $0x4,(%rsp)
jae    1910 <prediction+0x800>
xor    %r13d,%r13d
jmp    1a40 <prediction+0x930>
xchg   %ax,%ax
mov    %r15,%rax
imul   %rsi,%rax
lea    (%rax,%r8,1),%rcx
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
lea    (%r12,%rcx,8),%rdx
cmp    %rdx,%rsi
mov    0xd8(%rsp),%rdx
jae    1957 <prediction+0x847>
lea    (%rdx,%rcx,8),%rcx
lea    (%r12,%rax,8),%rax
cmp    %rcx,%rax
jae    1957 <prediction+0x847>
xor    %r13d,%r13d
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%rdx
jmp    1a40 <prediction+0x930>
cmpq   $0xc,0x60(%rsp)
jae    196b <prediction+0x85b>
xor    %eax,%eax
mov    0x48(%rsp),%rsi
jmp    19e5 <prediction+0x8d5>
mov    0x50(%rsp),%rcx
xor    %eax,%eax
mov    0x48(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movups -0x70(%rbp,%rax,8),%xmm0
movups -0x60(%rbp,%rax,8),%xmm1
movups %xmm0,-0x70(%r14,%rax,8)
movups %xmm1,-0x60(%r14,%rax,8)
movups -0x50(%rbp,%rax,8),%xmm0
movups -0x40(%rbp,%rax,8),%xmm1
movups %xmm0,-0x50(%r14,%rax,8)
movups %xmm1,-0x40(%r14,%rax,8)
movups -0x30(%rbp,%rax,8),%xmm0
movups -0x20(%rbp,%rax,8),%xmm1
movups %xmm0,-0x30(%r14,%rax,8)
movups %xmm1,-0x20(%r14,%rax,8)
movupd -0x10(%rbp,%rax,8),%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
movupd %xmm0,-0x10(%r14,%rax,8)
movupd %xmm1,(%r14,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1980 <prediction+0x870>
cmpq   $0x0,0x58(%rsp)
je     1a1f <prediction+0x90f>
lea    (%r10,%rax,8),%rcx
lea    (%r11,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rax,%rdx,1),%xmm0
movupd (%rax,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,1)
movupd %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1a00 <prediction+0x8f0>
mov    0x68(%rsp),%rax
mov    %rax,%r13
cmp    %r8,%rax
mov    0x28(%rsp),%rdx
mov    0x18(%rsp),%rsi
je     18d0 <prediction+0x7c0>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rax
not    %rax
add    %r8,%rax
test   %rdx,%rdx
je     1a76 <prediction+0x966>
mov    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%r13,8),%xmm0
movsd  %xmm0,(%rdi,%r13,8)
add    $0x1,%r13
add    $0xffffffffffffffff,%rcx
jne    1a60 <prediction+0x950>
cmp    $0x3,%rax
jb     18d0 <prediction+0x7c0>
movsd  (%rbx,%r13,8),%xmm0
movsd  %xmm0,-0x10(%r10,%r13,8)
movsd  0x8(%rbx,%r13,8),%xmm0
movsd  %xmm0,-0x8(%r10,%r13,8)
movsd  0x10(%rbx,%r13,8),%xmm0
movsd  %xmm0,(%r10,%r13,8)
movsd  0x18(%rbx,%r13,8),%xmm0
movsd  %xmm0,0x8(%r10,%r13,8)
add    $0x4,%r13
cmp    %r13,%r8
jne    1a80 <prediction+0x970>
jmp    18d0 <prediction+0x7c0>
test   %r8d,%r8d
jle    1f27 <prediction+0xe17>
mov    (%rsp),%eax
movslq %eax,%rdx
mov    %eax,%r10d
mov    0xc8(%rsp),%rax
lea    0x8(%rax),%rbp
lea    0x0(,%rdx,8),%r11
mov    0xd0(%rsp),%rax
lea    0x8(%rax),%rsi
mov    0xd8(%rsp),%rax
lea    0x8(%rax),%rcx
lea    0x8(%r12),%rbx
mov    0xf8(%rsp),%rax
add    $0x4,%rax
mov    %rdx,(%rsp)
lea    0x0(,%rdx,4),%r15
add    $0xffffffffffffffff,%r10
xor    %r14d,%r14d
movapd 0x4d2(%rip),%xmm2
movsd  0x4da(%rip),%xmm3
jmp    1b5c <prediction+0xa4c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r11,%rbp
add    %r11,%rsi
add    %r11,%rcx
add    %r11,%rbx
add    %r15,%rax
cmp    %r8,%r14
je     1f27 <prediction+0xe17>
cmpl   $0x0,0x10(%rsp)
mov    0xd8(%rsp),%rdx
mov    0x8(%rsp),%rdi
js     1b40 <prediction+0xa30>
mov    %r14,%r13
imul   (%rsp),%r13
movsd  (%rdi),%xmm4
mov    0xd0(%rsp),%rdi
movsd  (%rdi,%r13,8),%xmm5
mulsd  %xmm1,%xmm5
mov    0xc8(%rsp),%rdi
mulsd  (%rdi,%r13,8),%xmm4
addsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
ucomisd %xmm3,%xmm5
jbe    1bbe <prediction+0xaae>
mulsd  %xmm3,%xmm4
divsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
ucomisd 0x8(%r9),%xmm5
jbe    1bdb <prediction+0xacb>
mov    0xf8(%rsp),%rdi
cmpl   $0x0,(%rdi,%r13,4)
jle    1bdb <prediction+0xacb>
movsd  %xmm5,0x8(%r9)
addsd  (%r12,%r13,8),%xmm4
movsd  %xmm4,(%rdx,%r13,8)
mov    0xd0(%rsp),%rdi
movsd  (%rdi,%r13,8),%xmm4
mulsd  %xmm0,%xmm4
mov    0xc8(%rsp),%rdx
addsd  (%rdx,%r13,8),%xmm4
movsd  %xmm4,(%rdx,%r13,8)
movq   $0x0,(%rdi,%r13,8)
cmpl   $0x0,0x10(%rsp)
mov    0x8(%rsp),%rdx
je     1b40 <prediction+0xa30>
xor    %edi,%edi
jmp    1c64 <prediction+0xb54>
nopl   0x0(%rax)
addsd  (%rbx,%rdi,8),%xmm4
movsd  %xmm4,(%rcx,%rdi,8)
movsd  (%rsi,%rdi,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  0x0(%rbp,%rdi,8),%xmm4
movsd  %xmm4,0x0(%rbp,%rdi,8)
movq   $0x0,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%r10
je     1b40 <prediction+0xa30>
movsd  (%rdx),%xmm4
movsd  (%rsi,%rdi,8),%xmm5
mulsd  %xmm1,%xmm5
mulsd  0x0(%rbp,%rdi,8),%xmm4
addsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
ucomisd (%r9),%xmm5
jbe    1c30 <prediction+0xb20>
cmpl   $0x0,(%rax,%rdi,4)
jle    1c30 <prediction+0xb20>
movsd  %xmm5,(%r9)
jmp    1c30 <prediction+0xb20>
mov    0x30(%rsp),%rsi
test   %esi,%esi
jle    1f27 <prediction+0xe17>
shl    $0x2,%r11
xor    %eax,%eax
movapd 0x34e(%rip),%xmm0
movsd  0x356(%rip),%xmm1
jmp    1cd7 <prediction+0xbc7>
nopl   0x0(%rax)
addsd  (%rcx,%rax,2),%xmm2
movsd  %xmm2,(%rcx,%rax,2)
add    %r11,%rax
add    $0xffffffffffffffff,%rsi
je     1f27 <prediction+0xe17>
mov    0x8(%rsp),%rcx
movsd  (%rcx),%xmm2
mov    0xc8(%rsp),%rcx
mulsd  (%rcx,%rax,2),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm1,%xmm3
jbe    1d0b <prediction+0xbfb>
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
mov    0xd8(%rsp),%rcx
ucomisd 0x8(%r9),%xmm3
jbe    1cc0 <prediction+0xbb0>
mov    0xf8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rax,1)
jle    1cc0 <prediction+0xbb0>
movsd  %xmm3,0x8(%r9)
jmp    1cc0 <prediction+0xbb0>
test   %r13d,%r13d
jle    1f27 <prediction+0xe17>
mov    (%rsp),%eax
movslq %eax,%r11
mov    %eax,%r10d
add    $0xffffffffffffffff,%r10
mov    $0x1,%r14d
xor    %r8d,%r8d
movapd 0x2a8(%rip),%xmm0
movsd  0x2b0(%rip),%xmm1
mov    0x8(%rsp),%r15
jmp    1d80 <prediction+0xc70>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r11,%r14
cmp    %r13,%r8
je     1f27 <prediction+0xe17>
cmpl   $0x0,0x10(%rsp)
mov    0xd8(%rsp),%rbx
js     1d70 <prediction+0xc60>
mov    0xe8(%rsp),%rax
mov    (%rax),%ebp
mov    %r8,%rdi
imul   %r11,%rdi
test   %ebp,%ebp
je     1db0 <prediction+0xca0>
movsd  (%r12,%rdi,8),%xmm2
jmp    1e02 <prediction+0xcf2>
nopl   0x0(%rax)
movsd  (%r15),%xmm2
mov    0xc8(%rsp),%rax
mulsd  (%rax,%rdi,8),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm1,%xmm3
jbe    1de0 <prediction+0xcd0>
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd 0x8(%r9),%xmm3
jbe    1dfc <prediction+0xcec>
mov    0xf8(%rsp),%rax
cmpl   $0x0,(%rax,%rdi,4)
jle    1dfc <prediction+0xcec>
movsd  %xmm3,0x8(%r9)
addsd  (%r12,%rdi,8),%xmm2
movsd  %xmm2,(%rbx,%rdi,8)
cmpl   $0x0,0x10(%rsp)
je     1d70 <prediction+0xc60>
mov    $0x1,%ecx
mov    %r10,%rax
mov    %r14,%rsi
jmp    1e40 <prediction+0xd30>
nop
movsd  (%r12,%rsi,8),%xmm2
mov    %rsi,%rdx
movsd  %xmm2,(%rbx,%rdx,8)
add    $0x1,%rcx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
je     1d70 <prediction+0xc60>
test   %ebp,%ebp
jne    1e20 <prediction+0xd10>
movsd  (%r15),%xmm2
mov    0xc8(%rsp),%rdx
mulsd  (%rdx,%rsi,8),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd (%r9),%xmm3
jbe    1e78 <prediction+0xd68>
mov    0xf8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rsi,4)
jle    1e78 <prediction+0xd68>
movsd  %xmm3,(%r9)
lea    (%rcx,%rdi,1),%rdx
addsd  (%r12,%rsi,8),%xmm2
jmp    1e29 <prediction+0xd19>
test   %r13d,%r13d
jle    1f27 <prediction+0xe17>
mov    0xe8(%rsp),%rax
mov    (%rax),%eax
shl    $0x2,%rsi
xor    %ecx,%ecx
movapd 0x15b(%rip),%xmm0
movsd  0x163(%rip),%xmm1
jmp    1ec3 <prediction+0xdb3>
nop
addsd  (%rdx,%rcx,2),%xmm2
movsd  %xmm2,(%rdx,%rcx,2)
add    %rsi,%rcx
add    $0xffffffffffffffff,%r13
je     1f27 <prediction+0xe17>
test   %eax,%eax
jne    1eba <prediction+0xdaa>
mov    0x8(%rsp),%rdx
movsd  (%rdx),%xmm2
mov    0xc8(%rsp),%rdx
mulsd  (%rdx,%rcx,2),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm1,%xmm3
jbe    1efb <prediction+0xdeb>
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
mov    0xd8(%rsp),%rdx
ucomisd 0x8(%r9),%xmm3
jbe    1eb0 <prediction+0xda0>
mov    %rsi,%rdi
mov    0xf8(%rsp),%rsi
cmpl   $0x0,(%rsi,%rcx,1)
mov    %rdi,%rsi
jle    1eb0 <prediction+0xda0>
movsd  %xmm3,0x8(%r9)
jmp    1eb0 <prediction+0xda0>
mov    0xe8(%rsp),%rax
movl   $0x0,(%rax)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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