#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 */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, double);
int /*<<< orphan*/ free(double *);
double sqrt(double);
int /*<<< orphan*/ stderr;
int compute_solution(const int max_iters, int nintci, int nintcf, int nextcf,
                     int **lcc, double *bp, double *bs, double *bw, double *bl,
                     double *bn, double *be, double *bh, double *cnorm,
                     double *var, double *su, double *cgup,
                     double *residual_ratio) {
  int iter = 1;
  int if1 = 0;
  int if2 = 0;
  int nor = 1;
  int nor1 = nor - 1;
  int nc = 0;
  int nomax = 3;
  double resref = 0.0;
  double *resvec = (double *)calloc((nintcf + 1), sizeof(double));
  for (nc = nintci; nc <= nintcf; nc++) {
    resvec[nc] = su[nc];
    resref = resref + resvec[nc] * resvec[nc];
  }
  resref = sqrt(resref);
  if (resref < 1.0e-15) {
    fprintf(stderr, "Residue sum less than 1.e-15 - %lf\n", resref);
    return 0;
  }
  double *direc1 = (double *)calloc((nextcf + 1), sizeof(double));
  double *direc2 = (double *)calloc((nextcf + 1), sizeof(double));
  double *adxor1 = (double *)calloc((nintcf + 1), sizeof(double));
  double *adxor2 = (double *)calloc((nintcf + 1), sizeof(double));
  double *dxor1 = (double *)calloc((nintcf + 1), sizeof(double));
  double *dxor2 = (double *)calloc((nintcf + 1), sizeof(double));
  while (iter < max_iters) {
    for (nc = nintci; nc <= nintcf; nc++) {
      direc1[nc] = direc1[nc] + resvec[nc] * cgup[nc];
    }
    for (nc = nintci; nc <= nintcf; nc++) {
      direc2[nc] = bp[nc] * direc1[nc] - bs[nc] * direc1[lcc[nc][0]] -
                   be[nc] * direc1[lcc[nc][1]] - bn[nc] * direc1[lcc[nc][2]] -
                   bw[nc] * direc1[lcc[nc][3]] - bl[nc] * direc1[lcc[nc][4]] -
                   bh[nc] * direc1[lcc[nc][5]];
    }
    double oc1, oc2, occ;
    if (nor1 == 1) {
      oc1 = 0;
      occ = 0;
      for (nc = nintci; nc <= nintcf; nc++) {
        occ = occ + direc2[nc] * adxor1[nc];
      }
      oc1 = occ / cnorm[1];
      for (nc = nintci; nc <= nintcf; nc++) {
        direc2[nc] = direc2[nc] - oc1 * adxor1[nc];
        direc1[nc] = direc1[nc] - oc1 * dxor1[nc];
      }
      if1++;
    } else {
      if (nor1 == 2) {
        oc1 = 0;
        occ = 0;
        for (nc = nintci; nc <= nintcf; nc++) {
          occ = occ + direc2[nc] * adxor1[nc];
        }
        oc1 = occ / cnorm[1];
        oc2 = 0;
        occ = 0;
        for (nc = nintci; nc <= nintcf; nc++) {
          occ = occ + direc2[nc] * adxor2[nc];
        }
        oc2 = occ / cnorm[2];
        for (nc = nintci; nc <= nintcf; nc++) {
          direc1[nc] = direc1[nc] - oc1 * dxor1[nc] - oc2 * dxor2[nc];
          direc2[nc] = direc2[nc] - oc1 * adxor1[nc] - oc2 * adxor2[nc];
        }
        if2++;
      }
    }
    cnorm[nor] = 0;
    double omega = 0;
    for (nc = nintci; nc <= nintcf; nc++) {
      cnorm[nor] = cnorm[nor] + direc2[nc] * direc2[nc];
      omega = omega + resvec[nc] * direc2[nc];
    }
    omega = omega / cnorm[nor];
    double res_updated = 0.0;
    for (nc = nintci; nc <= nintcf; nc++) {
      resvec[nc] = resvec[nc] - omega * direc2[nc];
      res_updated = res_updated + resvec[nc] * resvec[nc];
      var[nc] = var[nc] + omega * direc1[nc];
    }
    res_updated = sqrt(res_updated);
    *residual_ratio = res_updated / resref;
    if (*residual_ratio <= 1.0e-10)
      break;
    iter++;
    if (nor == nomax) {
      nor = 1;
    } else {
      if (nor == 1) {
        for (nc = nintci; nc <= nintcf; nc++) {
          dxor1[nc] = direc1[nc];
          adxor1[nc] = direc2[nc];
        }
      } else {
        if (nor == 2) {
          for (nc = nintci; nc <= nintcf; nc++) {
            dxor2[nc] = direc1[nc];
            adxor2[nc] = direc2[nc];
          }
        }
      }
      nor++;
    }
    nor1 = nor - 1;
  }
  free(direc1);
  free(direc2);
  free(adxor1);
  free(adxor2);
  free(dxor1);
  free(dxor2);
  free(resvec);
  return iter;
}


