#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);
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 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) {
      for (k = 0; k < *nk; ++k) {
        for (j = 0; j < mt; j++) {
          dextrapol = *dtime * veold[mt * k + j] + scal1 * accold[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;
          veold[mt * k + j] = veold[mt * k + j] + scal2 * accold[mt * k + j];
          accold[mt * k + j] = 0.;
        }
      }
    } 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 = 0; 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
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,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
cmpl   $0x4,(%rax)
jne    1713 <prediction+0x613>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
addsd  %xmm0,%xmm0
movsd  0xe83(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0xe7f(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0xe52(%rip),%xmm0
subsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jge    1353 <prediction+0x253>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    134e <prediction+0x24e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    133b <prediction+0x23b>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xdd1(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    1294 <prediction+0x194>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1294 <prediction+0x194>
movsd  -0x48(%rbp),%xmm0
movaps 0xd98(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f1 <prediction+0xf1>
jmp    1340 <prediction+0x240>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11db <prediction+0xdb>
jmp    170e <prediction+0x60e>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    14d4 <prediction+0x3d4>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    13d6 <prediction+0x2d6>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13c3 <prediction+0x2c3>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    137d <prediction+0x27d>
jmp    13c8 <prediction+0x2c8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1367 <prediction+0x267>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    14cf <prediction+0x3cf>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xc08(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xbdc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1454 <prediction+0x354>
movsd  0xbca(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0xbd9(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xbc0(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    14a4 <prediction+0x3a4>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    14a4 <prediction+0x3a4>
movsd  -0x48(%rbp),%xmm0
movaps 0xb89(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13dd <prediction+0x2dd>
jmp    1709 <prediction+0x609>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1704 <prediction+0x604>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    16f1 <prediction+0x5f1>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1595 <prediction+0x495>
movsd  -0x48(%rbp),%xmm0
movaps 0xac7(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xa9b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1595 <prediction+0x495>
movsd  0xa89(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0xa98(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    15f4 <prediction+0x4f4>
movsd  -0x48(%rbp),%xmm0
movaps 0xa75(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    15ef <prediction+0x4ef>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    15ef <prediction+0x4ef>
movsd  -0x48(%rbp),%xmm0
movaps 0xa3e(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    164a <prediction+0x54a>
movsd  -0x48(%rbp),%xmm0
movaps 0xa20(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    1645 <prediction+0x545>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1645 <prediction+0x545>
movsd  -0x48(%rbp),%xmm0
movaps 0x9e7(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    164a <prediction+0x54a>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14f1 <prediction+0x3f1>
jmp    16f6 <prediction+0x5f6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14db <prediction+0x3db>
jmp    1709 <prediction+0x609>
jmp    170e <prediction+0x60e>
jmp    1c71 <prediction+0xb71>
mov    0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jle    1bf1 <prediction+0xaf1>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jge    1864 <prediction+0x764>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    185f <prediction+0x75f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    184c <prediction+0x74c>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    180d <prediction+0x70d>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0x88e(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    17d7 <prediction+0x6d7>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    17d7 <prediction+0x6d7>
movsd  -0x48(%rbp),%xmm0
movaps 0x855(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1839 <prediction+0x739>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    183e <prediction+0x73e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    174a <prediction+0x64a>
jmp    1851 <prediction+0x751>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1734 <prediction+0x634>
jmp    1bec <prediction+0xaec>
mov    -0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    19f7 <prediction+0x8f7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    18e7 <prediction+0x7e7>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    18d4 <prediction+0x7d4>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    188e <prediction+0x78e>
jmp    18d9 <prediction+0x7d9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1878 <prediction+0x778>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    19f2 <prediction+0x8f2>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    19df <prediction+0x8df>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0x6ea(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x6be(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1972 <prediction+0x872>
movsd  0x6ac(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0x6bb(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0x6a2(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    19c2 <prediction+0x8c2>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    19c2 <prediction+0x8c2>
movsd  -0x48(%rbp),%xmm0
movaps 0x66b(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    19e4 <prediction+0x8e4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18ee <prediction+0x7ee>
jmp    1be7 <prediction+0xae7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1be2 <prediction+0xae2>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1bcf <prediction+0xacf>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1b90 <prediction+0xa90>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1aa2 <prediction+0x9a2>
movsd  -0x48(%rbp),%xmm0
movaps 0x5ba(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x58e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1aa2 <prediction+0x9a2>
movsd  0x57c(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0x58b(%rip),%xmm2
pand   %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1b04 <prediction+0xa04>
movsd  -0x48(%rbp),%xmm0
movaps 0x568(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
jbe    1aff <prediction+0x9ff>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1aff <prediction+0x9ff>
movsd  -0x48(%rbp),%xmm0
movaps 0x52e(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,0x8(%rax)
jmp    1b5a <prediction+0xa5a>
movsd  -0x48(%rbp),%xmm0
movaps 0x510(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    1b55 <prediction+0xa55>
mov    0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    1b55 <prediction+0xa55>
movsd  -0x48(%rbp),%xmm0
movaps 0x4d7(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1b5a <prediction+0xa5a>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1bbc <prediction+0xabc>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1bc1 <prediction+0xac1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a14 <prediction+0x914>
jmp    1bd4 <prediction+0xad4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19fe <prediction+0x8fe>
jmp    1be7 <prediction+0xae7>
jmp    1bec <prediction+0xaec>
jmp    1c6c <prediction+0xb6c>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1c67 <prediction+0xb67>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1c54 <prediction+0xb54>
mov    0x40(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c0e <prediction+0xb0e>
jmp    1c59 <prediction+0xb59>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bf8 <prediction+0xaf8>
jmp    1c6c <prediction+0xb6c>
jmp    1c71 <prediction+0xb71>
mov    0x38(%rbp),%rax
movl   $0x0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<prediction>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x70(%rsp),%rax
mov    %rax,-0x30(%rsp)
mov    0x68(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    0x50(%rsp),%rax
mov    %rax,-0x8(%rsp)
mov    0x40(%rsp),%r14
mov    0x38(%rsp),%rax
mov    0x78(%rsp),%rbp
mov    0x4(%rbp),%ebp
mov    %rbp,-0x68(%rsp)
add    $0x1,%ebp
mov    %ebp,-0x78(%rsp)
xorpd  %xmm0,%xmm0
movupd %xmm0,(%rdi)
cmpl   $0x4,(%rsi)
jne    1287 <prediction+0x187>
mov    0x48(%rsp),%rsi
movsd  (%rdx),%xmm2
addsd  %xmm2,%xmm2
movsd  0xeac(%rip),%xmm0
movapd %xmm0,%xmm1
subsd  %xmm2,%xmm1
mulsd  0xea4(%rip),%xmm1
movsd  (%r8),%xmm2
mulsd  %xmm2,%xmm1
subsd  (%rcx),%xmm0
mulsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm0
mov    (%r9),%ecx
cmp    $0x1,%ecx
jg     1374 <prediction+0x274>
mov    (%rax),%r9d
test   %r9d,%r9d
jle    1f5e <prediction+0xe5e>
mov    -0x78(%rsp),%eax
movslq %eax,%r10
mov    %eax,%edx
lea    0x0(,%r10,8),%r11
shl    $0x2,%r10
shl    $0x2,%rdx
xor    %r15d,%r15d
movapd 0xe33(%rip),%xmm2
jmp    11fb <prediction+0xfb>
nop
add    $0x1,%r15
add    %r11,%r14
add    %r11,%rsi
add    %r10,%rbx
mov    %rbx,-0x30(%rsp)
add    %r11,%rax
mov    %rax,-0x10(%rsp)
add    %r11,%rbp
mov    %rbp,-0x8(%rsp)
cmp    %r9,%r15
je     1f5e <prediction+0xe5e>
cmpl   $0x0,-0x68(%rsp)
mov    -0x8(%rsp),%rbp
mov    -0x30(%rsp),%rbx
mov    -0x10(%rsp),%rax
js     11d0 <prediction+0xd0>
xor    %ecx,%ecx
jmp    1255 <prediction+0x155>
cs nopw 0x0(%rax,%rax,1)
nop
addsd  (%rax,%rcx,2),%xmm3
movsd  %xmm3,0x0(%rbp,%rcx,2)
movsd  (%rsi,%rcx,2),%xmm3
mulsd  %xmm0,%xmm3
addsd  (%r14,%rcx,2),%xmm3
movsd  %xmm3,(%r14,%rcx,2)
movq   $0x0,(%rsi,%rcx,2)
add    $0x4,%rcx
cmp    %rcx,%rdx
je     11d0 <prediction+0xd0>
movsd  (%r8),%xmm3
movsd  (%rsi,%rcx,2),%xmm4
mulsd  %xmm1,%xmm4
mulsd  (%r14,%rcx,2),%xmm3
addsd  %xmm4,%xmm3
movapd %xmm3,%xmm4
andpd  %xmm2,%xmm4
ucomisd (%rdi),%xmm4
jbe    1220 <prediction+0x120>
cmpl   $0x0,(%rbx,%rcx,1)
jle    1220 <prediction+0x120>
movsd  %xmm4,(%rdi)
jmp    1220 <prediction+0x120>
mov    0x58(%rsp),%rcx
cmpl   $0x1,(%rcx)
jle    1634 <prediction+0x534>
mov    (%r9),%ecx
cmp    $0x1,%ecx
jg     18a0 <prediction+0x7a0>
mov    (%rax),%r10d
test   %r10d,%r10d
jle    1f5e <prediction+0xe5e>
mov    -0x78(%rsp),%eax
movslq %eax,%r15
mov    %eax,%eax
mov    %rax,-0x78(%rsp)
xor    %r12d,%r12d
movapd 0xd3a(%rip),%xmm0
xor    %r13d,%r13d
jmp    12e0 <prediction+0x1e0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    %r15,%r12
cmp    %r10,%r13
je     1f5e <prediction+0xe5e>
cmpl   $0x0,-0x68(%rsp)
js     12d0 <prediction+0x1d0>
mov    0x60(%rsp),%rax
mov    (%rax),%edx
mov    %r13,%r11
imul   %r15,%r11
mov    -0x78(%rsp),%rcx
mov    %r12,%rsi
xor    %eax,%eax
jmp    1337 <prediction+0x237>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rbp
movsd  0x0(%rbp,%rsi,8),%xmm1
mov    %rsi,%rbp
mov    0x50(%rsp),%r9
movsd  %xmm1,(%r9,%rbp,8)
add    $0x1,%rax
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
je     12d0 <prediction+0x1d0>
test   %edx,%edx
jne    1310 <prediction+0x210>
movsd  (%r8),%xmm1
mulsd  (%r14,%rsi,8),%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
ucomisd (%rdi),%xmm2
jbe    1364 <prediction+0x264>
mov    0x70(%rsp),%rbp
cmpl   $0x0,0x0(%rbp,%rsi,4)
jle    1364 <prediction+0x264>
movsd  %xmm2,(%rdi)
lea    (%rax,%r11,1),%rbp
mov    0x68(%rsp),%rbx
addsd  (%rbx,%rsi,8),%xmm1
jmp    131e <prediction+0x21e>
mov    (%rax),%ebx
cmp    $0x2,%ecx
jne    1b64 <prediction+0xa64>
test   %ebx,%ebx
jle    1f5e <prediction+0xe5e>
mov    -0x78(%rsp),%eax
movslq %eax,%rcx
mov    %eax,%esi
mov    %esi,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%ebp
and    $0x3,%ebp
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,-0x58(%rsp)
mov    0x50(%rsp),%r13
lea    0x70(%r13),%r10
mov    %rcx,-0x50(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,-0x48(%rsp)
mov    0x68(%rsp),%r12
lea    0x70(%r12),%r9
lea    0x10(%r13),%rdx
lea    0x10(%r12),%rax
mov    %rbp,-0x20(%rsp)
mov    %rbp,%rcx
mov    %rax,%rbp
shl    $0x5,%rcx
mov    %rcx,-0x40(%rsp)
xor    %r11d,%r11d
mov    %rbx,-0x60(%rsp)
jmp    1434 <prediction+0x334>
nop
add    $0x1,%r11
mov    -0x48(%rsp),%rcx
add    %rcx,%r10
add    %rcx,%r9
add    %rcx,%rdx
add    %rcx,%rbp
add    %rcx,%r13
add    %rcx,%r12
cmp    %rbx,%r11
je     1d05 <prediction+0xc05>
cmpl   $0x0,-0x68(%rsp)
js     1410 <prediction+0x310>
cmpl   $0x4,-0x78(%rsp)
mov    %rbp,-0x70(%rsp)
jae    1450 <prediction+0x350>
xor    %r15d,%r15d
jmp    1590 <prediction+0x490>
nop
mov    %r11,%rax
imul   -0x50(%rsp),%rax
lea    (%rax,%rsi,1),%rcx
mov    0x50(%rsp),%rbp
lea    0x0(,%rax,8),%r15
add    %rbp,%r15
mov    0x68(%rsp),%rbx
lea    (%rbx,%rcx,8),%rbp
cmp    %rbp,%r15
jae    14a1 <prediction+0x3a1>
mov    0x50(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
lea    (%rbx,%rax,8),%rax
cmp    %rcx,%rax
jae    14a1 <prediction+0x3a1>
xor    %r15d,%r15d
mov    -0x60(%rsp),%rbx
jmp    1590 <prediction+0x490>
cmpq   $0xc,-0x18(%rsp)
jae    14b2 <prediction+0x3b2>
xor    %ebp,%ebp
mov    -0x40(%rsp),%rbx
jmp    152c <prediction+0x42c>
mov    -0x28(%rsp),%rcx
xor    %ebp,%ebp
mov    -0x40(%rsp),%rbx
xchg   %ax,%ax
movups -0x70(%r9,%rbp,8),%xmm0
movups -0x60(%r9,%rbp,8),%xmm1
movups %xmm0,-0x70(%r10,%rbp,8)
movups %xmm1,-0x60(%r10,%rbp,8)
movups -0x50(%r9,%rbp,8),%xmm0
movups -0x40(%r9,%rbp,8),%xmm1
movups %xmm0,-0x50(%r10,%rbp,8)
movups %xmm1,-0x40(%r10,%rbp,8)
movups -0x30(%r9,%rbp,8),%xmm0
movups -0x20(%r9,%rbp,8),%xmm1
movups %xmm0,-0x30(%r10,%rbp,8)
movups %xmm1,-0x20(%r10,%rbp,8)
movupd -0x10(%r9,%rbp,8),%xmm0
movupd (%r9,%rbp,8),%xmm1
movupd %xmm0,-0x10(%r10,%rbp,8)
movupd %xmm1,(%r10,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rcx
jne    14c0 <prediction+0x3c0>
cmpq   $0x0,-0x20(%rsp)
je     1570 <prediction+0x470>
lea    (%rdx,%rbp,8),%rcx
mov    -0x70(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rbp,%rax,1),%xmm0
movupd 0x0(%rbp,%rax,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rax,1)
movupd %xmm1,(%rcx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbx
jne    1550 <prediction+0x450>
mov    -0x38(%rsp),%rax
mov    %rax,%r15
cmp    %rsi,%rax
mov    -0x70(%rsp),%rbp
mov    -0x60(%rsp),%rbx
je     1410 <prediction+0x310>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
mov    %r15,%rcx
not    %rcx
add    %rsi,%rcx
mov    -0x58(%rsp),%rbx
test   %rbx,%rbx
je     15d0 <prediction+0x4d0>
mov    %rbx,%rbp
mov    %rax,%rbx
nopl   0x0(%rax)
movsd  (%r12,%r15,8),%xmm0
movsd  %xmm0,0x0(%r13,%r15,8)
add    $0x1,%r15
add    $0xffffffffffffffff,%rbp
jne    15b0 <prediction+0x4b0>
jmp    15d3 <prediction+0x4d3>
nopl   0x0(%rax)
mov    %rax,%rbx
cmp    $0x3,%rcx
mov    -0x70(%rsp),%rbp
jb     1410 <prediction+0x310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%r15,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%r15,8)
movsd  0x8(%r12,%r15,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%r15,8)
movsd  0x10(%r12,%r15,8),%xmm0
movsd  %xmm0,(%rdx,%r15,8)
movsd  0x18(%r12,%r15,8),%xmm0
movsd  %xmm0,0x8(%rdx,%r15,8)
add    $0x4,%r15
cmp    %r15,%rsi
jne    15f0 <prediction+0x4f0>
jmp    1410 <prediction+0x310>
mov    (%rax),%r14d
test   %r14d,%r14d
jle    1f5e <prediction+0xe5e>
movslq -0x78(%rsp),%rax
mov    %eax,%esi
mov    %esi,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,-0x58(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x50(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rsp)
mov    %esi,%r15d
and    $0x3,%r15d
mov    0x50(%rsp),%r11
lea    0x70(%r11),%rdx
mov    %rax,-0x70(%rsp)
lea    0x0(,%rax,8),%r12
mov    0x68(%rsp),%rax
lea    0x70(%rax),%rbp
lea    0x10(%r11),%r8
lea    0x10(%rax),%r9
mov    %r10,-0x60(%rsp)
shl    $0x5,%r10
xor    %r13d,%r13d
mov    %r14,-0x30(%rsp)
mov    %r15,-0x48(%rsp)
jmp    16df <prediction+0x5df>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    %r12,%rdx
add    %r12,%rbp
add    %r12,%r8
add    %r12,%r9
add    %r12,%r11
add    %r12,%rax
cmp    %r14,%r13
je     1f5e <prediction+0xe5e>
cmpl   $0x0,-0x68(%rsp)
js     16c0 <prediction+0x5c0>
cmpl   $0x4,-0x78(%rsp)
jae    1700 <prediction+0x600>
xor    %ebx,%ebx
jmp    1820 <prediction+0x720>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rcx
imul   -0x70(%rsp),%rcx
lea    (%rcx,%rsi,1),%rdi
mov    0x50(%rsp),%rbx
lea    (%rbx,%rcx,8),%r15
mov    0x68(%rsp),%r14
lea    (%r14,%rdi,8),%rbx
cmp    %rbx,%r15
jae    1747 <prediction+0x647>
mov    0x50(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
lea    (%r14,%rcx,8),%rcx
cmp    %rdi,%rcx
jae    1747 <prediction+0x647>
xor    %ebx,%ebx
mov    -0x30(%rsp),%r14
mov    -0x48(%rsp),%r15
jmp    1820 <prediction+0x720>
cmpq   $0xc,-0x50(%rsp)
jae    1753 <prediction+0x653>
xor    %ebx,%ebx
jmp    17bd <prediction+0x6bd>
mov    -0x38(%rsp),%r15
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x70(%rbp,%rbx,8),%xmm0
movups -0x60(%rbp,%rbx,8),%xmm1
movups %xmm0,-0x70(%rdx,%rbx,8)
movups %xmm1,-0x60(%rdx,%rbx,8)
movups -0x50(%rbp,%rbx,8),%xmm0
movups -0x40(%rbp,%rbx,8),%xmm1
movups %xmm0,-0x50(%rdx,%rbx,8)
movups %xmm1,-0x40(%rdx,%rbx,8)
movups -0x30(%rbp,%rbx,8),%xmm0
movups -0x20(%rbp,%rbx,8),%xmm1
movups %xmm0,-0x30(%rdx,%rbx,8)
movups %xmm1,-0x20(%rdx,%rbx,8)
movupd -0x10(%rbp,%rbx,8),%xmm0
movupd 0x0(%rbp,%rbx,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rbx,8)
movupd %xmm1,(%rdx,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%r15
jne    1760 <prediction+0x660>
cmpq   $0x0,-0x60(%rsp)
mov    -0x30(%rsp),%r14
je     17ff <prediction+0x6ff>
lea    (%r8,%rbx,8),%rdi
lea    (%r9,%rbx,8),%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%rcx,%rbx,1),%xmm0
movupd (%rcx,%rbx,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rbx,1)
movupd %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    17e0 <prediction+0x6e0>
mov    -0x58(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rsi,%rcx
mov    -0x48(%rsp),%r15
je     16c0 <prediction+0x5c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
not    %rdi
add    %rsi,%rdi
test   %r15,%r15
je     1855 <prediction+0x755>
mov    %r15,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,(%r11,%rbx,8)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rcx
jne    1840 <prediction+0x740>
cmp    $0x3,%rdi
jb     16c0 <prediction+0x5c0>
nop
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,-0x10(%r8,%rbx,8)
movsd  0x8(%rax,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r8,%rbx,8)
movsd  0x10(%rax,%rbx,8),%xmm0
movsd  %xmm0,(%r8,%rbx,8)
movsd  0x18(%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1860 <prediction+0x760>
jmp    16c0 <prediction+0x5c0>
mov    (%rax),%ebx
cmp    $0x2,%ecx
mov    %rbx,-0x70(%rsp)
jne    1d8e <prediction+0xc8e>
test   %ebx,%ebx
jle    1f5e <prediction+0xe5e>
mov    -0x78(%rsp),%eax
movslq %eax,%rcx
mov    %eax,%r11d
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rsp)
mov    %r11d,%eax
and    $0x3,%eax
mov    %rax,-0x50(%rsp)
mov    0x50(%rsp),%rax
lea    0x70(%rax),%r10
mov    %rcx,-0x60(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,-0x48(%rsp)
mov    0x68(%rsp),%r15
lea    0x70(%r15),%r9
lea    0x10(%rax),%rdx
lea    0x10(%r15),%rbp
mov    %rsi,-0x20(%rsp)
shl    $0x5,%rsi
mov    %rsi,-0x40(%rsp)
xor    %r12d,%r12d
jmp    1964 <prediction+0x864>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r12
mov    -0x48(%rsp),%rcx
add    %rcx,%r10
add    %rcx,%r9
add    %rcx,%rdx
add    %rcx,%rbp
add    %rcx,%rax
add    %rcx,%r15
cmp    %rbx,%r12
je     1ed2 <prediction+0xdd2>
cmpl   $0x0,-0x68(%rsp)
js     1940 <prediction+0x840>
cmpl   $0x4,-0x78(%rsp)
jae    1980 <prediction+0x880>
xor    %r13d,%r13d
jmp    1ad0 <prediction+0x9d0>
nopw   0x0(%rax,%rax,1)
mov    %rbp,-0x58(%rsp)
mov    %r12,%rcx
imul   -0x60(%rsp),%rcx
lea    (%rcx,%r11,1),%rsi
mov    0x50(%rsp),%rbp
lea    0x0(,%rcx,8),%r13
add    %rbp,%r13
mov    0x68(%rsp),%rbx
lea    (%rbx,%rsi,8),%rbp
cmp    %rbp,%r13
mov    0x50(%rsp),%rbp
jae    19d6 <prediction+0x8d6>
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
lea    (%rbx,%rcx,8),%rcx
cmp    %rsi,%rcx
jae    19d6 <prediction+0x8d6>
xor    %r13d,%r13d
mov    -0x58(%rsp),%rbp
jmp    1ad0 <prediction+0x9d0>
cmpq   $0xc,-0x18(%rsp)
jae    19ea <prediction+0x8ea>
xor    %ecx,%ecx
mov    -0x40(%rsp),%rbx
jmp    1a6c <prediction+0x96c>
mov    -0x28(%rsp),%rbp
xor    %ecx,%ecx
mov    -0x40(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movups -0x70(%r9,%rcx,8),%xmm0
movups -0x60(%r9,%rcx,8),%xmm1
movups %xmm0,-0x70(%r10,%rcx,8)
movups %xmm1,-0x60(%r10,%rcx,8)
movups -0x50(%r9,%rcx,8),%xmm0
movups -0x40(%r9,%rcx,8),%xmm1
movups %xmm0,-0x50(%r10,%rcx,8)
movups %xmm1,-0x40(%r10,%rcx,8)
movups -0x30(%r9,%rcx,8),%xmm0
movups -0x20(%r9,%rcx,8),%xmm1
movups %xmm0,-0x30(%r10,%rcx,8)
movups %xmm1,-0x20(%r10,%rcx,8)
movupd -0x10(%r9,%rcx,8),%xmm0
movupd (%r9,%rcx,8),%xmm1
movupd %xmm0,-0x10(%r10,%rcx,8)
movupd %xmm1,(%r10,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rbp
jne    1a00 <prediction+0x900>
cmpq   $0x0,-0x20(%rsp)
je     1ab0 <prediction+0x9b0>
lea    (%rdx,%rcx,8),%rbp
mov    -0x58(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rcx,%rsi,1),%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd %xmm0,-0x10(%rbp,%rsi,1)
movupd %xmm1,0x0(%rbp,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    1a90 <prediction+0x990>
mov    -0x38(%rsp),%rcx
mov    %rcx,%r13
cmp    %r11,%rcx
mov    -0x70(%rsp),%rbx
mov    -0x58(%rsp),%rbp
je     1940 <prediction+0x840>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rcx
not    %rcx
add    %r11,%rcx
mov    -0x50(%rsp),%rbx
mov    %rbp,%rsi
test   %rbx,%rbx
je     1b06 <prediction+0xa06>
mov    %rbx,%rbp
nopl   0x0(%rax)
movsd  (%r15,%r13,8),%xmm0
movsd  %xmm0,(%rax,%r13,8)
add    $0x1,%r13
add    $0xffffffffffffffff,%rbp
jne    1af0 <prediction+0x9f0>
cmp    $0x3,%rcx
mov    -0x70(%rsp),%rbx
mov    %rsi,%rbp
jb     1940 <prediction+0x840>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%r13,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%r13,8)
movsd  0x8(%r15,%r13,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%r13,8)
movsd  0x10(%r15,%r13,8),%xmm0
movsd  %xmm0,(%rdx,%r13,8)
movsd  0x18(%r15,%r13,8),%xmm0
movsd  %xmm0,0x8(%rdx,%r13,8)
add    $0x4,%r13
cmp    %r13,%r11
jne    1b20 <prediction+0xa20>
jmp    1940 <prediction+0x840>
test   %ebx,%ebx
jle    1f5e <prediction+0xe5e>
mov    -0x78(%rsp),%eax
movslq %eax,%r9
mov    %eax,%r15d
lea    0x8(%r14),%rdx
lea    0x0(,%r9,8),%r11
lea    0x8(%rsi),%rax
mov    0x68(%rsp),%rcx
lea    0x8(%rcx),%r10
mov    0x50(%rsp),%rcx
add    $0x8,%rcx
mov    0x70(%rsp),%rbp
lea    0x4(%rbp),%r12
mov    %r9,-0x70(%rsp)
lea    0x0(,%r9,4),%rbp
mov    %rbp,-0x78(%rsp)
add    $0xffffffffffffffff,%r15
xor    %r13d,%r13d
movapd 0x43e(%rip),%xmm2
movsd  0x446(%rip),%xmm3
jmp    1bf1 <prediction+0xaf1>
nopl   0x0(%rax)
add    $0x1,%r13
mov    %r11,%rbp
add    %r11,%rdx
add    %r11,%rax
add    %r11,%r10
add    %r11,%rcx
add    -0x78(%rsp),%r12
cmp    %rbx,%r13
je     1f5e <prediction+0xe5e>
cmpl   $0x0,-0x68(%rsp)
js     1bd0 <prediction+0xad0>
mov    %r13,%r9
imul   -0x70(%rsp),%r9
movsd  (%r8),%xmm4
movsd  (%rsi,%r9,8),%xmm5
mulsd  %xmm1,%xmm5
mulsd  (%r14,%r9,8),%xmm4
addsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
ucomisd %xmm3,%xmm5
jbe    1c38 <prediction+0xb38>
mulsd  %xmm3,%xmm4
divsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
ucomisd 0x8(%rdi),%xmm5
jbe    1c51 <prediction+0xb51>
mov    0x70(%rsp),%rbp
cmpl   $0x0,0x0(%rbp,%r9,4)
jle    1c51 <prediction+0xb51>
movsd  %xmm5,0x8(%rdi)
mov    0x68(%rsp),%rbp
addsd  0x0(%rbp,%r9,8),%xmm4
mov    0x50(%rsp),%rbp
movsd  %xmm4,0x0(%rbp,%r9,8)
movsd  (%rsi,%r9,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  (%r14,%r9,8),%xmm4
movsd  %xmm4,(%r14,%r9,8)
movq   $0x0,(%rsi,%r9,8)
cmpl   $0x0,-0x68(%rsp)
je     1bd0 <prediction+0xad0>
xor    %ebp,%ebp
jmp    1cd3 <prediction+0xbd3>
cs nopw 0x0(%rax,%rax,1)
addsd  (%r10,%rbp,8),%xmm4
movsd  %xmm4,(%rcx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  (%rdx,%rbp,8),%xmm4
movsd  %xmm4,(%rdx,%rbp,8)
movq   $0x0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r15
je     1bd0 <prediction+0xad0>
movsd  (%r8),%xmm4
movsd  (%rax,%rbp,8),%xmm5
mulsd  %xmm1,%xmm5
mulsd  (%rdx,%rbp,8),%xmm4
addsd  %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
ucomisd (%rdi),%xmm5
jbe    1ca0 <prediction+0xba0>
cmpl   $0x0,(%r12,%rbp,4)
jle    1ca0 <prediction+0xba0>
movsd  %xmm5,(%rdi)
jmp    1ca0 <prediction+0xba0>
test   %ebx,%ebx
mov    -0x50(%rsp),%rsi
jle    1f5e <prediction+0xe5e>
shl    $0x2,%rsi
xor    %eax,%eax
movapd 0x2e0(%rip),%xmm0
movsd  0x2e8(%rip),%xmm1
jmp    1d47 <prediction+0xc47>
nopw   0x0(%rax,%rax,1)
addsd  (%rcx,%rax,2),%xmm2
movsd  %xmm2,(%rcx,%rax,2)
add    %rsi,%rax
add    $0xffffffffffffffff,%rbx
je     1f5e <prediction+0xe5e>
movsd  (%r8),%xmm2
mulsd  (%r14,%rax,2),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm1,%xmm3
jbe    1d70 <prediction+0xc70>
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
mov    0x50(%rsp),%rcx
mov    0x70(%rsp),%rdx
ucomisd 0x8(%rdi),%xmm3
jbe    1d30 <prediction+0xc30>
cmpl   $0x0,(%rdx,%rax,1)
jle    1d30 <prediction+0xc30>
movsd  %xmm3,0x8(%rdi)
jmp    1d30 <prediction+0xc30>
test   %ebx,%ebx
jle    1f5e <prediction+0xe5e>
mov    -0x78(%rsp),%eax
movslq %eax,%r10
mov    %eax,%r9d
add    $0xffffffffffffffff,%r9
mov    $0x1,%r15d
xor    %r12d,%r12d
movapd 0x24b(%rip),%xmm0
movsd  0x253(%rip),%xmm1
jmp    1dd2 <prediction+0xcd2>
nop
add    $0x1,%r12
add    %r10,%r15
cmp    -0x70(%rsp),%r12
je     1f5e <prediction+0xe5e>
cmpl   $0x0,-0x68(%rsp)
mov    0x50(%rsp),%r13
js     1dc0 <prediction+0xcc0>
mov    0x60(%rsp),%rax
mov    (%rax),%ebp
mov    %r12,%r11
imul   %r10,%r11
test   %ebp,%ebp
je     1e00 <prediction+0xd00>
mov    0x68(%rsp),%rax
movsd  (%rax,%r11,8),%xmm2
jmp    1e4c <prediction+0xd4c>
nopl   (%rax)
movsd  (%r8),%xmm2
mulsd  (%r14,%r11,8),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm1,%xmm3
jbe    1e29 <prediction+0xd29>
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd 0x8(%rdi),%xmm3
jbe    1e41 <prediction+0xd41>
mov    0x70(%rsp),%rax
cmpl   $0x0,(%rax,%r11,4)
jle    1e41 <prediction+0xd41>
movsd  %xmm3,0x8(%rdi)
mov    0x68(%rsp),%rax
addsd  (%rax,%r11,8),%xmm2
movsd  %xmm2,0x0(%r13,%r11,8)
cmpl   $0x0,-0x68(%rsp)
je     1dc0 <prediction+0xcc0>
mov    $0x1,%eax
mov    %r9,%rdx
mov    %r15,%rcx
jmp    1e96 <prediction+0xd96>
nopl   0x0(%rax,%rax,1)
mov    0x68(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm2
mov    %rcx,%rsi
movsd  %xmm2,0x0(%r13,%rsi,8)
add    $0x1,%rax
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
je     1dc0 <prediction+0xcc0>
test   %ebp,%ebp
jne    1e70 <prediction+0xd70>
movsd  (%r8),%xmm2
mulsd  (%r14,%rcx,8),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd (%rdi),%xmm3
jbe    1ec2 <prediction+0xdc2>
mov    0x70(%rsp),%rsi
cmpl   $0x0,(%rsi,%rcx,4)
jle    1ec2 <prediction+0xdc2>
movsd  %xmm3,(%rdi)
lea    (%rax,%r11,1),%rsi
mov    0x68(%rsp),%rbx
addsd  (%rbx,%rcx,8),%xmm2
jmp    1e7d <prediction+0xd7d>
test   %ebx,%ebx
mov    -0x60(%rsp),%rbp
jle    1f5e <prediction+0xe5e>
mov    0x60(%rsp),%rax
mov    (%rax),%eax
shl    $0x2,%rbp
xor    %ecx,%ecx
movapd 0x10c(%rip),%xmm0
movsd  0x114(%rip),%xmm1
jmp    1f13 <prediction+0xe13>
xchg   %ax,%ax
addsd  (%rdx,%rcx,2),%xmm2
movsd  %xmm2,(%rdx,%rcx,2)
add    %rbp,%rcx
add    $0xffffffffffffffff,%rbx
je     1f5e <prediction+0xe5e>
test   %eax,%eax
jne    1f0a <prediction+0xe0a>
movsd  (%r8),%xmm2
mulsd  (%r14,%rcx,2),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
ucomisd %xmm1,%xmm3
jbe    1f40 <prediction+0xe40>
mulsd  %xmm1,%xmm2
divsd  %xmm3,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
mov    0x50(%rsp),%rdx
mov    0x70(%rsp),%rsi
ucomisd 0x8(%rdi),%xmm3
jbe    1f00 <prediction+0xe00>
cmpl   $0x0,(%rsi,%rcx,1)
jle    1f00 <prediction+0xe00>
movsd  %xmm3,0x8(%rdi)
jmp    1f00 <prediction+0xe00>
mov    0x60(%rsp),%rax
movl   $0x0,(%rax)
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) {
%16 = alloca double*
%17 = alloca i32*
%18 = alloca double*
%19 = alloca double*
%20 = alloca double*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca double*
%29 = alloca i32*
%30 = alloca i32*
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca double
%35 = alloca double
%36 = alloca double
store double* %0, double** %16
store i32* %1, i32** %17
store double* %2, double** %18
store double* %3, double** %19
store double* %4, double** %20
store i32* %5, i32** %21
store i32* %6, i32** %22
store double* %7, double** %23
store double* %8, double** %24
store double* %9, double** %25
store i32* %10, i32** %26
store i32* %11, i32** %27
store double* %12, double** %28
store i32* %13, i32** %29
store i32* %14, i32** %30
%37 = load i32*, i32** %30
%38 = getelementptr inbounds i32, i32* %37, i64 1
%39 = load i32, i32* %38
%40 = add nsw i32 %39, 1
store i32 %40, i32* %33
%41 = load double*, double** %16
%42 = getelementptr inbounds double, double* %41, i64 0
store double 0.000000e+00, double* %42
%43 = load double*, double** %16
%44 = getelementptr inbounds double, double* %43, i64 1
store double 0.000000e+00, double* %44
%45 = load i32*, i32** %17
%46 = load i32, i32* %45
%47 = icmp eq i32 %46, 4
br i1 %47, label %48, label %452
48: ; preds = %15
%49 = load double*, double** %18
%50 = load double, double* %49
%51 = call double @llvm.fmuladd.f64(double -2.000000e+00, double %50, double 1.000000e+00)
%52 = fmul double 5.000000e-01, %51
%53 = load double*, double** %20
%54 = load double, double* %53
%55 = fmul double %52, %54
%56 = load double*, double** %20
%57 = load double, double* %56
%58 = fmul double %55, %57
store double %58, double* %35
%59 = load double*, double** %19
%60 = load double, double* %59
%61 = fsub double 1.000000e+00, %60
%62 = load double*, double** %20
%63 = load double, double* %62
%64 = fmul double %61, %63
store double %64, double* %36
%65 = load i32*, i32** %21
%66 = load i32, i32* %65
%67 = icmp slt i32 %66, 2
br i1 %67, label %68, label %189
68: ; preds = %48
store i32 0, i32* %32
br label %69
69: ; preds = %185, %68
%70 = load i32, i32* %32
%71 = load i32*, i32** %22
%72 = load i32, i32* %71
%73 = icmp slt i32 %70, %72
br i1 %73, label %74, label %188
74: ; preds = %69
store i32 0, i32* %31
br label %75
75: ; preds = %181, %74
%76 = load i32, i32* %31
%77 = load i32, i32* %33
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %184
79: ; preds = %75
%80 = load double*, double** %20
%81 = load double, double* %80
%82 = load double*, double** %23
%83 = load i32, i32* %33
%84 = load i32, i32* %32
%85 = mul nsw i32 %83, %84
%86 = load i32, i32* %31
%87 = add nsw i32 %85, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %82, i64 %88
%90 = load double, double* %89
%91 = load double, double* %35
%92 = load double*, double** %24
%93 = load i32, i32* %33
%94 = load i32, i32* %32
%95 = mul nsw i32 %93, %94
%96 = load i32, i32* %31
%97 = add nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds double, double* %92, i64 %98
%100 = load double, double* %99
%101 = fmul double %91, %100
%102 = call double @llvm.fmuladd.f64(double %81, double %90, double %101)
store double %102, double* %34
%103 = load double, double* %34
%104 = call double @llvm.fabs.f64(double %103)
%105 = load double*, double** %16
%106 = getelementptr inbounds double, double* %105, i64 0
%107 = load double, double* %106
%108 = fcmp ogt double %104, %107
br i1 %108, label %109, label %125
109: ; preds = %79
%110 = load i32*, i32** %29
%111 = load i32, i32* %33
%112 = load i32, i32* %32
%113 = mul nsw i32 %111, %112
%114 = load i32, i32* %31
%115 = add nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %110, i64 %116
%118 = load i32, i32* %117
%119 = icmp sgt i32 %118, 0
br i1 %119, label %120, label %125
120: ; preds = %109
%121 = load double, double* %34
%122 = call double @llvm.fabs.f64(double %121)
%123 = load double*, double** %16
%124 = getelementptr inbounds double, double* %123, i64 0
store double %122, double* %124
br label %125
125: ; preds = %120, %109, %79
%126 = load double*, double** %28
%127 = load i32, i32* %33
%128 = load i32, i32* %32
%129 = mul nsw i32 %127, %128
%130 = load i32, i32* %31
%131 = add nsw i32 %129, %130
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double, double* %126, i64 %132
%134 = load double, double* %133
%135 = load double, double* %34
%136 = fadd double %134, %135
%137 = load double*, double** %25
%138 = load i32, i32* %33
%139 = load i32, i32* %32
%140 = mul nsw i32 %138, %139
%141 = load i32, i32* %31
%142 = add nsw i32 %140, %141
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %137, i64 %143
store double %136, double* %144
%145 = load double*, double** %23
%146 = load i32, i32* %33
%147 = load i32, i32* %32
%148 = mul nsw i32 %146, %147
%149 = load i32, i32* %31
%150 = add nsw i32 %148, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %145, i64 %151
%153 = load double, double* %152
%154 = load double, double* %36
%155 = load double*, double** %24
%156 = load i32, i32* %33
%157 = load i32, i32* %32
%158 = mul nsw i32 %156, %157
%159 = load i32, i32* %31
%160 = add nsw i32 %158, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %155, i64 %161
%163 = load double, double* %162
%164 = call double @llvm.fmuladd.f64(double %154, double %163, double %153)
%165 = load double*, double** %23
%166 = load i32, i32* %33
%167 = load i32, i32* %32
%168 = mul nsw i32 %166, %167
%169 = load i32, i32* %31
%170 = add nsw i32 %168, %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %165, i64 %171
store double %164, double* %172
%173 = load double*, double** %24
%174 = load i32, i32* %33
%175 = load i32, i32* %32
%176 = mul nsw i32 %174, %175
%177 = load i32, i32* %31
%178 = add nsw i32 %176, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %173, i64 %179
store double 0.000000e+00, double* %180
br label %181
181: ; preds = %125
%182 = load i32, i32* %31
%183 = add nsw i32 %182, 1
store i32 %183, i32* %31
br label %75
184: ; preds = %75
br label %185
185: ; preds = %184
%186 = load i32, i32* %32
%187 = add nsw i32 %186, 1
store i32 %187, i32* %32
br label %69
188: ; preds = %69
br label %451
189: ; preds = %48
%190 = load i32*, i32** %21
%191 = load i32, i32* %190
%192 = icmp eq i32 %191, 2
br i1 %192, label %193, label %290
193: ; preds = %189
store i32 0, i32* %32
br label %194
194: ; preds = %226, %193
%195 = load i32, i32* %32
%196 = load i32*, i32** %22
%197 = load i32, i32* %196
%198 = icmp slt i32 %195, %197
br i1 %198, label %199, label %229
199: ; preds = %194
store i32 0, i32* %31
br label %200
200: ; preds = %222, %199
%201 = load i32, i32* %31
%202 = load i32, i32* %33
%203 = icmp slt i32 %201, %202
br i1 %203, label %204, label %225
204: ; preds = %200
%205 = load double*, double** %28
%206 = load i32, i32* %33
%207 = load i32, i32* %32
%208 = mul nsw i32 %206, %207
%209 = load i32, i32* %31
%210 = add nsw i32 %208, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %205, i64 %211
%213 = load double, double* %212
%214 = load double*, double** %25
%215 = load i32, i32* %33
%216 = load i32, i32* %32
%217 = mul nsw i32 %215, %216
%218 = load i32, i32* %31
%219 = add nsw i32 %217, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %214, i64 %220
store double %213, double* %221
br label %222
222: ; preds = %204
%223 = load i32, i32* %31
%224 = add nsw i32 %223, 1
store i32 %224, i32* %31
br label %200
225: ; preds = %200
br label %226
226: ; preds = %225
%227 = load i32, i32* %32
%228 = add nsw i32 %227, 1
store i32 %228, i32* %32
br label %194
229: ; preds = %194
store i32 0, i32* %32
br label %230
230: ; preds = %286, %229
%231 = load i32, i32* %32
%232 = load i32*, i32** %22
%233 = load i32, i32* %232
%234 = icmp slt i32 %231, %233
br i1 %234, label %235, label %289
235: ; preds = %230
%236 = load double*, double** %20
%237 = load double, double* %236
%238 = load double*, double** %23
%239 = load i32, i32* %33
%240 = load i32, i32* %32
%241 = mul nsw i32 %239, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %238, i64 %242
%244 = load double, double* %243
%245 = fmul double %237, %244
store double %245, double* %34
%246 = load double, double* %34
%247 = call double @llvm.fabs.f64(double %246)
%248 = fcmp ogt double %247, 1.000000e+02
br i1 %248, label %249, label %255
249: ; preds = %235
%250 = load double, double* %34
%251 = fmul double 1.000000e+02, %250
%252 = load double, double* %34
%253 = call double @llvm.fabs.f64(double %252)
%254 = fdiv double %251, %253
store double %254, double* %34
br label %255
255: ; preds = %249, %235
%256 = load double, double* %34
%257 = call double @llvm.fabs.f64(double %256)
%258 = load double*, double** %16
%259 = getelementptr inbounds double, double* %258, i64 1
%260 = load double, double* %259
%261 = fcmp ogt double %257, %260
br i1 %261, label %262, label %276
262: ; preds = %255
%263 = load i32*, i32** %29
%264 = load i32, i32* %33
%265 = load i32, i32* %32
%266 = mul nsw i32 %264, %265
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %263, i64 %267
%269 = load i32, i32* %268
%270 = icmp sgt i32 %269, 0
br i1 %270, label %271, label %276
271: ; preds = %262
%272 = load double, double* %34
%273 = call double @llvm.fabs.f64(double %272)
%274 = load double*, double** %16
%275 = getelementptr inbounds double, double* %274, i64 1
store double %273, double* %275
br label %276
276: ; preds = %271, %262, %255
%277 = load double, double* %34
%278 = load double*, double** %25
%279 = load i32, i32* %33
%280 = load i32, i32* %32
%281 = mul nsw i32 %279, %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds double, double* %278, i64 %282
%284 = load double, double* %283
%285 = fadd double %284, %277
store double %285, double* %283
br label %286
286: ; preds = %276
%287 = load i32, i32* %32
%288 = add nsw i32 %287, 1
store i32 %288, i32* %32
br label %230
289: ; preds = %230
br label %450
290: ; preds = %189
store i32 0, i32* %32
br label %291
291: ; preds = %446, %290
%292 = load i32, i32* %32
%293 = load i32*, i32** %22
%294 = load i32, i32* %293
%295 = icmp slt i32 %292, %294
br i1 %295, label %296, label %449
296: ; preds = %291
store i32 0, i32* %31
br label %297
297: ; preds = %442, %296
%298 = load i32, i32* %31
%299 = load i32, i32* %33
%300 = icmp slt i32 %298, %299
br i1 %300, label %301, label %445
301: ; preds = %297
%302 = load double*, double** %20
%303 = load double, double* %302
%304 = load double*, double** %23
%305 = load i32, i32* %33
%306 = load i32, i32* %32
%307 = mul nsw i32 %305, %306
%308 = load i32, i32* %31
%309 = add nsw i32 %307, %308
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds double, double* %304, i64 %310
%312 = load double, double* %311
%313 = load double, double* %35
%314 = load double*, double** %24
%315 = load i32, i32* %33
%316 = load i32, i32* %32
%317 = mul nsw i32 %315, %316
%318 = load i32, i32* %31
%319 = add nsw i32 %317, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %314, i64 %320
%322 = load double, double* %321
%323 = fmul double %313, %322
%324 = call double @llvm.fmuladd.f64(double %303, double %312, double %323)
store double %324, double* %34
%325 = load i32, i32* %31
%326 = icmp eq i32 %325, 0
br i1 %326, label %327, label %337
327: ; preds = %301
%328 = load double, double* %34
%329 = call double @llvm.fabs.f64(double %328)
%330 = fcmp ogt double %329, 1.000000e+02
br i1 %330, label %331, label %337
331: ; preds = %327
%332 = load double, double* %34
%333 = fmul double 1.000000e+02, %332
%334 = load double, double* %34
%335 = call double @llvm.fabs.f64(double %334)
%336 = fdiv double %333, %335
store double %336, double* %34
br label %337
337: ; preds = %331, %327, %301
%338 = load i32, i32* %31
%339 = icmp eq i32 %338, 0
br i1 %339, label %340, label %362
340: ; preds = %337
%341 = load double, double* %34
%342 = call double @llvm.fabs.f64(double %341)
%343 = load double*, double** %16
%344 = getelementptr inbounds double, double* %343, i64 1
%345 = load double, double* %344
%346 = fcmp ogt double %342, %345
br i1 %346, label %347, label %361
347: ; preds = %340
%348 = load i32*, i32** %29
%349 = load i32, i32* %33
%350 = load i32, i32* %32
%351 = mul nsw i32 %349, %350
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i32, i32* %348, i64 %352
%354 = load i32, i32* %353
%355 = icmp sgt i32 %354, 0
br i1 %355, label %356, label %361
356: ; preds = %347
%357 = load double, double* %34
%358 = call double @llvm.fabs.f64(double %357)
%359 = load double*, double** %16
%360 = getelementptr inbounds double, double* %359, i64 1
store double %358, double* %360
br label %361
361: ; preds = %356, %347, %340
br label %386
362: ; preds = %337
%363 = load double, double* %34
%364 = call double @llvm.fabs.f64(double %363)
%365 = load double*, double** %16
%366 = getelementptr inbounds double, double* %365, i64 0
%367 = load double, double* %366
%368 = fcmp ogt double %364, %367
br i1 %368, label %369, label %385
369: ; preds = %362
%370 = load i32*, i32** %29
%371 = load i32, i32* %33
%372 = load i32, i32* %32
%373 = mul nsw i32 %371, %372
%374 = load i32, i32* %31
%375 = add nsw i32 %373, %374
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %370, i64 %376
%378 = load i32, i32* %377
%379 = icmp sgt i32 %378, 0
br i1 %379, label %380, label %385
380: ; preds = %369
%381 = load double, double* %34
%382 = call double @llvm.fabs.f64(double %381)
%383 = load double*, double** %16
%384 = getelementptr inbounds double, double* %383, i64 0
store double %382, double* %384
br label %385
385: ; preds = %380, %369, %362
br label %386
386: ; preds = %385, %361
%387 = load double*, double** %28
%388 = load i32, i32* %33
%389 = load i32, i32* %32
%390 = mul nsw i32 %388, %389
%391 = load i32, i32* %31
%392 = add nsw i32 %390, %391
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %387, i64 %393
%395 = load double, double* %394
%396 = load double, double* %34
%397 = fadd double %395, %396
%398 = load double*, double** %25
%399 = load i32, i32* %33
%400 = load i32, i32* %32
%401 = mul nsw i32 %399, %400
%402 = load i32, i32* %31
%403 = add nsw i32 %401, %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %398, i64 %404
store double %397, double* %405
%406 = load double*, double** %23
%407 = load i32, i32* %33
%408 = load i32, i32* %32
%409 = mul nsw i32 %407, %408
%410 = load i32, i32* %31
%411 = add nsw i32 %409, %410
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds double, double* %406, i64 %412
%414 = load double, double* %413
%415 = load double, double* %36
%416 = load double*, double** %24
%417 = load i32, i32* %33
%418 = load i32, i32* %32
%419 = mul nsw i32 %417, %418
%420 = load i32, i32* %31
%421 = add nsw i32 %419, %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds double, double* %416, i64 %422
%424 = load double, double* %423
%425 = call double @llvm.fmuladd.f64(double %415, double %424, double %414)
%426 = load double*, double** %23
%427 = load i32, i32* %33
%428 = load i32, i32* %32
%429 = mul nsw i32 %427, %428
%430 = load i32, i32* %31
%431 = add nsw i32 %429, %430
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds double, double* %426, i64 %432
store double %425, double* %433
%434 = load double*, double** %24
%435 = load i32, i32* %33
%436 = load i32, i32* %32
%437 = mul nsw i32 %435, %436
%438 = load i32, i32* %31
%439 = add nsw i32 %437, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds double, double* %434, i64 %440
store double 0.000000e+00, double* %441
br label %442
442: ; preds = %386
%443 = load i32, i32* %31
%444 = add nsw i32 %443, 1
store i32 %444, i32* %31
br label %297
445: ; preds = %297
br label %446
446: ; preds = %445
%447 = load i32, i32* %32
%448 = add nsw i32 %447, 1
store i32 %448, i32* %32
br label %291
449: ; preds = %291
br label %450
450: ; preds = %449, %289
br label %451
451: ; preds = %450, %188
br label %841
452: ; preds = %15
%453 = load i32*, i32** %26
%454 = load i32, i32* %453
%455 = icmp sgt i32 %454, 1
br i1 %455, label %456, label %803
456: ; preds = %452
%457 = load i32*, i32** %21
%458 = load i32, i32* %457
%459 = icmp slt i32 %458, 2
br i1 %459, label %460, label %557
460: ; preds = %456
store i32 0, i32* %32
br label %461
461: ; preds = %553, %460
%462 = load i32, i32* %32
%463 = load i32*, i32** %22
%464 = load i32, i32* %463
%465 = icmp slt i32 %462, %464
br i1 %465, label %466, label %556
466: ; preds = %461
store i32 0, i32* %31
br label %467
467: ; preds = %549, %466
%468 = load i32, i32* %31
%469 = load i32, i32* %33
%470 = icmp slt i32 %468, %469
br i1 %470, label %471, label %552
471: ; preds = %467
%472 = load i32*, i32** %27
%473 = load i32, i32* %472
%474 = icmp eq i32 %473, 0
br i1 %474, label %475, label %530
475: ; preds = %471
%476 = load double*, double** %20
%477 = load double, double* %476
%478 = load double*, double** %23
%479 = load i32, i32* %33
%480 = load i32, i32* %32
%481 = mul nsw i32 %479, %480
%482 = load i32, i32* %31
%483 = add nsw i32 %481, %482
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %478, i64 %484
%486 = load double, double* %485
%487 = fmul double %477, %486
store double %487, double* %34
%488 = load double, double* %34
%489 = call double @llvm.fabs.f64(double %488)
%490 = load double*, double** %16
%491 = getelementptr inbounds double, double* %490, i64 0
%492 = load double, double* %491
%493 = fcmp ogt double %489, %492
br i1 %493, label %494, label %510
494: ; preds = %475
%495 = load i32*, i32** %29
%496 = load i32, i32* %33
%497 = load i32, i32* %32
%498 = mul nsw i32 %496, %497
%499 = load i32, i32* %31
%500 = add nsw i32 %498, %499
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds i32, i32* %495, i64 %501
%503 = load i32, i32* %502
%504 = icmp sgt i32 %503, 0
br i1 %504, label %505, label %510
505: ; preds = %494
%506 = load double, double* %34
%507 = call double @llvm.fabs.f64(double %506)
%508 = load double*, double** %16
%509 = getelementptr inbounds double, double* %508, i64 0
store double %507, double* %509
br label %510
510: ; preds = %505, %494, %475
%511 = load double*, double** %28
%512 = load i32, i32* %33
%513 = load i32, i32* %32
%514 = mul nsw i32 %512, %513
%515 = load i32, i32* %31
%516 = add nsw i32 %514, %515
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds double, double* %511, i64 %517
%519 = load double, double* %518
%520 = load double, double* %34
%521 = fadd double %519, %520
%522 = load double*, double** %25
%523 = load i32, i32* %33
%524 = load i32, i32* %32
%525 = mul nsw i32 %523, %524
%526 = load i32, i32* %31
%527 = add nsw i32 %525, %526
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds double, double* %522, i64 %528
store double %521, double* %529
br label %548
530: ; preds = %471
%531 = load double*, double** %28
%532 = load i32, i32* %33
%533 = load i32, i32* %32
%534 = mul nsw i32 %532, %533
%535 = load i32, i32* %31
%536 = add nsw i32 %534, %535
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds double, double* %531, i64 %537
%539 = load double, double* %538
%540 = load double*, double** %25
%541 = load i32, i32* %33
%542 = load i32, i32* %32
%543 = mul nsw i32 %541, %542
%544 = load i32, i32* %31
%545 = add nsw i32 %543, %544
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds double, double* %540, i64 %546
store double %539, double* %547
br label %548
548: ; preds = %530, %510
br label %549
549: ; preds = %548
%550 = load i32, i32* %31
%551 = add nsw i32 %550, 1
store i32 %551, i32* %31
br label %467
552: ; preds = %467
br label %553
553: ; preds = %552
%554 = load i32, i32* %32
%555 = add nsw i32 %554, 1
store i32 %555, i32* %32
br label %461
556: ; preds = %461
br label %802
557: ; preds = %456
%558 = load i32*, i32** %21
%559 = load i32, i32* %558
%560 = icmp eq i32 %559, 2
br i1 %560, label %561, label %663
561: ; preds = %557
store i32 0, i32* %32
br label %562
562: ; preds = %594, %561
%563 = load i32, i32* %32
%564 = load i32*, i32** %22
%565 = load i32, i32* %564
%566 = icmp slt i32 %563, %565
br i1 %566, label %567, label %597
567: ; preds = %562
store i32 0, i32* %31
br label %568
568: ; preds = %590, %567
%569 = load i32, i32* %31
%570 = load i32, i32* %33
%571 = icmp slt i32 %569, %570
br i1 %571, label %572, label %593
572: ; preds = %568
%573 = load double*, double** %28
%574 = load i32, i32* %33
%575 = load i32, i32* %32
%576 = mul nsw i32 %574, %575
%577 = load i32, i32* %31
%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 = load double*, double** %25
%583 = load i32, i32* %33
%584 = load i32, i32* %32
%585 = mul nsw i32 %583, %584
%586 = load i32, i32* %31
%587 = add nsw i32 %585, %586
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds double, double* %582, i64 %588
store double %581, double* %589
br label %590
590: ; preds = %572
%591 = load i32, i32* %31
%592 = add nsw i32 %591, 1
store i32 %592, i32* %31
br label %568
593: ; preds = %568
br label %594
594: ; preds = %593
%595 = load i32, i32* %32
%596 = add nsw i32 %595, 1
store i32 %596, i32* %32
br label %562
597: ; preds = %562
store i32 0, i32* %32
br label %598
598: ; preds = %659, %597
%599 = load i32, i32* %32
%600 = load i32*, i32** %22
%601 = load i32, i32* %600
%602 = icmp slt i32 %599, %601
br i1 %602, label %603, label %662
603: ; preds = %598
%604 = load i32*, i32** %27
%605 = load i32, i32* %604
%606 = icmp eq i32 %605, 0
br i1 %606, label %607, label %658
607: ; preds = %603
%608 = load double*, double** %20
%609 = load double, double* %608
%610 = load double*, double** %23
%611 = load i32, i32* %33
%612 = load i32, i32* %32
%613 = mul nsw i32 %611, %612
%614 = sext i32 %613 to i64
%615 = getelementptr inbounds double, double* %610, i64 %614
%616 = load double, double* %615
%617 = fmul double %609, %616
store double %617, double* %34
%618 = load double, double* %34
%619 = call double @llvm.fabs.f64(double %618)
%620 = fcmp ogt double %619, 1.000000e+02
br i1 %620, label %621, label %627
621: ; preds = %607
%622 = load double, double* %34
%623 = fmul double 1.000000e+02, %622
%624 = load double, double* %34
%625 = call double @llvm.fabs.f64(double %624)
%626 = fdiv double %623, %625
store double %626, double* %34
br label %627
627: ; preds = %621, %607
%628 = load double, double* %34
%629 = call double @llvm.fabs.f64(double %628)
%630 = load double*, double** %16
%631 = getelementptr inbounds double, double* %630, i64 1
%632 = load double, double* %631
%633 = fcmp ogt double %629, %632
br i1 %633, label %634, label %648
634: ; preds = %627
%635 = load i32*, i32** %29
%636 = load i32, i32* %33
%637 = load i32, i32* %32
%638 = mul nsw i32 %636, %637
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds i32, i32* %635, i64 %639
%641 = load i32, i32* %640
%642 = icmp sgt i32 %641, 0
br i1 %642, label %643, label %648
643: ; preds = %634
%644 = load double, double* %34
%645 = call double @llvm.fabs.f64(double %644)
%646 = load double*, double** %16
%647 = getelementptr inbounds double, double* %646, i64 1
store double %645, double* %647
br label %648
648: ; preds = %643, %634, %627
%649 = load double, double* %34
%650 = load double*, double** %25
%651 = load i32, i32* %33
%652 = load i32, i32* %32
%653 = mul nsw i32 %651, %652
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %650, i64 %654
%656 = load double, double* %655
%657 = fadd double %656, %649
store double %657, double* %655
br label %658
658: ; preds = %648, %603
br label %659
659: ; preds = %658
%660 = load i32, i32* %32
%661 = add nsw i32 %660, 1
store i32 %661, i32* %32
br label %598
662: ; preds = %598
br label %801
663: ; preds = %557
store i32 0, i32* %32
br label %664
664: ; preds = %797, %663
%665 = load i32, i32* %32
%666 = load i32*, i32** %22
%667 = load i32, i32* %666
%668 = icmp slt i32 %665, %667
br i1 %668, label %669, label %800
669: ; preds = %664
store i32 0, i32* %31
br label %670
670: ; preds = %793, %669
%671 = load i32, i32* %31
%672 = load i32, i32* %33
%673 = icmp slt i32 %671, %672
br i1 %673, label %674, label %796
674: ; preds = %670
%675 = load i32*, i32** %27
%676 = load i32, i32* %675
%677 = icmp eq i32 %676, 0
br i1 %677, label %678, label %774
678: ; preds = %674
%679 = load double*, double** %20
%680 = load double, double* %679
%681 = load double*, double** %23
%682 = load i32, i32* %33
%683 = load i32, i32* %32
%684 = mul nsw i32 %682, %683
%685 = load i32, i32* %31
%686 = add nsw i32 %684, %685
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds double, double* %681, i64 %687
%689 = load double, double* %688
%690 = fmul double %680, %689
store double %690, double* %34
%691 = load i32, i32* %31
%692 = icmp eq i32 %691, 0
br i1 %692, label %693, label %703
693: ; preds = %678
%694 = load double, double* %34
%695 = call double @llvm.fabs.f64(double %694)
%696 = fcmp ogt double %695, 1.000000e+02
br i1 %696, label %697, label %703
697: ; preds = %693
%698 = load double, double* %34
%699 = fmul double 1.000000e+02, %698
%700 = load double, double* %34
%701 = call double @llvm.fabs.f64(double %700)
%702 = fdiv double %699, %701
store double %702, double* %34
br label %703
703: ; preds = %697, %693, %678
%704 = load i32, i32* %31
%705 = icmp eq i32 %704, 0
br i1 %705, label %706, label %730
706: ; preds = %703
%707 = load double, double* %34
%708 = call double @llvm.fabs.f64(double %707)
%709 = load double*, double** %16
%710 = getelementptr inbounds double, double* %709, i64 1
%711 = load double, double* %710
%712 = fcmp ogt double %708, %711
br i1 %712, label %713, label %729
713: ; preds = %706
%714 = load i32*, i32** %29
%715 = load i32, i32* %33
%716 = load i32, i32* %32
%717 = mul nsw i32 %715, %716
%718 = load i32, i32* %31
%719 = add nsw i32 %717, %718
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds i32, i32* %714, i64 %720
%722 = load i32, i32* %721
%723 = icmp sgt i32 %722, 0
br i1 %723, label %724, label %729
724: ; preds = %713
%725 = load double, double* %34
%726 = call double @llvm.fabs.f64(double %725)
%727 = load double*, double** %16
%728 = getelementptr inbounds double, double* %727, i64 1
store double %726, double* %728
br label %729
729: ; preds = %724, %713, %706
br label %754
730: ; preds = %703
%731 = load double, double* %34
%732 = call double @llvm.fabs.f64(double %731)
%733 = load double*, double** %16
%734 = getelementptr inbounds double, double* %733, i64 0
%735 = load double, double* %734
%736 = fcmp ogt double %732, %735
br i1 %736, label %737, label %753
737: ; preds = %730
%738 = load i32*, i32** %29
%739 = load i32, i32* %33
%740 = load i32, i32* %32
%741 = mul nsw i32 %739, %740
%742 = load i32, i32* %31
%743 = add nsw i32 %741, %742
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds i32, i32* %738, i64 %744
%746 = load i32, i32* %745
%747 = icmp sgt i32 %746, 0
br i1 %747, label %748, label %753
748: ; preds = %737
%749 = load double, double* %34
%750 = call double @llvm.fabs.f64(double %749)
%751 = load double*, double** %16
%752 = getelementptr inbounds double, double* %751, i64 0
store double %750, double* %752
br label %753
753: ; preds = %748, %737, %730
br label %754
754: ; preds = %753, %729
%755 = load double*, double** %28
%756 = load i32, i32* %33
%757 = load i32, i32* %32
%758 = mul nsw i32 %756, %757
%759 = load i32, i32* %31
%760 = add nsw i32 %758, %759
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds double, double* %755, i64 %761
%763 = load double, double* %762
%764 = load double, double* %34
%765 = fadd double %763, %764
%766 = load double*, double** %25
%767 = load i32, i32* %33
%768 = load i32, i32* %32
%769 = mul nsw i32 %767, %768
%770 = load i32, i32* %31
%771 = add nsw i32 %769, %770
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds double, double* %766, i64 %772
store double %765, double* %773
br label %792
774: ; preds = %674
%775 = load double*, double** %28
%776 = load i32, i32* %33
%777 = load i32, i32* %32
%778 = mul nsw i32 %776, %777
%779 = load i32, i32* %31
%780 = add nsw i32 %778, %779
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double, double* %775, i64 %781
%783 = load double, double* %782
%784 = load double*, double** %25
%785 = load i32, i32* %33
%786 = load i32, i32* %32
%787 = mul nsw i32 %785, %786
%788 = load i32, i32* %31
%789 = add nsw i32 %787, %788
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds double, double* %784, i64 %790
store double %783, double* %791
br label %792
792: ; preds = %774, %754
br label %793
793: ; preds = %792
%794 = load i32, i32* %31
%795 = add nsw i32 %794, 1
store i32 %795, i32* %31
br label %670
796: ; preds = %670
br label %797
797: ; preds = %796
%798 = load i32, i32* %32
%799 = add nsw i32 %798, 1
store i32 %799, i32* %32
br label %664
800: ; preds = %664
br label %801
801: ; preds = %800, %662
br label %802
802: ; preds = %801, %556
br label %840
803: ; preds = %452
store i32 0, i32* %32
br label %804
804: ; preds = %836, %803
%805 = load i32, i32* %32
%806 = load i32*, i32** %22
%807 = load i32, i32* %806
%808 = icmp slt i32 %805, %807
br i1 %808, label %809, label %839
809: ; preds = %804
store i32 0, i32* %31
br label %810
810: ; preds = %832, %809
%811 = load i32, i32* %31
%812 = load i32, i32* %33
%813 = icmp slt i32 %811, %812
br i1 %813, label %814, label %835
814: ; preds = %810
%815 = load double*, double** %28
%816 = load i32, i32* %33
%817 = load i32, i32* %32
%818 = mul nsw i32 %816, %817
%819 = load i32, i32* %31
%820 = add nsw i32 %818, %819
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double, double* %815, i64 %821
%823 = load double, double* %822
%824 = load double*, double** %25
%825 = load i32, i32* %33
%826 = load i32, i32* %32
%827 = mul nsw i32 %825, %826
%828 = load i32, i32* %31
%829 = add nsw i32 %827, %828
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds double, double* %824, i64 %830
store double %823, double* %831
br label %832
832: ; preds = %814
%833 = load i32, i32* %31
%834 = add nsw i32 %833, 1
store i32 %834, i32* %31
br label %810
835: ; preds = %810
br label %836
836: ; preds = %835
%837 = load i32, i32* %32
%838 = add nsw i32 %837, 1
store i32 %838, i32* %32
br label %804
839: ; preds = %804
br label %840
840: ; preds = %839, %802
br label %841
841: ; preds = %840, %451
%842 = load i32*, i32** %27
store i32 0, i32* %842
ret void
}

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