x86 assembly (clang, -O0):
<compute_solution>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x3,-0x44(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1240 <compute_solution+0x100>
mov    0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11e0 <compute_solution+0xa0>
movsd  -0x50(%rbp),%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  0xda9(%rip),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1288 <compute_solution+0x148>
mov    0x2d77(%rip),%rax
mov    (%rax),%edi
movsd  -0x50(%rbp),%xmm0
lea    0xd99(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1c20 <compute_solution+0xae0>
mov    -0x14(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x10(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x10(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1bd8 <compute_solution+0xa98>
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     136b <compute_solution+0x22b>
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1315 <compute_solution+0x1d5>
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     154f <compute_solution+0x40f>
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq (%rcx),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq 0x4(%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq 0x8(%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq 0xc(%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq 0x10(%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq 0x14(%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1371 <compute_solution+0x231>
cmpl   $0x1,-0x3c(%rbp)
jne    16a4 <compute_solution+0x564>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     15c1 <compute_solution+0x481>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1575 <compute_solution+0x435>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1696 <compute_solution+0x556>
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    15e0 <compute_solution+0x4a0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18e5 <compute_solution+0x7a5>
cmpl   $0x2,-0x3c(%rbp)
jne    18e0 <compute_solution+0x7a0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1716 <compute_solution+0x5d6>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    16ca <compute_solution+0x58a>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
divsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1797 <compute_solution+0x657>
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    174b <compute_solution+0x60b>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
divsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     18d7 <compute_solution+0x797>
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x78(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17b6 <compute_solution+0x676>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18e5 <compute_solution+0x7a5>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     198e <compute_solution+0x84e>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1906 <compute_solution+0x7c6>
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1a8d <compute_solution+0x94d>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm1
ff
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    19bc <compute_solution+0x87c>
movsd  -0xb0(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
divsd  -0x50(%rbp),%xmm0
mov    0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x60(%rbp),%rax
movsd  0x545(%rip),%xmm0
ucomisd (%rax),%xmm0
jb     1ad2 <compute_solution+0x992>
jmp    1bd8 <compute_solution+0xa98>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x44(%rbp),%eax
jne    1af3 <compute_solution+0x9b3>
movl   $0x1,-0x38(%rbp)
jmp    1bca <compute_solution+0xa8a>
cmpl   $0x1,-0x38(%rbp)
jne    1b56 <compute_solution+0xa16>
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1b51 <compute_solution+0xa11>
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b03 <compute_solution+0x9c3>
jmp    1bc1 <compute_solution+0xa81>
cmpl   $0x2,-0x38(%rbp)
jne    1bbc <compute_solution+0xa7c>
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1bb7 <compute_solution+0xa77>
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b66 <compute_solution+0xa26>
jmp    1bbc <compute_solution+0xa7c>
jmp    1bc1 <compute_solution+0xa81>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1303 <compute_solution+0x1c3>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_solution>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,%r13
mov    %r8,%r15
mov    %ecx,%r14d
mov    %edx,%ebx
mov    %esi,%ebp
mov    %edi,0x4c(%rsp)
lea    0x1(%rbx),%edi
mov    %rdi,0x18(%rsp)
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x40(%rsp)
xorpd  %xmm1,%xmm1
mov    %ebx,%edi
xorpd  %xmm0,%xmm0
mov    %ebp,0x4(%rsp)
sub    %ebp,%edi
jl     1237 <compute_solution+0xf7>
mov    0x200(%rsp),%rax
movslq 0x4(%rsp),%rcx
lea    0x1(%rdi),%edx
xorpd  %xmm0,%xmm0
and    $0x3,%edx
je     11cc <compute_solution+0x8c>
mov    0x40(%rsp),%rbp
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    11b0 <compute_solution+0x70>
cmp    $0x3,%edi
jb     1237 <compute_solution+0xf7>
mov    0x18(%rsp),%edx
mov    0x40(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  0x10(%rax,%rcx,8),%xmm2
movsd  %xmm2,0x10(%rbp,%rcx,8)
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movsd  0x18(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbp,%rcx,8)
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
add    $0x4,%rcx
cmp    %ecx,%edx
jne    11e0 <compute_solution+0xa0>
ucomisd %xmm1,%xmm0
mov    %rdi,0x28(%rsp)
mov    %rbx,0x30(%rsp)
jb     124d <compute_solution+0x10d>
sqrtsd %xmm0,%xmm0
jmp    1252 <compute_solution+0x112>
call   1060 <sqrt@plt>
movsd  0x1da6(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    127c <compute_solution+0x13c>
mov    0x3d79(%rip),%rax
mov    (%rax),%edi
lea    0x1db0(%rip),%rsi
call   1050 <fprintf@plt>
xor    %eax,%eax
jmp    24a4 <compute_solution+0x1364>
mov    %r15,0x88(%rsp)
movsd  %xmm0,0x100(%rsp)
add    $0x1,%r14d
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%rbp
mov    %r14d,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r15
mov    0x18(%rsp),%rbx
mov    %ebx,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebx,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r12
mov    %ebx,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,0x38(%rsp)
mov    %ebx,%edi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    $0x1,%edx
cmpl   $0x2,0x4c(%rsp)
jl     2462 <compute_solution+0x1322>
mov    0x4(%rsp),%r9d
mov    %r14,0xb0(%rsp)
movslq %r9d,%r14
mov    0x28(%rsp),%rcx
lea    (%r14,%rcx,1),%rsi
lea    0x0(%rbp,%r14,8),%rax
mov    %rax,0x98(%rsp)
mov    %rax,%rdi
lea    0x8(%rbp,%rsi,8),%r10
add    $0x1,%rcx
mov    0x40(%rsp),%rax
lea    (%rax,%rsi,8),%r11
add    $0x8,%r11
mov    %ebx,%r8d
sub    %r9d,%r8d
mov    %r8,0x90(%rsp)
movabs $0x1fffffffc,%rdx
or     $0x2,%rdx
and    %rcx,%rdx
mov    %rdx,0xd8(%rsp)
lea    -0x2(%rdx),%rbx
mov    %rbx,0x130(%rsp)
shr    %rbx
add    $0x1,%rbx
mov    %rcx,0x78(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x50(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0xe8(%rsp)
mov    %r12,0x60(%rsp)
mov    %r13,0x68(%rsp)
mov    %rcx,%r13
shr    $0x2,%r13
add    $0x1,%r13
mov    %rdi,%r9
cmp    %r11,%rdi
lea    (%rax,%r14,8),%rcx
setb   %al
mov    %rcx,0xf0(%rsp)
mov    %r10,%r12
cmp    %r10,%rcx
setb   %dl
and    %al,%dl
mov    0x208(%rsp),%rcx
lea    (%rcx,%rsi,8),%rax
add    $0x8,%rax
cmp    %rax,%rdi
setb   %al
lea    (%rcx,%r14,8),%rcx
mov    %rcx,0x140(%rsp)
cmp    %r10,%rcx
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0x17(%rsp)
mov    %r8d,%eax
and    $0x3,%eax
mov    %eax,0x48(%rsp)
lea    (%r15,%r14,8),%rax
mov    %rax,0xb8(%rsp)
cmp    %r10,%rax
mov    %r10,0x80(%rsp)
setb   %r10b
mov    %rsi,%rcx
lea    (%r15,%rsi,8),%rdx
add    $0x8,%rdx
mov    %rdx,0xc0(%rsp)
cmp    %rdx,%rdi
setb   %sil
and    %r10b,%sil
mov    0x20(%rsp),%r10
lea    (%r10,%rcx,8),%r8
add    $0x8,%r8
mov    %rcx,%r11
mov    %rcx,0x8(%rsp)
cmp    %r8,%rax
mov    %r8,0x58(%rsp)
setb   %cl
lea    (%r10,%r14,8),%rdi
cmp    %rdx,%rdi
setb   %r10b
and    %cl,%r10b
or     %r10b,%sil
mov    0x38(%rsp),%rcx
lea    (%rcx,%r11,8),%r11
add    $0x8,%r11
cmp    %r11,%rax
setb   0x70(%rsp)
mov    0x38(%rsp),%rcx
lea    (%rcx,%r14,8),%rax
cmp    %rdx,%rax
setb   %cl
and    0x70(%rsp),%cl
cmp    %r8,%r9
setb   %r8b
cmp    %r12,%rdi
setb   %dl
and    %r8b,%dl
or     %cl,%dl
or     %dl,%sil
cmp    %r11,%r9
setb   %r8b
cmp    %r12,%rax
setb   %cl
and    %r8b,%cl
or     %cl,%sil
mov    %sil,0x14(%rsp)
mov    %rbx,%rsi
mov    %rbx,0x128(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0x118(%rsp)
mov    %rax,0xa0(%rsp)
cmp    0x58(%rsp),%rax
setb   %sil
mov    %rdi,0x70(%rsp)
cmp    %r11,%rdi
setb   %al
and    %sil,%al
or     %cl,%al
or     %dl,%al
or     %r10b,%al
mov    %al,0x16(%rsp)
mov    0xb0(%rsp),%rbx
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,8),%rcx
add    $0x8,%rcx
mov    0x60(%rsp),%r10
lea    0x8(%r10,%rax,8),%r11
mov    0xb8(%rsp),%r9
mov    %r13,%rax
mov    %r13,0xe0(%rsp)
and    $0xfffffffffffffffe,%r13
mov    %r13,0xd0(%rsp)
lea    (%rbx,%r14,8),%r13
cmp    %r11,%r13
setb   %dl
lea    (%r10,%r14,8),%rdi
cmp    %rcx,%rdi
setb   %al
and    %dl,%al
mov    0x80(%rsp),%rsi
cmp    %rsi,%r13
setb   %r8b
mov    0x98(%rsp),%rbx
cmp    %rcx,%rbx
setb   %dl
and    %r8b,%dl
or     %al,%dl
mov    0xc0(%rsp),%r12
cmp    %r12,%r13
setb   %al
cmp    %rcx,%r9
setb   %cl
and    %al,%cl
cmp    %rsi,%rdi
setb   %r8b
cmp    %r11,%rbx
setb   %al
and    %r8b,%al
or     %cl,%al
or     %dl,%al
mov    0x50(%rsp),%rcx
cmp    %r12,%rdi
setb   %r8b
cmp    %r11,%r9
setb   %dl
and    %r8b,%dl
or     %al,%dl
mov    %dl,0x15(%rsp)
mov    0x68(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x180(%rsp)
mov    0x1c0(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x178(%rsp)
mov    0x88(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x170(%rsp)
mov    0x1e0(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x168(%rsp)
mov    0x1d8(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x160(%rsp)
mov    0x1c8(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x158(%rsp)
mov    0x1d0(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x150(%rsp)
mov    0x1e8(%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x148(%rsp)
mov    0x1f8(%rsp),%rax
lea    (%rax,%r14,8),%r12
xorpd  %xmm6,%xmm6
movsd  0x1991(%rip),%xmm7
lea    (%rcx,%r14,1),%rax
mov    %rax,0xa8(%rsp)
mov    0xd8(%rsp),%rax
add    %r14,%rax
mov    %rax,0x120(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x138(%rsp)
lea    0x10(%rbp,%r14,8),%rax
mov    %rax,0xf8(%rsp)
lea    (%r15,%r14,8),%rbx
add    $0x30,%rbx
mov    %r14,0x8(%rsp)
lea    0x30(,%r14,8),%rsi
add    %rbp,%rsi
xor    %eax,%eax
mov    $0x1,%edx
mov    $0x1,%r11d
movsd  0x100(%rsp),%xmm5
mov    %r13,0x58(%rsp)
mov    %rdi,0xc8(%rsp)
mov    %r12,0x80(%rsp)
mov    %rbx,0x110(%rsp)
mov    %rsi,0x108(%rsp)
jmp    1722 <compute_solution+0x5e2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11d
lea    -0x1(%r11),%eax
cmp    0x4c(%rsp),%edx
je     2451 <compute_solution+0x1311>
mov    %rax,0xc0(%rsp)
mov    %r11,0x88(%rsp)
mov    %edx,0x68(%rsp)
mov    0x30(%rsp),%rax
cmp    0x4(%rsp),%eax
jl     1977 <compute_solution+0x837>
cmpl   $0x3,0x28(%rsp)
setb   %al
or     0x17(%rsp),%al
mov    0x8(%rsp),%rdx
mov    0x208(%rsp),%r9
mov    0xf8(%rsp),%rcx
mov    0x30(%rsp),%rsi
mov    0x18(%rsp),%rdi
jne    17f3 <compute_solution+0x6b3>
xor    %eax,%eax
mov    0x50(%rsp),%rdx
mov    0xf0(%rsp),%r9
mov    0x140(%rsp),%r11
nopl   (%rax)
movupd -0x10(%rcx,%rax,8),%xmm0
movupd (%rcx,%rax,8),%xmm1
movupd (%r9,%rax,8),%xmm2
movupd 0x10(%r9,%rax,8),%xmm3
movupd (%r11,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd 0x10(%r11,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,-0x10(%rcx,%rax,8)
movupd %xmm0,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1790 <compute_solution+0x650>
mov    %rdx,%rax
mov    0xa8(%rsp),%rdx
cmp    %rax,0x78(%rsp)
mov    0x208(%rsp),%r9
je     186d <compute_solution+0x72d>
mov    %edi,%eax
sub    %edx,%eax
test   $0x1,%al
jne    1804 <compute_solution+0x6c4>
mov    %rdx,%rax
cmp    %esi,%edx
jne    1830 <compute_solution+0x6f0>
jmp    186d <compute_solution+0x72d>
mov    0x40(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
mulsd  (%r9,%rdx,8),%xmm0
addsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
mov    %rdx,%rax
add    $0x1,%rax
cmp    %esi,%edx
je     186d <compute_solution+0x72d>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
mulsd  (%r9,%rax,8),%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%r9,%rax,8),%xmm0
addsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %eax,%edi
jne    1830 <compute_solution+0x6f0>
cmp    0x4(%rsp),%esi
mov    0x180(%rsp),%r8
mov    0x178(%rsp),%rdi
mov    0x170(%rsp),%r13
mov    0x168(%rsp),%r10
mov    0x160(%rsp),%r14
mov    0x158(%rsp),%r11
mov    0xb8(%rsp),%r9
mov    0x150(%rsp),%r12
mov    0x148(%rsp),%rcx
jl     1977 <compute_solution+0x837>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rax,8),%rdx
movslq (%rdx),%rsi
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  (%rdi,%rax,8),%xmm1
movsd  (%r8,%rax,8),%xmm0
mov    0x98(%rsp),%rsi
mulsd  (%rsi,%rax,8),%xmm0
subsd  %xmm1,%xmm0
movsd  (%r10,%rax,8),%xmm1
movslq 0x4(%rdx),%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm1
movsd  (%r14,%rax,8),%xmm2
movslq 0x8(%rdx),%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm2
subsd  %xmm1,%xmm0
subsd  %xmm2,%xmm0
movsd  (%r11,%rax,8),%xmm1
movslq 0xc(%rdx),%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm1
subsd  %xmm1,%xmm0
movsd  (%r12,%rax,8),%xmm1
movslq 0x10(%rdx),%rsi
mulsd  0x0(%rbp,%rsi,8),%xmm1
mov    0x90(%rsp),%rsi
subsd  %xmm1,%xmm0
movsd  (%rcx,%rax,8),%xmm1
movslq 0x14(%rdx),%rdx
mulsd  0x0(%rbp,%rdx,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0x1,%rax
cmp    %eax,%esi
jne    18d0 <compute_solution+0x790>
mov    0x88(%rsp),%r11
mov    %r11d,%r10d
mov    0xc0(%rsp),%rax
cmp    $0x1,%eax
je     1ba0 <compute_solution+0xa60>
cmp    $0x2,%eax
mov    0x80(%rsp),%r12
mov    0x1f0(%rsp),%rdi
mov    0x58(%rsp),%r13
mov    0x60(%rsp),%rsi
mov    0x90(%rsp),%r8
mov    0x18(%rsp),%rbx
jne    1ef0 <compute_solution+0xdb0>
mov    0x30(%rsp),%r14
cmp    0x4(%rsp),%r14d
jl     1c80 <compute_solution+0xb40>
mov    0x48(%rsp),%edx
xorpd  %xmm0,%xmm0
test   %edx,%edx
je     1d67 <compute_solution+0xc27>
mov    0x8(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm1
mov    0x20(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    19f0 <compute_solution+0x8b0>
cmpl   $0x3,0x28(%rsp)
jb     1a6f <compute_solution+0x92f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm1
movsd  0x8(%r15,%rcx,8),%xmm2
mov    0x20(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  0x8(%rax,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r15,%rcx,8),%xmm3
mulsd  0x10(%rax,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r15,%rcx,8),%xmm0
mulsd  0x18(%rax,%rcx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %ecx,%ebx
jne    1a20 <compute_solution+0x8e0>
cmp    0x4(%rsp),%r14d
mov    0xa0(%rsp),%rax
jl     1c80 <compute_solution+0xb40>
xorpd  %xmm1,%xmm1
test   $0x3,%r8b
je     1d91 <compute_solution+0xc51>
mov    0x48(%rsp),%edx
mov    0x8(%rsp),%rcx
nopl   0x0(%rax)
movsd  (%r15,%rcx,8),%xmm2
mulsd  (%rsi,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    1aa0 <compute_solution+0x960>
cmpl   $0x3,0x28(%rsp)
jb     1b0a <compute_solution+0x9ca>
nop
movsd  (%r15,%rcx,8),%xmm2
movsd  0x8(%r15,%rcx,8),%xmm3
mulsd  (%rsi,%rcx,8),%xmm2
mulsd  0x8(%rsi,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%r15,%rcx,8),%xmm4
mulsd  0x10(%rsi,%rcx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%r15,%rcx,8),%xmm1
mulsd  0x18(%rsi,%rcx,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rcx
cmp    %ecx,%ebx
jne    1ac0 <compute_solution+0x980>
cmp    0x4(%rsp),%r14d
jl     1c80 <compute_solution+0xb40>
movapd 0x14f3(%rip),%xmm2
xorpd  %xmm2,%xmm0
divsd  0x8(%rdi),%xmm0
xorpd  %xmm2,%xmm1
divsd  0x10(%rdi),%xmm1
xor    %ecx,%ecx
mov    0xc8(%rsp),%r14
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
mov    0x98(%rsp),%rdx
addsd  (%rdx,%rcx,8),%xmm2
movsd  0x0(%r13,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rdx,%rcx,8)
mov    0x70(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%r9,%rcx,8),%xmm2
movsd  (%r14,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%r8d
jne    1b40 <compute_solution+0xa00>
jmp    1ef0 <compute_solution+0xdb0>
mov    0x30(%rsp),%r14
cmp    0x4(%rsp),%r14d
mov    0x80(%rsp),%r12
mov    0x1f0(%rsp),%rdi
mov    0x58(%rsp),%r13
mov    0x90(%rsp),%r8
mov    0x18(%rsp),%rbx
jl     1c80 <compute_solution+0xb40>
xorpd  %xmm0,%xmm0
test   $0x3,%r8b
je     1d7c <compute_solution+0xc3c>
mov    0x48(%rsp),%edx
mov    0x8(%rsp),%rcx
nopl   0x0(%rax)
movsd  (%r15,%rcx,8),%xmm1
mov    0x20(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    1bf0 <compute_solution+0xab0>
cmpl   $0x3,0x28(%rsp)
jb     1c6f <compute_solution+0xb2f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm1
movsd  0x8(%r15,%rcx,8),%xmm2
mov    0x20(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  0x8(%rax,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r15,%rcx,8),%xmm3
mulsd  0x10(%rax,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r15,%rcx,8),%xmm0
mulsd  0x18(%rax,%rcx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rcx
cmp    %ecx,%ebx
jne    1c20 <compute_solution+0xae0>
cmp    0x4(%rsp),%r14d
jge    1c91 <compute_solution+0xb51>
cs nopw 0x0(%rax,%rax,1)
movq   $0x0,(%rdi,%r10,8)
xorpd  %xmm0,%xmm0
jmp    2030 <compute_solution+0xef0>
cmpl   $0x0,0x28(%rsp)
sete   %cl
xorpd  0x136f(%rip),%xmm0
divsd  0x8(%rdi),%xmm0
or     0x14(%rsp),%cl
mov    0x8(%rsp),%rdx
jne    1e20 <compute_solution+0xce0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x130(%rsp)
je     1da6 <compute_solution+0xc66>
mov    0x118(%rsp),%rdx
xor    %ecx,%ecx
mov    0x70(%rsp),%r8
mov    0xa0(%rsp),%r13
mov    0xf8(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movupd (%r9,%rcx,8),%xmm2
movupd (%r8,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%r9,%rcx,8)
movupd -0x10(%rax,%rcx,8),%xmm2
movupd 0x0(%r13,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,-0x10(%rax,%rcx,8)
movupd 0x10(%r9,%rcx,8),%xmm2
movupd 0x10(%r8,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,0x10(%r9,%rcx,8)
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%r13,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%rax,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1cf0 <compute_solution+0xbb0>
jmp    1da8 <compute_solution+0xc68>
mov    0x8(%rsp),%rcx
cmpl   $0x3,0x28(%rsp)
jae    1a20 <compute_solution+0x8e0>
jmp    1a6f <compute_solution+0x92f>
mov    0x8(%rsp),%rcx
cmpl   $0x3,0x28(%rsp)
jae    1c20 <compute_solution+0xae0>
jmp    1c6f <compute_solution+0xb2f>
mov    0x8(%rsp),%rcx
cmpl   $0x3,0x28(%rsp)
jae    1ac0 <compute_solution+0x980>
jmp    1b0a <compute_solution+0x9ca>
xor    %ecx,%ecx
testb  $0x1,0x128(%rsp)
01
mov    0x58(%rsp),%r13
mov    0x90(%rsp),%r8
mov    0x18(%rsp),%rbx
je     1e05 <compute_solution+0xcc5>
add    0x8(%rsp),%rcx
movupd (%r15,%rcx,8),%xmm2
mov    0x20(%rsp),%rax
movupd (%rax,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%r15,%rcx,8)
movupd 0x0(%rbp,%rcx,8),%xmm2
mov    0x38(%rsp),%rdx
movupd (%rdx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,0x0(%rbp,%rcx,8)
mov    0x120(%rsp),%rdx
mov    0xd8(%rsp),%rcx
cmp    %rcx,0x78(%rsp)
je     1ef0 <compute_solution+0xdb0>
mov    %ebx,%ecx
sub    %edx,%ecx
test   $0x1,%cl
jne    1e2e <compute_solution+0xcee>
mov    %rdx,%rcx
jmp    1e69 <compute_solution+0xd29>
mov    0x20(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
mov    0x38(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
mov    %rdx,%rcx
add    $0x1,%rcx
mov    0x30(%rsp),%rax
cmp    %eax,%edx
je     1ef0 <compute_solution+0xdb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%r15,%rcx,8)
mov    0x38(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x8(%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r15,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %ecx,%ebx
jne    1e80 <compute_solution+0xd40>
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rdi,%r10,8)
xorpd  %xmm0,%xmm0
mov    0x30(%rsp),%r14
cmp    0x4(%rsp),%r14d
jl     2030 <compute_solution+0xef0>
xorpd  %xmm2,%xmm2
mov    0x8(%rsp),%rcx
xorpd  %xmm1,%xmm1
test   $0x1,%r8b
je     1f54 <compute_solution+0xe14>
mov    0x8(%rsp),%rcx
movsd  (%r15,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm6,%xmm2
movsd  %xmm2,(%rdi,%r10,8)
mov    0x40(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm1
mulsd  (%r15,%rcx,8),%xmm1
addsd  %xmm6,%xmm1
mov    0x138(%rsp),%rcx
cmpl   $0x0,0x28(%rsp)
je     1fb6 <compute_solution+0xe76>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rdi,%r10,8)
mov    0x40(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm3
mulsd  (%r15,%rcx,8),%xmm3
addsd  %xmm1,%xmm3
movsd  0x8(%r15,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rdi,%r10,8)
movsd  0x8(%rdx,%rcx,8),%xmm1
mulsd  0x8(%r15,%rcx,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rcx
cmp    %ecx,%ebx
jne    1f60 <compute_solution+0xe20>
xorpd  %xmm0,%xmm0
cmp    0x4(%rsp),%r14d
mov    0xf0(%rsp),%rcx
jl     2030 <compute_solution+0xef0>
divsd  %xmm2,%xmm1
movapd %xmm1,%xmm2
xorpd  0x1037(%rip),%xmm2
xorpd  %xmm0,%xmm0
xor    %eax,%eax
nop
movsd  (%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rax,8),%xmm3
movsd  %xmm3,(%rcx,%rax,8)
mulsd  %xmm3,%xmm3
mov    0x98(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  (%r12,%rax,8),%xmm4
addsd  %xmm3,%xmm0
movsd  %xmm4,(%r12,%rax,8)
add    $0x1,%rax
cmp    %eax,%r8d
jne    1fe0 <compute_solution+0xea0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomisd %xmm6,%xmm0
jb     2060 <compute_solution+0xf20>
sqrtsd %xmm0,%xmm0
mov    0x68(%rsp),%edx
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%rsi
mov    0xb0(%rsp),%r10
jmp    20ab <compute_solution+0xf6b>
nopl   0x0(%rax,%rax,1)
call   1060 <sqrt@plt>
mov    0x88(%rsp),%r11
movsd  0xf93(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    0xb8(%rsp),%r9
mov    0xb0(%rsp),%r10
mov    0x58(%rsp),%r13
movsd  0x100(%rsp),%xmm5
mov    0x68(%rsp),%edx
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%rsi
divsd  %xmm5,%xmm0
mov    0x210(%rsp),%rax
movsd  %xmm0,(%rax)
ucomisd %xmm0,%xmm7
jae    245a <compute_solution+0x131a>
add    $0x1,%edx
cmp    $0x3,%r11d
je     21a0 <compute_solution+0x1060>
cmp    $0x1,%r11d
jne    21b0 <compute_solution+0x1070>
cmp    0x4(%rsp),%r14d
mov    0x60(%rsp),%r14
mov    0x18(%rsp),%rdi
jl     1710 <compute_solution+0x5d0>
cmpl   $0x3,0x28(%rsp)
setb   %al
or     0x16(%rsp),%al
mov    0x8(%rsp),%rcx
jne    23a7 <compute_solution+0x1267>
cmpq   $0x0,0xe8(%rsp)
mov    %edx,0x68(%rsp)
je     2340 <compute_solution+0x1200>
mov    0xd0(%rsp),%rcx
xor    %eax,%eax
mov    0x70(%rsp),%rdx
mov    0xa0(%rsp),%rdi
mov    0x50(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
movups -0x30(%rbx,%rax,8),%xmm0
movups -0x20(%rbx,%rax,8),%xmm1
movups %xmm0,(%rdx,%rax,8)
movups %xmm1,0x10(%rdx,%rax,8)
movups -0x10(%rsi,%rax,8),%xmm0
movups (%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%rdi,%rax,8)
movups %xmm1,0x30(%rdi,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm1,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2140 <compute_solution+0x1000>
jmp    2347 <compute_solution+0x1207>
nop
mov    $0x1,%r11d
mov    0x60(%rsp),%r14
jmp    1714 <compute_solution+0x5d4>
cmp    0x4(%rsp),%r14d
mov    0x60(%rsp),%r14
mov    0x18(%rsp),%rdi
jl     1710 <compute_solution+0x5d0>
cmpl   $0x3,0x28(%rsp)
setb   %al
or     0x15(%rsp),%al
mov    0x8(%rsp),%rcx
jne    22c5 <compute_solution+0x1185>
cmpq   $0x0,0xe8(%rsp)
je     2437 <compute_solution+0x12f7>
mov    0xd0(%rsp),%rcx
xor    %eax,%eax
mov    0xc8(%rsp),%rdi
mov    0x50(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,0x0(%r13,%rax,8)
movups %xmm1,0x10(%r13,%rax,8)
movups -0x30(%rbx,%rax,8),%xmm0
movups -0x20(%rbx,%rax,8),%xmm1
movups %xmm0,(%rdi,%rax,8)
movups %xmm1,0x10(%rdi,%rax,8)
movups -0x10(%rsi,%rax,8),%xmm0
movups (%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%r13,%rax,8)
movups %xmm1,0x30(%r13,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd %xmm0,0x20(%rdi,%rax,8)
movupd %xmm1,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2210 <compute_solution+0x10d0>
testb  $0x1,0xe0(%rsp)
01
je     22ad <compute_solution+0x116d>
add    0x8(%rsp),%rax
movups 0x0(%rbp,%rax,8),%xmm0
movups 0x10(%rbp,%rax,8),%xmm1
movups %xmm0,(%r10,%rax,8)
movups %xmm1,0x10(%r10,%rax,8)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
movupd %xmm0,(%r14,%rax,8)
movupd %xmm1,0x10(%r14,%rax,8)
mov    0xa8(%rsp),%rcx
cmp    %r8,0x78(%rsp)
mov    0x18(%rsp),%rdi
je     1710 <compute_solution+0x5d0>
mov    %edi,%eax
sub    %ecx,%eax
test   $0x1,%al
jne    22d2 <compute_solution+0x1192>
mov    %rcx,%rax
jmp    22f1 <compute_solution+0x11b1>
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    %rcx,%rax
add    $0x1,%rax
cmp    0x30(%rsp),%ecx
mov    0x18(%rsp),%rcx
je     1710 <compute_solution+0x5d0>
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%r10,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r14,%rax,8)
add    $0x2,%rax
cmp    %eax,%ecx
jne    2300 <compute_solution+0x11c0>
jmp    1710 <compute_solution+0x5d0>
xor    %eax,%eax
mov    0x50(%rsp),%r8
testb  $0x1,0xe0(%rsp)
01
mov    0x68(%rsp),%edx
je     238f <compute_solution+0x124f>
add    0x8(%rsp),%rax
movups 0x0(%rbp,%rax,8),%xmm0
movups 0x10(%rbp,%rax,8),%xmm1
mov    0x38(%rsp),%rcx
movups %xmm0,(%rcx,%rax,8)
movups %xmm1,0x10(%rcx,%rax,8)
movupd (%r15,%rax,8),%xmm0
movupd 0x10(%r15,%rax,8),%xmm1
mov    0x20(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0xa8(%rsp),%rcx
cmp    %r8,0x78(%rsp)
mov    0x18(%rsp),%rdi
je     1710 <compute_solution+0x5d0>
mov    %edi,%eax
sub    %ecx,%eax
test   $0x1,%al
jne    23b4 <compute_solution+0x1274>
mov    %rcx,%rax
jmp    23db <compute_solution+0x129b>
movsd  0x0(%rbp,%rcx,8),%xmm0
mov    0x38(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movsd  (%r15,%rcx,8),%xmm0
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    %rcx,%rax
add    $0x1,%rax
cmp    0x30(%rsp),%ecx
mov    0x18(%rsp),%r8
je     1710 <compute_solution+0x5d0>
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
mov    0x38(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  (%r15,%rax,8),%xmm0
mov    0x20(%rsp),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %eax,%r8d
jne    23f0 <compute_solution+0x12b0>
jmp    1710 <compute_solution+0x5d0>
xor    %eax,%eax
mov    0x50(%rsp),%r8
testb  $0x1,0xe0(%rsp)
01
jne    2279 <compute_solution+0x1139>
jmp    22ad <compute_solution+0x116d>
mov    0x4c(%rsp),%edx
mov    %r14,%r12
jmp    245f <compute_solution+0x131f>
mov    0x60(%rsp),%r12
mov    %r10,%r14
mov    %rbp,%rdi
mov    %edx,%ebp
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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