int KnotAnalyse(const double *chain, int size, int projection, double *tvalue,
                double *tstart, double *tend) {
  int ni, nj, nk, Nbnd, dim1, dim2, dim3,
      crosscnt = 0, si0j0_j1, si0j1_j0, sj0j1_i0, sj0j1_i1, si0j0_i1, si0j1_i1,
      maxcrss, R3cnt;
  int **crssngs, **crssndx, R1, R2, R3, *p1, *p2, *p3, *s1, *s2, *s3, swap,
      p1o = 0, p2o = 0, p3o = 0, s1o = 0, s2o = 0, s3o = 0, stuckcnt = 0;
  double xi1, xi0, yi1, yi0, xj1, xj0, yj1, yj0, mi0j0, mi0j1, mj0j1, mi0i1,
      *tvals, xcr, ycr, icrl, jcrl, zi0, zi1, zj0, zj1, zcri, zcrj;
  double cx, cy, cz, Rxz, Ryz, cos, sin, *chainR;
  Nbnd = size - 1;
  maxcrss = (int)(((Nbnd / 2) - 1) * (Nbnd - 1));
  crssngs = matrix_int_calloc(maxcrss, 3);
  p1 = vector_int_alloc(Nbnd);
  p2 = vector_int_alloc(Nbnd);
  p3 = vector_int_alloc(Nbnd);
  s1 = vector_int_alloc(Nbnd);
  s2 = vector_int_alloc(Nbnd);
  s3 = vector_int_alloc(Nbnd);
  tvals = vector_double_alloc(maxcrss);
  chainR = vector_double_alloc(3 * size);
  cx = chain[3 * size - 3] - chain[0];
  cz = chain[3 * size - 1] - chain[2];
  Rxz = sqrt(cx * cx + cz * cz);
  cos = cz / Rxz;
  sin = cx / Rxz;
  for (ni = 0; ni < size; ni++) {
    chainR[3 * ni + 0] = cos * chain[3 * ni + 0] - sin * chain[3 * ni + 2];
    chainR[3 * ni + 1] = chain[3 * ni + 1];
    chainR[3 * ni + 2] = sin * chain[3 * ni + 0] + cos * chain[3 * ni + 2];
  }
  cy = chainR[3 * size - 2] - chainR[1];
  cz = chainR[3 * size - 1] - chainR[2];
  Ryz = sqrt(cy * cy + cz * cz);
  cos = cz / Ryz;
  sin = cy / Ryz;
  for (ni = 0; ni < size; ni++) {
    chainR[3 * ni + 1] = cos * chainR[3 * ni + 1] - sin * chainR[3 * ni + 2];
    chainR[3 * ni + 2] = sin * chainR[3 * ni + 1] + cos * chainR[3 * ni + 2];
  }
  dim3 = projection;
  dim1 = (dim3 + 1) % 3;
  dim2 = (dim3 + 2) % 3;
  for (ni = 0; ni < Nbnd - 2; ni++) {
    xi0 = chainR[3 * ni + dim1];
    yi0 = chainR[3 * ni + dim2];
    zi0 = chainR[3 * ni + dim3];
    xi1 = chainR[3 * ni + 3 + dim1];
    yi1 = chainR[3 * ni + 3 + dim2];
    zi1 = chainR[3 * ni + 3 + dim3];
    for (nj = ni + 2; nj < Nbnd; nj++) {
      xj0 = chainR[3 * nj + dim1];
      yj0 = chainR[3 * nj + dim2];
      zj0 = chainR[3 * nj + dim3];
      xj1 = chainR[3 * nj + 3 + dim1];
      yj1 = chainR[3 * nj + 3 + dim2];
      zj1 = chainR[3 * nj + 3 + dim3];
      mj0j1 = (yj0 - yj1) / (xj0 - xj1);
      sj0j1_i0 = (((mj0j1) * (xi0 - xj0) - (yi0 - yj0)) > 0);
      sj0j1_i1 = (((mj0j1) * (xi1 - xj0) - (yi1 - yj0)) > 0);
      if (sj0j1_i0 == sj0j1_i1)
        continue;
      mi0j0 = (yi0 - yj0) / (xi0 - xj0);
      si0j0_j1 = (((mi0j0) * (xj1 - xi0) - (yj1 - yi0)) > 0);
      si0j0_i1 = (((mi0j0) * (xi1 - xi0) - (yi1 - yi0)) > 0);
      if (si0j0_i1 != si0j0_j1)
        continue;
      mi0j1 = (yi0 - yj1) / (xi0 - xj1);
      si0j1_j0 = (((mi0j1) * (xj0 - xi0) - (yj0 - yi0)) > 0);
      si0j1_i1 = (((mi0j1) * (xi1 - xi0) - (yi1 - yi0)) > 0);
      if (si0j1_i1 != si0j1_j0)
        continue;
      mi0i1 = (yi0 - yi1) / (xi0 - xi1);
      xcr = ((mi0i1 * xi0 - yi0) - (mj0j1 * xj0 - yj0)) / (mi0i1 - mj0j1);
      ycr = mi0i1 * (xcr - xi0) + yi0;
      icrl = sqrt(((xcr - xi0) * (xcr - xi0) + (ycr - yi0) * (ycr - yi0)) /
                  ((xi1 - xi0) * (xi1 - xi0) + (yi1 - yi0) * (yi1 - yi0)));
      jcrl = sqrt(((xcr - xj0) * (xcr - xj0) + (ycr - yj0) * (ycr - yj0)) /
                  ((xj1 - xj0) * (xj1 - xj0) + (yj1 - yj0) * (yj1 - yj0)));
      zcri = zi0 + (zi1 - zi0) * icrl;
      zcrj = zj0 + (zj1 - zj0) * jcrl;
      crssngs[crosscnt][2] = (zcri > zcrj ? 1 : -1);
      tvals[2 * crosscnt] = ni + icrl;
      tvals[2 * crosscnt + 1] = nj + jcrl;
      crosscnt++;
    }
  }
  crssndx = matrix_int_calloc(2 * (dim1 = crosscnt) + 2, 3);
  if (crosscnt == 0)
    goto knotclearup;
  if (crosscnt > maxcrss) {
    printf("Warning: Too many crossings, increase buffer size.");
    crosscnt = -2;
    goto knotclearup;
  }
  for (ni = 0; ni < crosscnt; ni++) {
    crssngs[ni][0] += 1;
    crssngs[ni][1] += 2;
    for (nj = ni + 1; nj < crosscnt; nj++) {
      if (tvals[2 * ni] > tvals[2 * nj])
        crssngs[ni][0]++;
      else
        crssngs[nj][0]++;
      if (tvals[2 * ni] > tvals[2 * nj + 1])
        crssngs[ni][0]++;
      else
        crssngs[nj][1]++;
      if (tvals[2 * ni + 1] > tvals[2 * nj])
        crssngs[ni][1]++;
      else
        crssngs[nj][0]++;
      if (tvals[2 * ni + 1] > tvals[2 * nj + 1])
        crssngs[ni][1]++;
      else
        crssngs[nj][1]++;
    }
  }
  for (ni = 0; ni < crosscnt; ni++) {
    crssndx[crssngs[ni][0]][0] = crssngs[ni][1];
    crssndx[crssngs[ni][0]][1] = crssngs[ni][2];
    crssndx[crssngs[ni][0]][2] = crssngs[ni][0];
    crssndx[crssngs[ni][1]][0] = crssngs[ni][0];
    crssndx[crssngs[ni][1]][1] = -crssngs[ni][2];
    crssndx[crssngs[ni][1]][2] = crssngs[ni][1];
  }
  maxcrss = crosscnt;
  while (crosscnt != 0) {
    R1 = R2 = R3 = 0;
    for (ni = 1; ni < 2 * crosscnt + 1; ni++) {
      if (crssndx[ni][0] == ni + 1) {
        for (nj = 1; nj <= 2 * crosscnt - 2; nj++) {
          if (nj > ni - 1) {
            crssndx[nj][0] = crssndx[nj + 2][0];
            crssndx[nj][1] = crssndx[nj + 2][1];
            crssndx[nj][2] = crssndx[nj + 2][2];
          }
          if (crssndx[nj][0] > ni + 1)
            crssndx[nj][0] -= 2;
        }
        crosscnt--;
        stuckcnt = 0;
        R1 = 1;
        break;
      }
    }
    if (R1 == 1)
      continue;
    for (ni = 1; ni < 2 * crosscnt; ni++) {
      if (abs(crssndx[ni + 1][0] - crssndx[ni][0]) == 1 &&
          crssndx[ni][1] == crssndx[ni + 1][1]) {
        nk = (crssndx[ni + 1][0] < crssndx[ni][0] ? crssndx[ni + 1][0]
                                                  : crssndx[ni][0]);
        for (nj = 1; nj <= 2 * crosscnt - 4; nj++) {
          if (nj > nk - 3) {
            crssndx[nj][0] = crssndx[nj + 4][0];
            crssndx[nj][1] = crssndx[nj + 4][1];
            crssndx[nj][2] = crssndx[nj + 4][2];
          } else if (nj > ni - 1) {
            crssndx[nj][0] = crssndx[nj + 2][0];
            crssndx[nj][1] = crssndx[nj + 2][1];
            crssndx[nj][2] = crssndx[nj + 2][2];
          }
          if (crssndx[nj][0] > nk + 1)
            crssndx[nj][0] -= 4;
          else if (crssndx[nj][0] > ni + 1)
            crssndx[nj][0] -= 2;
        }
        crosscnt -= 2;
        stuckcnt = 0;
        R2 = 1;
        break;
      }
    }
    if (R2 == 1)
      continue;
    R3cnt = 0;
    for (ni = 1; ni < 2 * crosscnt; ni++) {
      if (crssndx[ni][1] == crssndx[ni + 1][1]) {
        for (nj = -1; nj < 2; nj += 2) {
          for (nk = -1; nk < 2; nk += 2) {
            if (crssndx[ni][0] == 2 * crosscnt && nj == 1)
              continue;
            if (crssndx[crssndx[ni][0] + nj][0] == crssndx[ni + 1][0] + nk) {
              p1[R3cnt] = ni;
              s1[R3cnt] = crssndx[ni][0];
              p2[R3cnt] = ni + 1;
              s2[R3cnt] = crssndx[ni + 1][0];
              p3[R3cnt] = s1[R3cnt] + nj;
              s3[R3cnt] = s2[R3cnt] + nk;
              if (p1[R3cnt] == p1o && s1[R3cnt] == s1o && p2[R3cnt] == p2o &&
                  s2[R3cnt] == s2o && p3[R3cnt] == p3o && s3[R3cnt] == s3o)
                continue;
              R3cnt++;
            }
          }
        }
      }
    }
    if (R3cnt > 0) {
      for (ni = 0; ni < R3cnt; ni++) {
        if (abs(s1[ni] - s2[ni]) == 1 || abs(s3[ni] - p1[ni]) == 1 ||
            abs(p3[ni] - p2[ni]) == 1) {
          R3cnt = ni;
          R3 = 1;
          break;
        }
        if (crssndx[2 * s3[ni] - s2[ni]][0] == 2 * p1[ni] - p2[ni] &&
            crssndx[2 * s3[ni] - s2[ni]][1] == crssndx[s2[ni]][1]) {
          R3cnt = ni;
          R3 = 1;
          break;
        }
        if (crssndx[2 * p3[ni] - s1[ni]][0] == 2 * p2[ni] - p1[ni] &&
            crssndx[2 * p3[ni] - s1[ni]][1] == crssndx[s1[ni]][1]) {
          R3cnt = ni;
          R3 = 1;
          break;
        }
        if (crssndx[2 * s2[ni] - s3[ni]][0] == 2 * s1[ni] - p3[ni] &&
            crssndx[2 * s2[ni] - s3[ni]][1] == crssndx[s3[ni]][1]) {
          R3cnt = ni;
          R3 = 1;
          break;
        }
      }
      if (R3 == 0) {
        R3cnt = rand() % R3cnt;
      }
      p1o = crssndx[p1[R3cnt]][0] = s3[R3cnt];
      p2o = crssndx[p2[R3cnt]][0] = p3[R3cnt];
      p3o = crssndx[p3[R3cnt]][0] = p2[R3cnt];
      s1o = crssndx[s1[R3cnt]][0] = s2[R3cnt];
      s2o = crssndx[s2[R3cnt]][0] = s1[R3cnt];
      s3o = crssndx[s3[R3cnt]][0] = p1[R3cnt];
      swap = crssndx[p2[R3cnt]][1];
      crssndx[p2[R3cnt]][1] = crssndx[p1[R3cnt]][1];
      crssndx[p1[R3cnt]][1] = swap;
      swap = crssndx[s1[R3cnt]][1];
      crssndx[s1[R3cnt]][1] = crssndx[p3[R3cnt]][1];
      crssndx[p3[R3cnt]][1] = swap;
      swap = crssndx[s3[R3cnt]][1];
      crssndx[s3[R3cnt]][1] = crssndx[s2[R3cnt]][1];
      crssndx[s2[R3cnt]][1] = swap;
      stuckcnt++;
    }
    if (R1 == 0 && R2 == 0 && R3 == 0)
      break;
    if (stuckcnt > 50) {
      printf("\nKnot Warning: Stuck performing R3 moves\n");
      break;
    }
  }
  if (crosscnt > 0) {
    for (ni = 0; ni < maxcrss; ni++) {
      if (crssndx[1][2] == crssngs[ni][0])
        *tstart = tvals[2 * ni];
      if (crssndx[1][2] == crssngs[ni][1])
        *tstart = tvals[2 * ni + 1];
      if (crssndx[2 * crosscnt][2] == crssngs[ni][0])
        *tend = tvals[2 * ni];
      if (crssndx[2 * crosscnt][2] == crssngs[ni][1])
        *tend = tvals[2 * ni + 1];
    }
    *tvalue = (*tend - *tstart) / Nbnd;
  }
knotclearup:
  matrix_int_free(crssngs, maxcrss);
  matrix_int_free(crssndx, 2 * dim1 + 1);
  vector_double_free(tvals);
  vector_double_free(chainR);
  return crosscnt;
}


x86 assembly (clang, -O0):
<KnotAnalyse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0xc0(%rbp)
movl   $0x0,-0xc4(%rbp)
movl   $0x0,-0xc8(%rbp)
movl   $0x0,-0xcc(%rbp)
movl   $0x0,-0xd0(%rbp)
movl   $0x0,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1050 <matrix_int_calloc@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x38(%rbp),%edi
mov    $0x0,%al
call   1070 <vector_int_alloc@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x38(%rbp),%edi
mov    $0x0,%al
call   1070 <vector_int_alloc@plt>
cltq
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%edi
mov    $0x0,%al
call   1070 <vector_int_alloc@plt>
cltq
mov    %rax,-0xa0(%rbp)
mov    -0x38(%rbp),%edi
mov    $0x0,%al
call   1070 <vector_int_alloc@plt>
cltq
mov    %rax,-0xa8(%rbp)
mov    -0x38(%rbp),%edi
mov    $0x0,%al
call   1070 <vector_int_alloc@plt>
cltq
mov    %rax,-0xb0(%rbp)
mov    -0x38(%rbp),%edi
mov    $0x0,%al
call   1070 <vector_int_alloc@plt>
cltq
mov    %rax,-0xb8(%rbp)
mov    -0x64(%rbp),%edi
mov    $0x0,%al
call   1090 <vector_double_alloc@plt>
cltq
mov    %rax,-0x140(%rbp)
imul   $0x3,-0xc(%rbp),%edi
mov    $0x0,%al
call   1090 <vector_double_alloc@plt>
cltq
mov    %rax,-0x1d0(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x8(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movsd  -0x198(%rbp),%xmm2
ff
movsd  -0x1a8(%rbp),%xmm1
ff
mulsd  -0x1a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
divsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
divsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1484 <KnotAnalyse+0x2f4>
movsd  -0x1c0(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x1c8(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x1c0(%rbp),%xmm1
ff
mov    -0x8(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1382 <KnotAnalyse+0x1f2>
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1d0(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1d0(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  -0x1a0(%rbp),%xmm2
ff
movsd  -0x1a8(%rbp),%xmm1
ff
mulsd  -0x1a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm0
ff
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
divsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1629 <KnotAnalyse+0x499>
movsd  -0x1c0(%rbp),%xmm0
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x1c8(%rbp),%xmm1
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1c8(%rbp),%xmm0
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x1c0(%rbp),%xmm1
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1544 <KnotAnalyse+0x3b4>
mov    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x3c(%rbp)
mov    -0x44(%rbp),%eax
add    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jge    1e02 <KnotAnalyse+0xc72>
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x3,%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x3,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x2c(%rbp),%ecx
add    $0x3,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1def <KnotAnalyse+0xc5f>
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x3,%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x3,%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x1d0(%rbp),%rax
imul   $0x3,-0x30(%rbp),%ecx
add    $0x3,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
subsd  -0x110(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm1
ff
subsd  -0x100(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
subsd  -0x108(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
subsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x54(%rbp)
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
subsd  -0x108(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
subsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
jne    18e7 <KnotAnalyse+0x757>
jmp    1de1 <KnotAnalyse+0xc51>
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0x118(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
subsd  -0x108(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x4c(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     19d6 <KnotAnalyse+0x846>
jmp    1de1 <KnotAnalyse+0xc51>
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0x110(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
subsd  -0x100(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x118(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x50(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     1ac5 <KnotAnalyse+0x935>
jmp    1de1 <KnotAnalyse+0xc51>
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
subsd  -0xe0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x130(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm3
ff
movsd  -0x118(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  -0x138(%rbp),%xmm1
ff
subsd  -0x130(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0xe8(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
movsd  -0x150(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm3
ff
subsd  -0xf8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
subsd  -0xe8(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm3
ff
subsd  -0xe8(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm2
ff
subsd  -0xf8(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm4
ff
subsd  -0xf8(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0x108(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm2
ff
subsd  -0x108(%rbp),%xmm2
ff
movsd  -0x150(%rbp),%xmm1
ff
subsd  -0x118(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm3
ff
subsd  -0x118(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x100(%rbp),%xmm1
ff
subsd  -0x108(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm3
ff
subsd  -0x108(%rbp),%xmm3
ff
movsd  -0x110(%rbp),%xmm2
ff
subsd  -0x118(%rbp),%xmm2
ff
movsd  -0x110(%rbp),%xmm4
ff
subsd  -0x118(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  %xmm0,-0x160(%rbp)
movsd  -0x168(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm0
ff
subsd  -0x168(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0x180(%rbp),%xmm0
ff
subsd  -0x178(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movsd  -0x190(%rbp),%xmm1
ff
mov    $0xffffffff,%ecx
mov    $0x1,%eax
ucomisd %xmm1,%xmm0
cmova  %eax,%ecx
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
cvtsi2sdl -0x2c(%rbp),%xmm0
addsd  -0x158(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x30(%rbp),%xmm0
addsd  -0x160(%rbp),%xmm0
ff
mov    -0x140(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    172f <KnotAnalyse+0x59f>
jmp    1df4 <KnotAnalyse+0xc64>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1658 <KnotAnalyse+0x4c8>
mov    -0x48(%rbp),%edi
mov    %edi,-0x3c(%rbp)
shl    $0x1,%edi
add    $0x2,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1050 <matrix_int_calloc@plt>
cltq
mov    %rax,-0x78(%rbp)
cmpl   $0x0,-0x48(%rbp)
jne    1e2f <KnotAnalyse+0xc9f>
jmp    2ef5 <KnotAnalyse+0x1d65>
mov    -0x48(%rbp),%eax
cmp    -0x64(%rbp),%eax
jle    1e55 <KnotAnalyse+0xcc5>
lea    0x11be(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xfffffffe,-0x48(%rbp)
jmp    2ef5 <KnotAnalyse+0x1d65>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    204b <KnotAnalyse+0xebb>
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
add    $0x2,%ecx
mov    %ecx,0x4(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    2038 <KnotAnalyse+0xea8>
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x140(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1eed <KnotAnalyse+0xd5d>
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1f00 <KnotAnalyse+0xd70>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x140(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1f4b <KnotAnalyse+0xdbb>
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    1f60 <KnotAnalyse+0xdd0>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x140(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1fad <KnotAnalyse+0xe1d>
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
jmp    1fc0 <KnotAnalyse+0xe30>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x140(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    2010 <KnotAnalyse+0xe80>
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
jmp    2025 <KnotAnalyse+0xe95>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
jmp    202a <KnotAnalyse+0xe9a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1e99 <KnotAnalyse+0xd09>
jmp    203d <KnotAnalyse+0xead>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1e5c <KnotAnalyse+0xccc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    2163 <KnotAnalyse+0xfd3>
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq (%rdx),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq (%rdx),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq (%rdx),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq 0x4(%rdx),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
sub    0x8(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq 0x4(%rdx),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x70(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,8),%rdx
movslq 0x4(%rdx),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2052 <KnotAnalyse+0xec2>
mov    -0x48(%rbp),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x48(%rbp)
je     2d95 <KnotAnalyse+0x1c05>
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x80(%rbp)
movl   $0x0,-0x7c(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    22c9 <KnotAnalyse+0x1139>
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    22b6 <KnotAnalyse+0x1126>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     2297 <KnotAnalyse+0x1107>
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    2255 <KnotAnalyse+0x10c5>
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    2284 <KnotAnalyse+0x10f4>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
sub    $0x2,%ecx
mov    %ecx,(%rax)
jmp    2289 <KnotAnalyse+0x10f9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    21c9 <KnotAnalyse+0x1039>
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0xd8(%rbp)
movl   $0x1,-0x7c(%rbp)
jmp    22c9 <KnotAnalyse+0x1139>
jmp    22bb <KnotAnalyse+0x112b>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2192 <KnotAnalyse+0x1002>
cmpl   $0x1,-0x7c(%rbp)
jne    22d8 <KnotAnalyse+0x1148>
jmp    2169 <KnotAnalyse+0xfd9>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    256c <KnotAnalyse+0x13dc>
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edi
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
sub    (%rax),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
jne    2559 <KnotAnalyse+0x13c9>
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x78(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    2559 <KnotAnalyse+0x13c9>
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x78(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jge    238d <KnotAnalyse+0x11fd>
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    %eax,-0x1d4(%rbp)
jmp    23a1 <KnotAnalyse+0x1211>
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d4(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x4,%ecx
cmp    %ecx,%eax
jg     253a <KnotAnalyse+0x13aa>
mov    -0x30(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jle    2442 <KnotAnalyse+0x12b2>
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
jmp    24bf <KnotAnalyse+0x132f>
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    24ba <KnotAnalyse+0x132a>
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%ecx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x8(%rax)
jmp    24bf <KnotAnalyse+0x132f>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    24f3 <KnotAnalyse+0x1363>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
sub    $0x4,%ecx
mov    %ecx,(%rax)
jmp    2527 <KnotAnalyse+0x1397>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    2522 <KnotAnalyse+0x1392>
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
sub    $0x2,%ecx
mov    %ecx,(%rax)
jmp    2527 <KnotAnalyse+0x1397>
jmp    252c <KnotAnalyse+0x139c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    23b1 <KnotAnalyse+0x1221>
mov    -0x48(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0xd8(%rbp)
movl   $0x1,-0x80(%rbp)
jmp    256c <KnotAnalyse+0x13dc>
jmp    255e <KnotAnalyse+0x13ce>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    22df <KnotAnalyse+0x114f>
cmpl   $0x1,-0x80(%rbp)
jne    257b <KnotAnalyse+0x13eb>
jmp    2169 <KnotAnalyse+0xfd9>
movl   $0x0,-0x68(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    27d4 <KnotAnalyse+0x1644>
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x78(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    27c1 <KnotAnalyse+0x1631>
movl   $0xffffffff,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    27bc <KnotAnalyse+0x162c>
movl   $0xffffffff,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jge    27a9 <KnotAnalyse+0x1619>
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    2610 <KnotAnalyse+0x1480>
cmpl   $0x1,-0x30(%rbp)
jne    2610 <KnotAnalyse+0x1480>
jmp    279b <KnotAnalyse+0x160b>
mov    -0x78(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    (%rcx),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x78(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    (%rcx),%ecx
add    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jne    2796 <KnotAnalyse+0x1606>
mov    -0x2c(%rbp),%edx
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edx
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edx
mov    -0xb0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x30(%rbp),%edx
mov    -0xa0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x34(%rbp),%edx
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xc0(%rbp),%eax
jne    278d <KnotAnalyse+0x15fd>
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xcc(%rbp),%eax
jne    278d <KnotAnalyse+0x15fd>
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xc4(%rbp),%eax
jne    278d <KnotAnalyse+0x15fd>
mov    -0xb0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xd0(%rbp),%eax
jne    278d <KnotAnalyse+0x15fd>
mov    -0xa0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xc8(%rbp),%eax
jne    278d <KnotAnalyse+0x15fd>
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xd4(%rbp),%eax
jne    278d <KnotAnalyse+0x15fd>
jmp    279b <KnotAnalyse+0x160b>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    279b <KnotAnalyse+0x160b>
mov    -0x34(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x34(%rbp)
jmp    25db <KnotAnalyse+0x144b>
jmp    27ae <KnotAnalyse+0x161e>
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
jmp    25ca <KnotAnalyse+0x143a>
jmp    27c1 <KnotAnalyse+0x1631>
jmp    27c6 <KnotAnalyse+0x1636>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2589 <KnotAnalyse+0x13f9>
cmpl   $0x0,-0x68(%rbp)
jle    2d4a <KnotAnalyse+0x1bba>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    2ab6 <KnotAnalyse+0x1926>
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0xb0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
je     286f <KnotAnalyse+0x16df>
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x90(%rbp),%rax
movslq -0x2c(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
je     286f <KnotAnalyse+0x16df>
mov    -0xa0(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x98(%rbp),%rax
movslq -0x2c(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1030 <abs@plt>
cmp    $0x1,%eax
jne    2884 <KnotAnalyse+0x16f4>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x1,-0x84(%rbp)
jmp    2ab6 <KnotAnalyse+0x1926>
mov    -0x78(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xb0(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x90(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0x98(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
jne    2939 <KnotAnalyse+0x17a9>
mov    -0x78(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xb0(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x78(%rbp),%rcx
mov    -0xb0(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    2939 <KnotAnalyse+0x17a9>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x1,-0x84(%rbp)
jmp    2ab6 <KnotAnalyse+0x1926>
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xa8(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x98(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0x90(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
jne    29ee <KnotAnalyse+0x185e>
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xa8(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x78(%rbp),%rcx
mov    -0xa8(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    29ee <KnotAnalyse+0x185e>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x1,-0x84(%rbp)
jmp    2ab6 <KnotAnalyse+0x1926>
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xb8(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0xa8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xa0(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
jne    2aa3 <KnotAnalyse+0x1913>
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x1,%ecx
mov    -0xb8(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x78(%rbp),%rcx
mov    -0xb8(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    2aa3 <KnotAnalyse+0x1913>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x68(%rbp)
movl   $0x1,-0x84(%rbp)
jmp    2ab6 <KnotAnalyse+0x1926>
jmp    2aa8 <KnotAnalyse+0x1918>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    27e5 <KnotAnalyse+0x1655>
cmpl   $0x0,-0x84(%rbp)
jne    2ad1 <KnotAnalyse+0x1941>
mov    $0x0,%al
call   10b0 <rand@plt>
cltd
idivl  -0x68(%rbp)
mov    %edx,-0x68(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x78(%rbp),%rcx
mov    -0x90(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %eax,(%rcx)
mov    %eax,-0xc0(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x78(%rbp),%rcx
mov    -0x98(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %eax,(%rcx)
mov    %eax,-0xc4(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x78(%rbp),%rcx
mov    -0xa0(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %eax,(%rcx)
mov    %eax,-0xc8(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x78(%rbp),%rcx
mov    -0xa8(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %eax,(%rcx)
mov    %eax,-0xcc(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x78(%rbp),%rcx
mov    -0xb0(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %eax,(%rcx)
mov    %eax,-0xd0(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x78(%rbp),%rcx
mov    -0xb8(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    %eax,(%rcx)
mov    %eax,-0xd4(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x98(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0xbc(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    -0x90(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0xa8(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0xbc(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    -0xa0(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0x78(%rbp),%rax
mov    -0xb8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    -0xb8(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0xbc(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    -0xb0(%rbp),%rdx
movslq -0x68(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,0x4(%rax)
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    2d70 <KnotAnalyse+0x1be0>
cmpl   $0x0,-0x80(%rbp)
jne    2d70 <KnotAnalyse+0x1be0>
cmpl   $0x0,-0x84(%rbp)
jne    2d70 <KnotAnalyse+0x1be0>
jmp    2d95 <KnotAnalyse+0x1c05>
cmpl   $0x32,-0xd8(%rbp)
jle    2d90 <KnotAnalyse+0x1c00>
lea    0x2af(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    2d95 <KnotAnalyse+0x1c05>
jmp    2169 <KnotAnalyse+0xfd9>
cmpl   $0x0,-0x48(%rbp)
jle    2ef0 <KnotAnalyse+0x1d60>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    2ecf <KnotAnalyse+0x1d3f>
mov    -0x78(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x8(%rax),%eax
mov    -0x70(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jne    2dee <KnotAnalyse+0x1c5e>
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x8(%rax),%eax
mov    -0x70(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    2e2e <KnotAnalyse+0x1c9e>
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    -0x70(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jne    2e73 <KnotAnalyse+0x1ce3>
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%eax
mov    -0x70(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jne    2ebc <KnotAnalyse+0x1d2c>
mov    -0x140(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    2ec1 <KnotAnalyse+0x1d31>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    2da6 <KnotAnalyse+0x1c16>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
cvtsi2sdl -0x38(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    2ef5 <KnotAnalyse+0x1d65>
mov    -0x70(%rbp),%rdi
mov    -0x64(%rbp),%esi
mov    $0x0,%al
call   1080 <matrix_int_free@plt>
mov    -0x78(%rbp),%rdi
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
mov    $0x0,%al
call   1080 <matrix_int_free@plt>
mov    -0x140(%rbp),%rdi
mov    $0x0,%al
call   1060 <vector_double_free@plt>
mov    -0x1d0(%rbp),%rdi
mov    $0x0,%al
call   1060 <vector_double_free@plt>
mov    -0x48(%rbp),%eax
add    $0x1e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<KnotAnalyse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x100(%rsp)
mov    %r8,0x108(%rsp)
mov    %rcx,0x110(%rsp)
mov    %rdx,0x8(%rsp)
mov    %esi,%r12d
mov    %rdi,%rbp
lea    -0x1(%r12),%r14d
mov    %r14d,%eax
shr    $0x1f,%eax
add    %r12d,%eax
add    $0xffffffff,%eax
sar    %eax
add    $0xffffffff,%eax
lea    -0x2(%r12),%ebx
imul   %eax,%ebx
mov    %ebx,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1050 <matrix_int_calloc@plt>
mov    %eax,%r15d
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <vector_int_alloc@plt>
mov    %eax,0xcc(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <vector_int_alloc@plt>
mov    %eax,0xc8(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <vector_int_alloc@plt>
mov    %eax,0xc4(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <vector_int_alloc@plt>
mov    %eax,0xc0(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <vector_int_alloc@plt>
mov    %eax,0xbc(%rsp)
mov    %r14d,0x8c(%rsp)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <vector_int_alloc@plt>
mov    %eax,0xb8(%rsp)
mov    %ebx,0x90(%rsp)
mov    %ebx,%edi
mov    %r12,%r14
xor    %eax,%eax
call   1090 <vector_double_alloc@plt>
mov    %eax,%r12d
lea    (%r14,%r14,2),%r13d
mov    %r13d,%edi
xor    %eax,%eax
call   1090 <vector_double_alloc@plt>
mov    %eax,%ebx
movslq %r13d,%r13
movsd  -0x18(%rbp,%r13,8),%xmm10
movsd  -0x8(%rbp,%r13,8),%xmm3
subsd  0x0(%rbp),%xmm10
subsd  0x10(%rbp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm10,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12c9 <KnotAnalyse+0x139>
sqrtsd %xmm0,%xmm0
jmp    12e8 <KnotAnalyse+0x158>
movapd %xmm10,0x30(%rsp)
movapd %xmm3,0x50(%rsp)
call   10a0 <sqrt@plt>
movapd 0x50(%rsp),%xmm3
movapd 0x30(%rsp),%xmm10
movslq %ebx,%r8
lea    -0x1(%r13),%rax
mov    %r14d,%ebx
test   %r14d,%r14d
jle    13b6 <KnotAnalyse+0x226>
divsd  %xmm0,%xmm3
divsd  %xmm0,%xmm10
movapd 0x1cf3(%rip),%xmm11
xorpd  %xmm10,%xmm11
cmp    $0x1,%r14d
je     133d <KnotAnalyse+0x1ad>
lea    0x0(,%rbx,8),%rcx
lea    (%rcx,%rcx,2),%rcx
lea    (%rcx,%rbp,1),%rdx
cmp    %rdx,%r8
jae    2373 <KnotAnalyse+0x11e3>
add    %r8,%rcx
cmp    %rbp,%rcx
jbe    2373 <KnotAnalyse+0x11e3>
xor    %ecx,%ecx
lea    (%rcx,%rcx,2),%rdx
lea    0x10(,%rdx,8),%rdx
mov    %rbx,%rsi
sub    %rcx,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,1),%xmm1
mulsd  %xmm11,%xmm1
movsd  -0x10(%rbp,%rdx,1),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,-0x10(%r8,%rdx,1)
movsd  -0x8(%rbp,%rdx,1),%xmm1
movsd  %xmm1,-0x8(%r8,%rdx,1)
movsd  0x0(%rbp,%rdx,1),%xmm1
mulsd  %xmm3,%xmm1
movsd  -0x10(%rbp,%rdx,1),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r8,%rdx,1)
add    $0x18,%rdx
add    $0xffffffffffffffff,%rsi
jne    1360 <KnotAnalyse+0x1d0>
movsd  -0x10(%r8,%r13,8),%xmm4
subsd  0x8(%r8),%xmm4
movsd  (%r8,%rax,8),%xmm5
subsd  0x10(%r8),%xmm5
movapd %xmm5,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %r8,0x98(%rsp)
jb     13fb <KnotAnalyse+0x26b>
sqrtsd %xmm0,%xmm0
jmp    1420 <KnotAnalyse+0x290>
movapd %xmm4,0x30(%rsp)
movsd  %xmm5,0x50(%rsp)
call   10a0 <sqrt@plt>
movsd  0x50(%rsp),%xmm5
movapd 0x30(%rsp),%xmm4
mov    0x98(%rsp),%r8
movslq %r15d,%rax
mov    %rax,0x18(%rsp)
movslq %r12d,%rax
mov    %rax,0x20(%rsp)
xor    %r15d,%r15d
mov    $0x0,%esi
test   %r14d,%r14d
jle    1a1a <KnotAnalyse+0x88a>
divsd  %xmm0,%xmm5
divsd  %xmm0,%xmm4
movapd 0x1baf(%rip),%xmm0
xorpd  %xmm4,%xmm0
shl    $0x3,%rbx
lea    (%rbx,%rbx,2),%rax
xor    %ecx,%ecx
nop
movsd  0x10(%r8,%rcx,1),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  0x8(%r8,%rcx,1),%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%r8,%rcx,1)
mulsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x10(%r8,%rcx,1)
add    $0x18,%rcx
cmp    %rcx,%rax
jne    1460 <KnotAnalyse+0x2d0>
xor    %esi,%esi
cmp    $0x4,%r14d
jl     1a1a <KnotAnalyse+0x88a>
lea    -0x3(%r14),%eax
mov    %rax,0x120(%rsp)
mov    0x8(%rsp),%rsi
lea    0x2(%rsi),%eax
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
lea    (%rax,%rax,2),%eax
neg    %eax
add    %esi,%eax
add    $0x2,%eax
lea    0x1(%rsi),%ecx
movslq %ecx,%rcx
imul   $0x55555556,%rcx,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
neg    %ecx
add    %esi,%ecx
add    $0x1,%ecx
movslq %ecx,%rbp
movslq %eax,%r13
movslq %esi,%rax
mov    %rax,0x50(%rsp)
mov    0x8c(%rsp),%eax
mov    %rax,0x118(%rsp)
neg    %r14d
xor    %edi,%edi
movl   $0x2,0x94(%rsp)
xorpd  %xmm14,%xmm14
mov    %r8,%r12
xor    %esi,%esi
mov    %r14,0x10(%rsp)
jmp    1584 <KnotAnalyse+0x3f4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xb0(%rsp),%rdi
add    $0x1,%rdi
addl   $0x1,0x94(%rsp)
01
mov    0x128(%rsp),%r12
add    $0x18,%r12
cmp    0x120(%rsp),%rdi
mov    $0x0,%r15d
je     1a1a <KnotAnalyse+0x88a>
lea    0x2(%rdi),%rax
cmp    0x118(%rsp),%rax
mov    %rdi,0xb0(%rsp)
mov    %r12,0x128(%rsp)
jae    1550 <KnotAnalyse+0x3c0>
lea    (%rdi,%rdi,2),%rax
lea    (%rax,%rbp,1),%rcx
movsd  (%r8,%rcx,8),%xmm12
lea    (%rax,%r13,1),%rcx
movsd  (%r8,%rcx,8),%xmm13
mov    0x50(%rsp),%rbx
lea    (%rax,%rbx,1),%rcx
movsd  (%r8,%rcx,8),%xmm2
lea    0x3(%rdi,%rdi,2),%rcx
lea    0x3(%rbp,%rax,1),%rdx
movsd  (%r8,%rdx,8),%xmm8
add    %r13,%rax
add    $0x3,%rax
movsd  (%r8,%rax,8),%xmm9
add    %rbx,%rcx
movsd  (%r8,%rcx,8),%xmm3
movapd %xmm8,%xmm10
subsd  %xmm12,%xmm10
movapd %xmm9,%xmm0
subsd  %xmm13,%xmm0
movapd %xmm0,%xmm11
xorpd  0x19ef(%rip),%xmm11
movapd %xmm13,%xmm4
subsd  %xmm9,%xmm4
movapd %xmm12,%xmm1
subsd  %xmm8,%xmm1
divsd  %xmm1,%xmm4
movsd  %xmm4,0x78(%rsp)
mulsd  %xmm12,%xmm4
subsd  %xmm13,%xmm4
movsd  %xmm4,0x70(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm10,%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x68(%rsp)
movsd  %xmm2,0x80(%rsp)
subsd  %xmm2,%xmm3
movsd  %xmm3,0x28(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movapd %xmm0,0xe0(%rsp)
mov    0x94(%rsp),%eax
mov    %eax,%r15d
movsd  %xmm12,0xa8(%rsp)
movsd  %xmm13,0x48(%rsp)
movsd  %xmm8,(%rsp)
movsd  %xmm9,0xa0(%rsp)
movsd  %xmm10,0x40(%rsp)
movapd %xmm11,0xd0(%rsp)
jmp    17bd <KnotAnalyse+0x62d>
movapd %xmm3,%xmm0
movapd %xmm4,0xf0(%rsp)
call   10a0 <sqrt@plt>
movapd 0xf0(%rsp),%xmm4
xorpd  %xmm14,%xmm14
mov    0x98(%rsp),%r8
mov    %rbx,%rsi
mov    0x10(%rsp),%r14
movsd  0xa8(%rsp),%xmm12
movsd  0x48(%rsp),%xmm13
movsd  (%rsp),%xmm8
movsd  0xa0(%rsp),%xmm9
movsd  0x40(%rsp),%xmm10
movapd 0xd0(%rsp),%xmm11
movsd  0x8(%rsp),%xmm2
movsd  0x30(%rsp),%xmm3
movsd  0x28(%rsp),%xmm1
mulsd  %xmm4,%xmm1
addsd  0x80(%rsp),%xmm1
subsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
xor    %eax,%eax
ucomisd %xmm2,%xmm1
seta   %al
lea    -0x1(%rax,%rax,1),%eax
movslq %esi,%rsi
mov    0x18(%rsp),%rcx
mov    (%rcx,%rsi,8),%rcx
mov    %eax,0x8(%rcx)
lea    (%rsi,%rsi,1),%eax
cltq
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
unpcklpd %xmm0,%xmm4
movapd 0xe0(%rsp),%xmm0
unpcklpd %xmm1,%xmm0
addpd  %xmm4,%xmm0
mov    0x20(%rsp),%rcx
movupd %xmm0,(%rcx,%rax,8)
add    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x18,%r12
lea    (%r14,%r15,1),%eax
add    $0x1,%eax
mov    %r15d,%ecx
add    $0x1,%ecx
mov    %ecx,%r15d
cmp    $0xffffffff,%eax
je     1550 <KnotAnalyse+0x3c0>
movsd  0x30(%r12,%rbp,8),%xmm7
movsd  0x48(%r12,%rbp,8),%xmm5
movsd  0x30(%r12,%r13,8),%xmm6
movsd  0x48(%r12,%r13,8),%xmm15
movapd %xmm6,%xmm0
subsd  %xmm15,%xmm0
movapd %xmm7,%xmm1
subsd  %xmm5,%xmm1
divsd  %xmm1,%xmm0
movapd %xmm12,%xmm2
subsd  %xmm7,%xmm2
movapd %xmm13,%xmm1
subsd  %xmm6,%xmm1
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm1,%xmm3
ucomisd %xmm14,%xmm3
setbe  %al
movapd %xmm8,%xmm3
subsd  %xmm7,%xmm3
movapd %xmm9,%xmm4
subsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm3
subsd  %xmm4,%xmm3
ucomisd %xmm14,%xmm3
seta   %cl
xor    %al,%cl
jne    17a0 <KnotAnalyse+0x610>
divsd  %xmm2,%xmm1
movapd %xmm5,%xmm2
subsd  %xmm12,%xmm2
movapd %xmm15,%xmm3
subsd  %xmm13,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm3,%xmm2
ucomisd %xmm14,%xmm2
seta   %al
mulsd  %xmm10,%xmm1
addsd  %xmm11,%xmm1
ucomisd %xmm14,%xmm1
setbe  %cl
cmp    %al,%cl
je     17a0 <KnotAnalyse+0x610>
movapd %xmm13,%xmm1
subsd  %xmm15,%xmm1
movapd %xmm12,%xmm2
subsd  %xmm5,%xmm2
divsd  %xmm2,%xmm1
movapd %xmm7,%xmm2
subsd  %xmm12,%xmm2
movapd %xmm6,%xmm3
subsd  %xmm13,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm3,%xmm2
ucomisd %xmm14,%xmm2
seta   %al
mulsd  %xmm10,%xmm1
addsd  %xmm11,%xmm1
ucomisd %xmm14,%xmm1
setbe  %cl
cmp    %al,%cl
je     17a0 <KnotAnalyse+0x610>
mov    0x50(%rsp),%rax
movsd  0x30(%r12,%rax,8),%xmm8
movsd  0x48(%r12,%rax,8),%xmm4
movsd  0x78(%rsp),%xmm2
movapd %xmm2,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm0
subsd  %xmm6,%xmm0
movsd  0x70(%rsp),%xmm3
subsd  %xmm0,%xmm3
divsd  %xmm1,%xmm3
movapd %xmm3,%xmm0
subsd  %xmm12,%xmm0
mulsd  %xmm0,%xmm2
addsd  %xmm13,%xmm2
movapd %xmm2,%xmm1
subsd  %xmm13,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
divsd  0x68(%rsp),%xmm0
ucomisd %xmm14,%xmm0
movsd  %xmm4,0x8(%rsp)
movsd  %xmm8,0x30(%rsp)
mov    %rsi,%rbx
jb     1956 <KnotAnalyse+0x7c6>
xorps  %xmm4,%xmm4
sqrtsd %xmm0,%xmm4
jmp    19d2 <KnotAnalyse+0x842>
movapd %xmm6,0xf0(%rsp)
movapd %xmm7,0x170(%rsp)
movapd %xmm15,0x160(%rsp)
movapd %xmm5,0x150(%rsp)
movapd %xmm3,0x140(%rsp)
movapd %xmm2,0x130(%rsp)
call   10a0 <sqrt@plt>
movapd 0x130(%rsp),%xmm2
movapd 0x140(%rsp),%xmm3
movapd 0x150(%rsp),%xmm5
movapd 0x160(%rsp),%xmm15
movapd 0x170(%rsp),%xmm7
movapd 0xf0(%rsp),%xmm6
xorpd  %xmm14,%xmm14
movapd %xmm0,%xmm4
unpcklpd %xmm5,%xmm3
unpcklpd %xmm7,%xmm7
subpd  %xmm7,%xmm3
unpcklpd %xmm15,%xmm2
unpcklpd %xmm6,%xmm6
subpd  %xmm6,%xmm2
mulpd  %xmm2,%xmm2
mulpd  %xmm3,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
divsd  %xmm0,%xmm3
ucomisd %xmm14,%xmm3
jb     16bb <KnotAnalyse+0x52b>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    16db <KnotAnalyse+0x54b>
mov    %rsi,(%rsp)
lea    (%rsi,%rsi,1),%eax
mov    %eax,0xa0(%rsp)
lea    (%rsi,%rsi,1),%edi
add    $0x2,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1050 <matrix_int_calloc@plt>
mov    (%rsp),%rdi
movslq %eax,%r13
test   %edi,%edi
je     1a75 <KnotAnalyse+0x8e5>
mov    0x90(%rsp),%ebx
cmp    %ebx,%edi
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r12
jle    1a8d <KnotAnalyse+0x8fd>
lea    0x15af(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xfffffffe,%r15d
mov    %ebx,%esi
jmp    2327 <KnotAnalyse+0x1197>
mov    0x90(%rsp),%eax
mov    %eax,%esi
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r12
jmp    2327 <KnotAnalyse+0x1197>
test   %edi,%edi
jle    1bdd <KnotAnalyse+0xa4d>
mov    %edi,%r8d
mov    $0x3,%r10d
xor    %r9d,%r9d
mov    %r8,%r11
mov    %r12,%rsi
jmp    1ac5 <KnotAnalyse+0x935>
nopl   0x0(%rax)
add    $0x2,%r10d
add    $0x8,%rsi
add    $0xffffffffffffffff,%r11
cmp    %r8,%r9
je     1b68 <KnotAnalyse+0x9d8>
mov    %r9,%rax
mov    (%r12,%r9,8),%rcx
addl   $0x1,(%rcx)
addl   $0x2,0x4(%rcx)
add    $0x1,%r9
cmp    %r8,%r9
jae    1ab0 <KnotAnalyse+0x920>
lea    0x4(%rcx),%rdx
shl    $0x4,%rax
movsd  (%r14,%rax,1),%xmm0
movsd  0x8(%r14,%rax,1),%xmm1
mov    $0x1,%eax
mov    %r10d,%edi
jmp    1b0f <KnotAnalyse+0x97f>
nopl   0x0(%rax,%rax,1)
addl   $0x1,(%rbx)
add    $0x2,%edi
add    $0x1,%rax
cmp    %rax,%r11
je     1ab0 <KnotAnalyse+0x920>
lea    -0x1(%rdi),%ebx
movsd  (%r14,%rbx,8),%xmm2
ucomisd %xmm2,%xmm0
mov    %rcx,%rbx
ja     1b25 <KnotAnalyse+0x995>
mov    (%rsi,%rax,8),%rbx
addl   $0x1,(%rbx)
mov    %edi,%ebx
movsd  (%r14,%rbx,8),%xmm3
ucomisd %xmm3,%xmm0
mov    %rcx,%rbp
ja     1b41 <KnotAnalyse+0x9b1>
mov    (%rsi,%rax,8),%rbp
add    $0x4,%rbp
addl   $0x1,0x0(%rbp)
ucomisd %xmm2,%xmm1
mov    %rdx,%rbx
ja     1b52 <KnotAnalyse+0x9c2>
mov    (%rsi,%rax,8),%rbx
addl   $0x1,(%rbx)
ucomisd %xmm3,%xmm1
mov    %rdx,%rbx
ja     1b00 <KnotAnalyse+0x970>
mov    (%rsi,%rax,8),%rbx
add    $0x4,%rbx
jmp    1b00 <KnotAnalyse+0x970>
mov    (%rsp),%rdi
test   %edi,%edi
jle    1bdd <KnotAnalyse+0xa4d>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rcx
movslq (%rcx),%rdx
mov    0x4(%rcx),%esi
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,(%rdx)
movslq (%rcx),%rdx
mov    0x8(%rcx),%esi
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,0x4(%rdx)
movslq (%rcx),%rdx
mov    0x0(%r13,%rdx,8),%rsi
mov    %edx,0x8(%rsi)
mov    (%rcx),%edx
movslq 0x4(%rcx),%rsi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edx,(%rsi)
xor    %edx,%edx
sub    0x8(%rcx),%edx
movslq 0x4(%rcx),%rsi
mov    0x0(%r13,%rsi,8),%rsi
mov    %edx,0x4(%rsi)
movslq 0x4(%rcx),%rcx
mov    0x0(%r13,%rcx,8),%rdx
mov    %ecx,0x8(%rdx)
add    $0x1,%rax
cmp    %rax,%r8
jne    1b80 <KnotAnalyse+0x9f0>
movslq 0xcc(%rsp),%r11
movslq 0xc8(%rsp),%rax
mov    %rax,0xe0(%rsp)
movslq 0xc4(%rsp),%rax
mov    %rax,0x30(%rsp)
movslq 0xc0(%rsp),%rax
mov    %rax,0x28(%rsp)
movslq 0xbc(%rsp),%rax
mov    %rax,0x8(%rsp)
movslq 0xb8(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    $0x1,%r14d
xor    %eax,%eax
movl   $0x0,0xd0(%rsp)
movl   $0x0,0x48(%rsp)
movl   $0x0,0x78(%rsp)
movl   $0x0,0x40(%rsp)
movl   $0x0,0x70(%rsp)
movl   $0x0,0x80(%rsp)
mov    %rdi,0x10(%rsp)
mov    %r11,0x68(%rsp)
mov    %eax,%r12d
mov    0x10(%rsp),%r15
jmp    1ca7 <KnotAnalyse+0xb17>
nopl   0x0(%rax,%rax,1)
cmp    %r8,%rbp
mov    %r11,%r15
mov    0x68(%rsp),%r11
mov    0xe0(%rsp),%r10
mov    0x28(%rsp),%r9
jge    1ed2 <KnotAnalyse+0xd42>
test   %r15d,%r15d
je     2316 <KnotAnalyse+0x1186>
lea    (%r15,%r15,1),%ebx
lea    (%r15,%r15,1),%eax
add    $0x1,%eax
movslq %eax,%r8
cmp    $0x2,%r8d
mov    $0x1,%eax
cmovge %r8d,%eax
mov    $0x1,%edx
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rcx
cmp    %rdx,%rax
je     1cf9 <KnotAnalyse+0xb69>
mov    0x0(%r13,%rcx,8),%rdx
mov    (%rdx),%esi
lea    0x1(%rcx),%rdx
cmp    %rsi,%rdx
jne    1cd0 <KnotAnalyse+0xb40>
cmp    $0x2,%r15d
jge    1dc0 <KnotAnalyse+0xc30>
add    $0xffffffff,%r15d
xor    %r12d,%r12d
cmp    %r8,%rcx
jl     1c9e <KnotAnalyse+0xb0e>
test   %r15d,%r15d
jle    2319 <KnotAnalyse+0x1189>
mov    %r15,%r11
lea    (%r15,%r15,1),%r10d
movslq %r10d,%r8
cmp    $0x3,%r8d
mov    $0x2,%eax
cmovge %r10d,%eax
mov    $0x1,%r9d
sub    %rax,%r9
mov    0x8(%r13),%rdi
mov    (%rdi),%edx
mov    $0x1,%r15b
mov    $0x2,%esi
jmp    1d62 <KnotAnalyse+0xbd2>
nopw   0x0(%rax,%rax,1)
cmp    %r8,%rbp
setl   %r15b
lea    0x1(%rbp),%rsi
lea    (%r9,%rbp,1),%rax
add    $0x1,%rax
mov    %ecx,%edx
mov    %rbx,%rdi
cmp    $0x2,%rax
je     1c80 <KnotAnalyse+0xaf0>
mov    %rsi,%rbp
mov    0x0(%r13,%rsi,8),%rbx
mov    (%rbx),%ecx
mov    %ecx,%eax
sub    %edx,%eax
mov    %eax,%esi
neg    %esi
cmovs  %eax,%esi
cmp    $0x1,%esi
jne    1d40 <KnotAnalyse+0xbb0>
mov    0x4(%rdi),%eax
cmp    0x4(%rbx),%eax
jne    1d40 <KnotAnalyse+0xbb0>
cmp    %edx,%ecx
cmovl  %ecx,%edx
cmp    $0x3,%r11d
jge    1e40 <KnotAnalyse+0xcb0>
add    $0xfffffffe,%r11d
xor    %r12d,%r12d
test   $0x1,%r15b
mov    %r11,%r15
mov    0x68(%rsp),%r11
mov    0xe0(%rsp),%r10
mov    0x28(%rsp),%r9
jne    1c9e <KnotAnalyse+0xb0e>
jmp    1ed2 <KnotAnalyse+0xd42>
xchg   %ax,%ax
add    $0xfffffffe,%ebx
lea    -0x1(%rdx),%r9
cmp    $0x2,%ebx
cmovl  %r14d,%ebx
add    $0x1,%ebx
mov    $0x1,%edi
mov    $0x1,%r10d
sub    %rbx,%r10
jmp    1e0b <KnotAnalyse+0xc7b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xfffffffe,%eax
mov    %eax,(%rbx)
lea    (%r10,%rdi,1),%rax
add    $0x1,%rax
add    $0x1,%rdi
cmp    $0x1,%rax
je     1cf2 <KnotAnalyse+0xb62>
cmp    %r9,%rdi
jae    1e20 <KnotAnalyse+0xc90>
mov    0x0(%r13,%rdi,8),%rbx
mov    (%rbx),%eax
cmp    %edx,%eax
jle    1df5 <KnotAnalyse+0xc65>
jmp    1df0 <KnotAnalyse+0xc60>
nopl   (%rax)
mov    0x0(%r13,%rdi,8),%rbx
mov    0x10(%r13,%rdi,8),%rsi
mov    (%rsi),%eax
mov    %eax,(%rbx)
mov    0x4(%rsi),%ebp
mov    %ebp,0x4(%rbx)
mov    0x8(%rsi),%esi
mov    %esi,0x8(%rbx)
cmp    %edx,%eax
jle    1df5 <KnotAnalyse+0xc65>
jmp    1df0 <KnotAnalyse+0xc60>
add    $0xfffffffc,%r10d
lea    -0x3(%rdx),%eax
add    $0x1,%edx
lea    -0x1(%rbp),%r8
movslq %eax,%rbx
cmp    $0x2,%r10d
cmovl  %r14d,%r10d
xor    %eax,%eax
jmp    1e72 <KnotAnalyse+0xce2>
nopl   (%rax)
add    %eax,%r9d
mov    %r9d,(%rdi)
mov    %rsi,%rax
cmp    %rsi,%r10
je     1d93 <KnotAnalyse+0xc03>
lea    0x1(%rax),%rsi
cmp    %rbx,%rsi
jle    1e90 <KnotAnalyse+0xd00>
mov    0x8(%r13,%rax,8),%rdi
mov    0x28(%r13,%rax,8),%rax
jmp    1eaa <KnotAnalyse+0xd1a>
nopw   0x0(%rax,%rax,1)
cmp    %r8,%rsi
jae    1ea0 <KnotAnalyse+0xd10>
mov    0x8(%r13,%rax,8),%rdi
mov    (%rdi),%r9d
jmp    1ebc <KnotAnalyse+0xd2c>
nop
mov    0x8(%r13,%rax,8),%rdi
mov    0x18(%r13,%rax,8),%rax
mov    (%rax),%r9d
mov    %r9d,(%rdi)
mov    0x4(%rax),%ecx
mov    %ecx,0x4(%rdi)
mov    0x8(%rax),%eax
mov    %eax,0x8(%rdi)
mov    $0xfffffffc,%eax
cmp    %edx,%r9d
jg     1e60 <KnotAnalyse+0xcd0>
mov    $0xfffffffe,%eax
cmp    %ebp,%r9d
jg     1e60 <KnotAnalyse+0xcd0>
jmp    1e66 <KnotAnalyse+0xcd6>
test   %r15d,%r15d
jle    2319 <KnotAnalyse+0x1189>
mov    %r12,0xb0(%rsp)
mov    %r15,0x10(%rsp)
add    %r15d,%r15d
cmp    $0x3,%r15d
mov    $0x2,%eax
cmovge %r15d,%eax
mov    %rax,0xa8(%rsp)
mov    0x8(%r13),%rax
xor    %edx,%edx
mov    $0x1,%r14d
jmp    1f1e <KnotAnalyse+0xd8e>
xchg   %ax,%ax
cmp    0xa8(%rsp),%r14
je     20c8 <KnotAnalyse+0xf38>
mov    %r14,%r12
mov    %rax,%rcx
mov    0x4(%rax),%ebp
add    $0x1,%r14
mov    0x8(%r13,%r12,8),%rax
cmp    0x4(%rax),%ebp
jne    1f10 <KnotAnalyse+0xd80>
mov    $0xffffffff,%r8d
jmp    1f4f <KnotAnalyse+0xdbf>
nopl   (%rax)
add    $0x1,%edx
lea    0x2(%r8),%ebp
test   %r8d,%r8d
mov    %ebp,%r8d
jns    1f10 <KnotAnalyse+0xd80>
mov    (%rcx),%ebp
cmp    %r15d,%ebp
jne    1f60 <KnotAnalyse+0xdd0>
cmp    $0x1,%r8d
je     2003 <KnotAnalyse+0xe73>
add    %r8d,%ebp
movslq %ebp,%rbp
mov    0x0(%r13,%rbp,8),%rbp
mov    (%rax),%ebx
add    $0xffffffff,%ebx
cmp    %ebx,0x0(%rbp)
jne    2003 <KnotAnalyse+0xe73>
movslq %edx,%rbp
mov    %r12d,(%r11,%rbp,4)
mov    (%rcx),%ebx
mov    %ebx,(%r9,%rbp,4)
mov    %r14d,(%r10,%rbp,4)
mov    (%rax),%ebx
mov    0x8(%rsp),%rsi
mov    %ebx,(%rsi,%rbp,4)
mov    (%r9,%rbp,4),%ebx
add    %r8d,%ebx
mov    0x30(%rsp),%r9
mov    %ebx,(%r9,%rbp,4)
mov    0x28(%rsp),%r9
mov    (%rsi,%rbp,4),%ebx
add    $0xffffffff,%ebx
mov    0x50(%rsp),%rsi
mov    %ebx,(%rsi,%rbp,4)
mov    0x80(%rsp),%esi
cmp    %esi,(%r11,%rbp,4)
jne    2000 <KnotAnalyse+0xe70>
mov    0x78(%rsp),%esi
cmp    %esi,(%r9,%rbp,4)
jne    2000 <KnotAnalyse+0xe70>
mov    0x70(%rsp),%esi
cmp    %esi,(%r10,%rbp,4)
jne    2000 <KnotAnalyse+0xe70>
mov    0x8(%rsp),%rsi
mov    0x48(%rsp),%edi
cmp    %edi,(%rsi,%rbp,4)
jne    2000 <KnotAnalyse+0xe70>
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%edi
cmp    %edi,(%rsi,%rbp,4)
jne    2000 <KnotAnalyse+0xe70>
cmp    0xd0(%rsp),%ebx
je     2003 <KnotAnalyse+0xe73>
nopl   (%rax)
add    $0x1,%edx
mov    (%rcx),%ebp
cmp    %r15d,%ebp
jne    2014 <KnotAnalyse+0xe84>
cmp    $0x1,%r8d
je     1f10 <KnotAnalyse+0xd80>
add    %r8d,%ebp
movslq %ebp,%rbp
mov    0x0(%r13,%rbp,8),%rbp
mov    (%rax),%ebx
add    $0x1,%ebx
cmp    %ebx,0x0(%rbp)
jne    1f43 <KnotAnalyse+0xdb3>
movslq %edx,%rbp
mov    %r12d,(%r11,%rbp,4)
mov    (%rcx),%ebx
mov    %ebx,(%r9,%rbp,4)
mov    %r14d,(%r10,%rbp,4)
mov    (%rax),%ebx
mov    0x8(%rsp),%rdi
mov    %ebx,(%rdi,%rbp,4)
mov    (%r9,%rbp,4),%ebx
add    %r8d,%ebx
mov    0x30(%rsp),%rsi
mov    %ebx,(%rsi,%rbp,4)
mov    (%rdi,%rbp,4),%ebx
add    $0x1,%ebx
mov    0x50(%rsp),%rsi
mov    %ebx,(%rsi,%rbp,4)
mov    0x80(%rsp),%esi
cmp    %esi,(%r11,%rbp,4)
jne    1f40 <KnotAnalyse+0xdb0>
mov    0x78(%rsp),%esi
cmp    %esi,(%r9,%rbp,4)
jne    1f40 <KnotAnalyse+0xdb0>
mov    0x70(%rsp),%esi
cmp    %esi,(%r10,%rbp,4)
jne    1f40 <KnotAnalyse+0xdb0>
mov    0x8(%rsp),%rsi
mov    0x48(%rsp),%edi
cmp    %edi,(%rsi,%rbp,4)
jne    1f40 <KnotAnalyse+0xdb0>
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%edi
cmp    %edi,(%rsi,%rbp,4)
jne    1f40 <KnotAnalyse+0xdb0>
cmp    0xd0(%rsp),%ebx
je     1f43 <KnotAnalyse+0xdb3>
jmp    1f40 <KnotAnalyse+0xdb0>
test   %edx,%edx
jle    2424 <KnotAnalyse+0x1294>
mov    %edx,%r12d
xor    %edx,%edx
jmp    20f2 <KnotAnalyse+0xf62>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %rdx,%r12
mov    0x28(%rsp),%r9
je     22f6 <KnotAnalyse+0x1166>
movslq (%r9,%rdx,4),%rax
mov    0x8(%rsp),%rcx
movslq (%rcx,%rdx,4),%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %esi,%edi
neg    %edi
cmovs  %esi,%edi
cmp    $0x1,%edi
je     21c6 <KnotAnalyse+0x1036>
mov    0x50(%rsp),%rsi
movslq (%rsi,%rdx,4),%r8
mov    (%r11,%rdx,4),%ebp
mov    %r8d,%esi
sub    %ebp,%esi
mov    %esi,%edi
neg    %edi
cmovs  %esi,%edi
cmp    $0x1,%edi
je     21c6 <KnotAnalyse+0x1036>
mov    0x30(%rsp),%rsi
mov    (%rsi,%rdx,4),%r9d
mov    (%r10,%rdx,4),%esi
mov    %r9d,%edi
sub    %esi,%edi
mov    %edi,%ebx
neg    %ebx
cmovs  %edi,%ebx
cmp    $0x1,%ebx
je     21c6 <KnotAnalyse+0x1036>
lea    (%r8,%r8,1),%edi
sub    %ecx,%edi
movslq %edi,%rdi
mov    0x0(%r13,%rdi,8),%rbx
lea    0x0(%rbp,%rbp,1),%edi
sub    %esi,%edi
cmp    %edi,(%rbx)
jne    2178 <KnotAnalyse+0xfe8>
mov    0x4(%rbx),%edi
mov    0x0(%r13,%rcx,8),%rbx
cmp    0x4(%rbx),%edi
je     21c6 <KnotAnalyse+0x1036>
lea    (%r9,%r9,1),%edi
sub    %eax,%edi
movslq %edi,%rdi
mov    0x0(%r13,%rdi,8),%rbx
add    %esi,%esi
sub    %ebp,%esi
cmp    %esi,(%rbx)
jne    219b <KnotAnalyse+0x100b>
mov    0x4(%rbx),%esi
mov    0x0(%r13,%rax,8),%rdi
cmp    0x4(%rdi),%esi
je     21c6 <KnotAnalyse+0x1036>
add    %ecx,%ecx
sub    %r8d,%ecx
movslq %ecx,%rcx
mov    0x0(%r13,%rcx,8),%rcx
add    %eax,%eax
sub    %r9d,%eax
cmp    %eax,(%rcx)
jne    20e0 <KnotAnalyse+0xf50>
mov    0x4(%rcx),%eax
mov    0x0(%r13,%r8,8),%rcx
cmp    0x4(%rcx),%eax
jne    20e0 <KnotAnalyse+0xf50>
xor    %r8d,%r8d
movslq %edx,%rcx
mov    0x50(%rsp),%r9
mov    (%r9,%rcx,4),%eax
movslq (%r11,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %eax,0x80(%rsp)
mov    %eax,(%rdx)
mov    0x30(%rsp),%rbp
mov    0x0(%rbp,%rcx,4),%eax
movslq (%r10,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %eax,0x70(%rsp)
mov    %eax,(%rdx)
mov    (%r10,%rcx,4),%eax
movslq 0x0(%rbp,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %eax,0x40(%rsp)
mov    %eax,(%rdx)
mov    0x8(%rsp),%rbx
mov    (%rbx,%rcx,4),%esi
mov    0x28(%rsp),%rax
movslq (%rax,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,0x78(%rsp)
mov    %esi,(%rdx)
mov    (%rax,%rcx,4),%esi
movslq (%rbx,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,0x48(%rsp)
mov    %esi,(%rdx)
mov    (%r11,%rcx,4),%esi
movslq (%r9,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,0xd0(%rsp)
mov    %esi,(%rdx)
movslq (%r10,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    0x4(%rdx),%esi
movslq (%r11,%rcx,4),%rdi
mov    0x0(%r13,%rdi,8),%rdi
mov    0x4(%rdi),%edi
mov    %edi,0x4(%rdx)
movslq (%r11,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,0x4(%rdx)
movslq (%rax,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    0x4(%rdx),%esi
movslq 0x0(%rbp,%rcx,4),%rdi
mov    0x0(%r13,%rdi,8),%rdi
mov    0x4(%rdi),%edi
mov    %edi,0x4(%rdx)
movslq 0x0(%rbp,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    %esi,0x4(%rdx)
movslq (%r9,%rcx,4),%rdx
mov    0x0(%r13,%rdx,8),%rdx
mov    0x4(%rdx),%esi
movslq (%rbx,%rcx,4),%rdi
mov    0x0(%r13,%rdi,8),%rdi
mov    0x4(%rdi),%edi
mov    %edi,0x4(%rdx)
movslq (%rbx,%rcx,4),%rcx
mov    0x0(%r13,%rcx,8),%rcx
mov    %esi,0x4(%rcx)
test   %r8b,%r8b
jne    2424 <KnotAnalyse+0x1294>
mov    0xb0(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    $0x31,%ecx
mov    $0x1,%r14d
jle    1c71 <KnotAnalyse+0xae1>
jmp    2418 <KnotAnalyse+0x1288>
xor    %eax,%eax
call   10b0 <rand@plt>
mov    0xe0(%rsp),%r10
mov    0x68(%rsp),%r11
cltd
idiv   %r12d
mov    $0x1,%r8b
jmp    21c9 <KnotAnalyse+0x1039>
xor    %r15d,%r15d
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r12
mov    (%rsp),%rsi
mov    %r12,%rdi
xor    %eax,%eax
call   1080 <matrix_int_free@plt>
mov    0xa0(%rsp),%esi
or     $0x1,%esi
mov    %r13,%rdi
xor    %eax,%eax
call   1080 <matrix_int_free@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <vector_double_free@plt>
mov    0x98(%rsp),%rdi
xor    %eax,%eax
call   1060 <vector_double_free@plt>
mov    %r15d,%eax
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
movapd %xmm11,%xmm8
unpcklpd %xmm11,%xmm8
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
movapd %xmm10,%xmm9
unpcklpd %xmm10,%xmm9
xor    %edx,%edx
mov    %rcx,%rsi
nopl   0x0(%rax)
movupd 0x0(%rbp,%rdx,1),%xmm4
movupd 0x10(%rbp,%rdx,1),%xmm5
movupd 0x20(%rbp,%rdx,1),%xmm6
movapd %xmm6,%xmm7
movsd  %xmm5,%xmm7
movsd  %xmm4,%xmm5
movapd %xmm0,%xmm2
mulpd  %xmm7,%xmm2
mulpd  %xmm8,%xmm7
movapd %xmm0,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm9,%xmm5
addpd  %xmm2,%xmm5
movsd  %xmm1,%xmm4
movsd  %xmm5,%xmm1
movsd  %xmm6,%xmm5
movupd %xmm5,0x20(%r8,%rdx,1)
movupd %xmm1,0x10(%r8,%rdx,1)
movupd %xmm4,(%r8,%rdx,1)
add    $0x30,%rdx
add    $0xfffffffffffffffe,%rsi
jne    23a0 <KnotAnalyse+0x1210>
cmp    %rbx,%rcx
je     13b6 <KnotAnalyse+0x226>
jmp    133f <KnotAnalyse+0x1af>
lea    0xc24(%rip),%rdi
call   1030 <puts@plt>
cmpl   $0x0,0x10(%rsp)
jle    24ef <KnotAnalyse+0x135f>
mov    (%rsp),%rsi
test   %esi,%esi
mov    0x108(%rsp),%r8
mov    0x100(%rsp),%r9
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r12
jle    24ca <KnotAnalyse+0x133a>
mov    0x8(%r13),%rax
mov    0x8(%rax),%eax
movslq %r15d,%rcx
mov    0x0(%r13,%rcx,8),%rcx
mov    0x8(%rcx),%ecx
mov    %esi,%edx
shl    $0x3,%rdx
xor    %ebx,%ebx
jmp    2476 <KnotAnalyse+0x12e6>
add    $0x8,%rbx
cmp    %rbx,%rdx
je     24ca <KnotAnalyse+0x133a>
mov    (%r12,%rbx,1),%rbp
mov    0x0(%rbp),%edi
cmp    %edi,%eax
jne    248c <KnotAnalyse+0x12fc>
movsd  (%r14,%rbx,2),%xmm0
movsd  %xmm0,(%r8)
mov    0x4(%rbp),%ebp
cmp    %ebp,%eax
jne    24a9 <KnotAnalyse+0x1319>
movsd  0x8(%r14,%rbx,2),%xmm0
movsd  %xmm0,(%r8)
cmp    %edi,%ecx
je     24ad <KnotAnalyse+0x131d>
cmp    %ebp,%ecx
jne    246d <KnotAnalyse+0x12dd>
jmp    24bc <KnotAnalyse+0x132c>
cmp    %edi,%ecx
jne    24a3 <KnotAnalyse+0x1313>
movsd  (%r14,%rbx,2),%xmm0
movsd  %xmm0,(%r9)
cmp    %ebp,%ecx
jne    246d <KnotAnalyse+0x12dd>
movsd  0x8(%r14,%rbx,2),%xmm0
movsd  %xmm0,(%r9)
jmp    246d <KnotAnalyse+0x12dd>
movsd  (%r9),%xmm0
subsd  (%r8),%xmm0
cvtsi2sdl 0x8c(%rsp),%xmm1
divsd  %xmm1,%xmm0
mov    0x110(%rsp),%rax
movsd  %xmm0,(%rax)
jmp    24fd <KnotAnalyse+0x136d>
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r12
mov    (%rsp),%rsi
mov    0x10(%rsp),%r15
jmp    2327 <KnotAnalyse+0x1197>

LLVM IR (-O0):
@.str = [51 x i8] c"Warning: Too many crossings, increase buffer size.\00"
@.str.1 = [42 x i8] c"\0AKnot Warning: Stuck performing R3 moves\0A\00"
define i32 @KnotAnalyse(double* %0, i32 %1, i32 %2, double* %3, double* %4, double* %5) {
%7 = alloca double*
%8 = alloca i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32**
%30 = alloca i32**
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32*
%35 = alloca i32*
%36 = alloca i32*
%37 = alloca i32*
%38 = alloca i32*
%39 = alloca i32*
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double*
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double*
store double* %0, double** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store double* %3, double** %10
store double* %4, double** %11
store double* %5, double** %12
store i32 0, i32* %20
store i32 0, i32* %41
store i32 0, i32* %42
store i32 0, i32* %43
store i32 0, i32* %44
store i32 0, i32* %45
store i32 0, i32* %46
store i32 0, i32* %47
%79 = load i32, i32* %8
%80 = sub nsw i32 %79, 1
store i32 %80, i32* %16
%81 = load i32, i32* %16
%82 = sdiv i32 %81, 2
%83 = sub nsw i32 %82, 1
%84 = load i32, i32* %16
%85 = sub nsw i32 %84, 1
%86 = mul nsw i32 %83, %85
store i32 %86, i32* %27
%87 = load i32, i32* %27
%88 = call i32 (i32, i32, ...) bitcast (i32 (...)* @matrix_int_calloc to i32 (i32, i32, ...)*)(i32 %87, i32 3)
%89 = sext i32 %88 to i64
%90 = inttoptr i64 %89 to i32**
store i32** %90, i32*** %29
%91 = load i32, i32* %16
%92 = call i32 (i32, ...) bitcast (i32 (...)* @vector_int_alloc to i32 (i32, ...)*)(i32 %91)
%93 = sext i32 %92 to i64
%94 = inttoptr i64 %93 to i32*
store i32* %94, i32** %34
%95 = load i32, i32* %16
%96 = call i32 (i32, ...) bitcast (i32 (...)* @vector_int_alloc to i32 (i32, ...)*)(i32 %95)
%97 = sext i32 %96 to i64
%98 = inttoptr i64 %97 to i32*
store i32* %98, i32** %35
%99 = load i32, i32* %16
%100 = call i32 (i32, ...) bitcast (i32 (...)* @vector_int_alloc to i32 (i32, ...)*)(i32 %99)
%101 = sext i32 %100 to i64
%102 = inttoptr i64 %101 to i32*
store i32* %102, i32** %36
%103 = load i32, i32* %16
%104 = call i32 (i32, ...) bitcast (i32 (...)* @vector_int_alloc to i32 (i32, ...)*)(i32 %103)
%105 = sext i32 %104 to i64
%106 = inttoptr i64 %105 to i32*
store i32* %106, i32** %37
%107 = load i32, i32* %16
%108 = call i32 (i32, ...) bitcast (i32 (...)* @vector_int_alloc to i32 (i32, ...)*)(i32 %107)
%109 = sext i32 %108 to i64
%110 = inttoptr i64 %109 to i32*
store i32* %110, i32** %38
%111 = load i32, i32* %16
%112 = call i32 (i32, ...) bitcast (i32 (...)* @vector_int_alloc to i32 (i32, ...)*)(i32 %111)
%113 = sext i32 %112 to i64
%114 = inttoptr i64 %113 to i32*
store i32* %114, i32** %39
%115 = load i32, i32* %27
%116 = call i32 (i32, ...) bitcast (i32 (...)* @vector_double_alloc to i32 (i32, ...)*)(i32 %115)
%117 = sext i32 %116 to i64
%118 = inttoptr i64 %117 to double*
store double* %118, double** %60
%119 = load i32, i32* %8
%120 = mul nsw i32 3, %119
%121 = call i32 (i32, ...) bitcast (i32 (...)* @vector_double_alloc to i32 (i32, ...)*)(i32 %120)
%122 = sext i32 %121 to i64
%123 = inttoptr i64 %122 to double*
store double* %123, double** %78
%124 = load double*, double** %7
%125 = load i32, i32* %8
%126 = mul nsw i32 3, %125
%127 = sub nsw i32 %126, 3
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds double, double* %124, i64 %128
%130 = load double, double* %129
%131 = load double*, double** %7
%132 = getelementptr inbounds double, double* %131, i64 0
%133 = load double, double* %132
%134 = fsub double %130, %133
store double %134, double* %71
%135 = load double*, double** %7
%136 = load i32, i32* %8
%137 = mul nsw i32 3, %136
%138 = sub nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds double, double* %135, i64 %139
%141 = load double, double* %140
%142 = load double*, double** %7
%143 = getelementptr inbounds double, double* %142, i64 2
%144 = load double, double* %143
%145 = fsub double %141, %144
store double %145, double* %73
%146 = load double, double* %71
%147 = load double, double* %71
%148 = load double, double* %73
%149 = load double, double* %73
%150 = fmul double %148, %149
%151 = call double @llvm.fmuladd.f64(double %146, double %147, double %150)
%152 = call double @sqrt(double %151)
store double %152, double* %74
%153 = load double, double* %73
%154 = load double, double* %74
%155 = fdiv double %153, %154
store double %155, double* %76
%156 = load double, double* %71
%157 = load double, double* %74
%158 = fdiv double %156, %157
store double %158, double* %77
store i32 0, i32* %13
br label %159
159: ; preds = %226, %6
%160 = load i32, i32* %13
%161 = load i32, i32* %8
%162 = icmp slt i32 %160, %161
br i1 %162, label %163, label %229
163: ; preds = %159
%164 = load double, double* %76
%165 = load double*, double** %7
%166 = load i32, i32* %13
%167 = mul nsw i32 3, %166
%168 = add nsw i32 %167, 0
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %165, i64 %169
%171 = load double, double* %170
%172 = load double, double* %77
%173 = load double*, double** %7
%174 = load i32, i32* %13
%175 = mul nsw i32 3, %174
%176 = add nsw i32 %175, 2
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds double, double* %173, i64 %177
%179 = load double, double* %178
%180 = fmul double %172, %179
%181 = fneg double %180
%182 = call double @llvm.fmuladd.f64(double %164, double %171, double %181)
%183 = load double*, double** %78
%184 = load i32, i32* %13
%185 = mul nsw i32 3, %184
%186 = add nsw i32 %185, 0
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double, double* %183, i64 %187
store double %182, double* %188
%189 = load double*, double** %7
%190 = load i32, i32* %13
%191 = mul nsw i32 3, %190
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %189, i64 %193
%195 = load double, double* %194
%196 = load double*, double** %78
%197 = load i32, i32* %13
%198 = mul nsw i32 3, %197
%199 = add nsw i32 %198, 1
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %196, i64 %200
store double %195, double* %201
%202 = load double, double* %77
%203 = load double*, double** %7
%204 = load i32, i32* %13
%205 = mul nsw i32 3, %204
%206 = add nsw i32 %205, 0
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %203, i64 %207
%209 = load double, double* %208
%210 = load double, double* %76
%211 = load double*, double** %7
%212 = load i32, i32* %13
%213 = mul nsw i32 3, %212
%214 = add nsw i32 %213, 2
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %211, i64 %215
%217 = load double, double* %216
%218 = fmul double %210, %217
%219 = call double @llvm.fmuladd.f64(double %202, double %209, double %218)
%220 = load double*, double** %78
%221 = load i32, i32* %13
%222 = mul nsw i32 3, %221
%223 = add nsw i32 %222, 2
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %220, i64 %224
store double %219, double* %225
br label %226
226: ; preds = %163
%227 = load i32, i32* %13
%228 = add nsw i32 %227, 1
store i32 %228, i32* %13
br label %159
229: ; preds = %159
%230 = load double*, double** %78
%231 = load i32, i32* %8
%232 = mul nsw i32 3, %231
%233 = sub nsw i32 %232, 2
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double, double* %230, i64 %234
%236 = load double, double* %235
%237 = load double*, double** %78
%238 = getelementptr inbounds double, double* %237, i64 1
%239 = load double, double* %238
%240 = fsub double %236, %239
store double %240, double* %72
%241 = load double*, double** %78
%242 = load i32, i32* %8
%243 = mul nsw i32 3, %242
%244 = sub nsw i32 %243, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %241, i64 %245
%247 = load double, double* %246
%248 = load double*, double** %78
%249 = getelementptr inbounds double, double* %248, i64 2
%250 = load double, double* %249
%251 = fsub double %247, %250
store double %251, double* %73
%252 = load double, double* %72
%253 = load double, double* %72
%254 = load double, double* %73
%255 = load double, double* %73
%256 = fmul double %254, %255
%257 = call double @llvm.fmuladd.f64(double %252, double %253, double %256)
%258 = call double @sqrt(double %257)
store double %258, double* %75
%259 = load double, double* %73
%260 = load double, double* %75
%261 = fdiv double %259, %260
store double %261, double* %76
%262 = load double, double* %72
%263 = load double, double* %75
%264 = fdiv double %262, %263
store double %264, double* %77
store i32 0, i32* %13
br label %265
265: ; preds = %319, %229
%266 = load i32, i32* %13
%267 = load i32, i32* %8
%268 = icmp slt i32 %266, %267
br i1 %268, label %269, label %322
269: ; preds = %265
%270 = load double, double* %76
%271 = load double*, double** %78
%272 = load i32, i32* %13
%273 = mul nsw i32 3, %272
%274 = add nsw i32 %273, 1
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %271, i64 %275
%277 = load double, double* %276
%278 = load double, double* %77
%279 = load double*, double** %78
%280 = load i32, i32* %13
%281 = mul nsw i32 3, %280
%282 = add nsw i32 %281, 2
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %279, i64 %283
%285 = load double, double* %284
%286 = fmul double %278, %285
%287 = fneg double %286
%288 = call double @llvm.fmuladd.f64(double %270, double %277, double %287)
%289 = load double*, double** %78
%290 = load i32, i32* %13
%291 = mul nsw i32 3, %290
%292 = add nsw i32 %291, 1
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds double, double* %289, i64 %293
store double %288, double* %294
%295 = load double, double* %77
%296 = load double*, double** %78
%297 = load i32, i32* %13
%298 = mul nsw i32 3, %297
%299 = add nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %296, i64 %300
%302 = load double, double* %301
%303 = load double, double* %76
%304 = load double*, double** %78
%305 = load i32, i32* %13
%306 = mul nsw i32 3, %305
%307 = add nsw i32 %306, 2
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds double, double* %304, i64 %308
%310 = load double, double* %309
%311 = fmul double %303, %310
%312 = call double @llvm.fmuladd.f64(double %295, double %302, double %311)
%313 = load double*, double** %78
%314 = load i32, i32* %13
%315 = mul nsw i32 3, %314
%316 = add nsw i32 %315, 2
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %313, i64 %317
store double %312, double* %318
br label %319
319: ; preds = %269
%320 = load i32, i32* %13
%321 = add nsw i32 %320, 1
store i32 %321, i32* %13
br label %265
322: ; preds = %265
%323 = load i32, i32* %9
store i32 %323, i32* %19
%324 = load i32, i32* %19
%325 = add nsw i32 %324, 1
%326 = srem i32 %325, 3
store i32 %326, i32* %17
%327 = load i32, i32* %19
%328 = add nsw i32 %327, 2
%329 = srem i32 %328, 3
store i32 %329, i32* %18
store i32 0, i32* %13
br label %330
330: ; preds = %683, %322
%331 = load i32, i32* %13
%332 = load i32, i32* %16
%333 = sub nsw i32 %332, 2
%334 = icmp slt i32 %331, %333
br i1 %334, label %335, label %686
335: ; preds = %330
%336 = load double*, double** %78
%337 = load i32, i32* %13
%338 = mul nsw i32 3, %337
%339 = load i32, i32* %17
%340 = add nsw i32 %338, %339
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds double, double* %336, i64 %341
%343 = load double, double* %342
store double %343, double* %49
%344 = load double*, double** %78
%345 = load i32, i32* %13
%346 = mul nsw i32 3, %345
%347 = load i32, i32* %18
%348 = add nsw i32 %346, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %344, i64 %349
%351 = load double, double* %350
store double %351, double* %51
%352 = load double*, double** %78
%353 = load i32, i32* %13
%354 = mul nsw i32 3, %353
%355 = load i32, i32* %19
%356 = add nsw i32 %354, %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds double, double* %352, i64 %357
%359 = load double, double* %358
store double %359, double* %65
%360 = load double*, double** %78
%361 = load i32, i32* %13
%362 = mul nsw i32 3, %361
%363 = add nsw i32 %362, 3
%364 = load i32, i32* %17
%365 = add nsw i32 %363, %364
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %360, i64 %366
%368 = load double, double* %367
store double %368, double* %48
%369 = load double*, double** %78
%370 = load i32, i32* %13
%371 = mul nsw i32 3, %370
%372 = add nsw i32 %371, 3
%373 = load i32, i32* %18
%374 = add nsw i32 %372, %373
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %369, i64 %375
%377 = load double, double* %376
store double %377, double* %50
%378 = load double*, double** %78
%379 = load i32, i32* %13
%380 = mul nsw i32 3, %379
%381 = add nsw i32 %380, 3
%382 = load i32, i32* %19
%383 = add nsw i32 %381, %382
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %378, i64 %384
%386 = load double, double* %385
store double %386, double* %66
%387 = load i32, i32* %13
%388 = add nsw i32 %387, 2
store i32 %388, i32* %14
br label %389
389: ; preds = %679, %335
%390 = load i32, i32* %14
%391 = load i32, i32* %16
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %682
393: ; preds = %389
%394 = load double*, double** %78
%395 = load i32, i32* %14
%396 = mul nsw i32 3, %395
%397 = load i32, i32* %17
%398 = add nsw i32 %396, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %394, i64 %399
%401 = load double, double* %400
store double %401, double* %53
%402 = load double*, double** %78
%403 = load i32, i32* %14
%404 = mul nsw i32 3, %403
%405 = load i32, i32* %18
%406 = add nsw i32 %404, %405
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double, double* %402, i64 %407
%409 = load double, double* %408
store double %409, double* %55
%410 = load double*, double** %78
%411 = load i32, i32* %14
%412 = mul nsw i32 3, %411
%413 = load i32, i32* %19
%414 = add nsw i32 %412, %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds double, double* %410, i64 %415
%417 = load double, double* %416
store double %417, double* %67
%418 = load double*, double** %78
%419 = load i32, i32* %14
%420 = mul nsw i32 3, %419
%421 = add nsw i32 %420, 3
%422 = load i32, i32* %17
%423 = add nsw i32 %421, %422
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds double, double* %418, i64 %424
%426 = load double, double* %425
store double %426, double* %52
%427 = load double*, double** %78
%428 = load i32, i32* %14
%429 = mul nsw i32 3, %428
%430 = add nsw i32 %429, 3
%431 = load i32, i32* %18
%432 = add nsw i32 %430, %431
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %427, i64 %433
%435 = load double, double* %434
store double %435, double* %54
%436 = load double*, double** %78
%437 = load i32, i32* %14
%438 = mul nsw i32 3, %437
%439 = add nsw i32 %438, 3
%440 = load i32, i32* %19
%441 = add nsw i32 %439, %440
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %436, i64 %442
%444 = load double, double* %443
store double %444, double* %68
%445 = load double, double* %55
%446 = load double, double* %54
%447 = fsub double %445, %446
%448 = load double, double* %53
%449 = load double, double* %52
%450 = fsub double %448, %449
%451 = fdiv double %447, %450
store double %451, double* %58
%452 = load double, double* %58
%453 = load double, double* %49
%454 = load double, double* %53
%455 = fsub double %453, %454
%456 = load double, double* %51
%457 = load double, double* %55
%458 = fsub double %456, %457
%459 = fneg double %458
%460 = call double @llvm.fmuladd.f64(double %452, double %455, double %459)
%461 = fcmp ogt double %460, 0.000000e+00
%462 = zext i1 %461 to i32
store i32 %462, i32* %23
%463 = load double, double* %58
%464 = load double, double* %48
%465 = load double, double* %53
%466 = fsub double %464, %465
%467 = load double, double* %50
%468 = load double, double* %55
%469 = fsub double %467, %468
%470 = fneg double %469
%471 = call double @llvm.fmuladd.f64(double %463, double %466, double %470)
%472 = fcmp ogt double %471, 0.000000e+00
%473 = zext i1 %472 to i32
store i32 %473, i32* %24
%474 = load i32, i32* %23
%475 = load i32, i32* %24
%476 = icmp eq i32 %474, %475
br i1 %476, label %477, label %478
477: ; preds = %393
br label %679
478: ; preds = %393
%479 = load double, double* %51
%480 = load double, double* %55
%481 = fsub double %479, %480
%482 = load double, double* %49
%483 = load double, double* %53
%484 = fsub double %482, %483
%485 = fdiv double %481, %484
store double %485, double* %56
%486 = load double, double* %56
%487 = load double, double* %52
%488 = load double, double* %49
%489 = fsub double %487, %488
%490 = load double, double* %54
%491 = load double, double* %51
%492 = fsub double %490, %491
%493 = fneg double %492
%494 = call double @llvm.fmuladd.f64(double %486, double %489, double %493)
%495 = fcmp ogt double %494, 0.000000e+00
%496 = zext i1 %495 to i32
store i32 %496, i32* %21
%497 = load double, double* %56
%498 = load double, double* %48
%499 = load double, double* %49
%500 = fsub double %498, %499
%501 = load double, double* %50
%502 = load double, double* %51
%503 = fsub double %501, %502
%504 = fneg double %503
%505 = call double @llvm.fmuladd.f64(double %497, double %500, double %504)
%506 = fcmp ogt double %505, 0.000000e+00
%507 = zext i1 %506 to i32
store i32 %507, i32* %25
%508 = load i32, i32* %25
%509 = load i32, i32* %21
%510 = icmp ne i32 %508, %509
br i1 %510, label %511, label %512
511: ; preds = %478
br label %679
512: ; preds = %478
%513 = load double, double* %51
%514 = load double, double* %54
%515 = fsub double %513, %514
%516 = load double, double* %49
%517 = load double, double* %52
%518 = fsub double %516, %517
%519 = fdiv double %515, %518
store double %519, double* %57
%520 = load double, double* %57
%521 = load double, double* %53
%522 = load double, double* %49
%523 = fsub double %521, %522
%524 = load double, double* %55
%525 = load double, double* %51
%526 = fsub double %524, %525
%527 = fneg double %526
%528 = call double @llvm.fmuladd.f64(double %520, double %523, double %527)
%529 = fcmp ogt double %528, 0.000000e+00
%530 = zext i1 %529 to i32
store i32 %530, i32* %22
%531 = load double, double* %57
%532 = load double, double* %48
%533 = load double, double* %49
%534 = fsub double %532, %533
%535 = load double, double* %50
%536 = load double, double* %51
%537 = fsub double %535, %536
%538 = fneg double %537
%539 = call double @llvm.fmuladd.f64(double %531, double %534, double %538)
%540 = fcmp ogt double %539, 0.000000e+00
%541 = zext i1 %540 to i32
store i32 %541, i32* %26
%542 = load i32, i32* %26
%543 = load i32, i32* %22
%544 = icmp ne i32 %542, %543
br i1 %544, label %545, label %546
545: ; preds = %512
br label %679
546: ; preds = %512
%547 = load double, double* %51
%548 = load double, double* %50
%549 = fsub double %547, %548
%550 = load double, double* %49
%551 = load double, double* %48
%552 = fsub double %550, %551
%553 = fdiv double %549, %552
store double %553, double* %59
%554 = load double, double* %59
%555 = load double, double* %49
%556 = load double, double* %51
%557 = fneg double %556
%558 = call double @llvm.fmuladd.f64(double %554, double %555, double %557)
%559 = load double, double* %58
%560 = load double, double* %53
%561 = load double, double* %55
%562 = fneg double %561
%563 = call double @llvm.fmuladd.f64(double %559, double %560, double %562)
%564 = fsub double %558, %563
%565 = load double, double* %59
%566 = load double, double* %58
%567 = fsub double %565, %566
%568 = fdiv double %564, %567
store double %568, double* %61
%569 = load double, double* %59
%570 = load double, double* %61
%571 = load double, double* %49
%572 = fsub double %570, %571
%573 = load double, double* %51
%574 = call double @llvm.fmuladd.f64(double %569, double %572, double %573)
store double %574, double* %62
%575 = load double, double* %61
%576 = load double, double* %49
%577 = fsub double %575, %576
%578 = load double, double* %61
%579 = load double, double* %49
%580 = fsub double %578, %579
%581 = load double, double* %62
%582 = load double, double* %51
%583 = fsub double %581, %582
%584 = load double, double* %62
%585 = load double, double* %51
%586 = fsub double %584, %585
%587 = fmul double %583, %586
%588 = call double @llvm.fmuladd.f64(double %577, double %580, double %587)
%589 = load double, double* %48
%590 = load double, double* %49
%591 = fsub double %589, %590
%592 = load double, double* %48
%593 = load double, double* %49
%594 = fsub double %592, %593
%595 = load double, double* %50
%596 = load double, double* %51
%597 = fsub double %595, %596
%598 = load double, double* %50
%599 = load double, double* %51
%600 = fsub double %598, %599
%601 = fmul double %597, %600
%602 = call double @llvm.fmuladd.f64(double %591, double %594, double %601)
%603 = fdiv double %588, %602
%604 = call double @sqrt(double %603)
store double %604, double* %63
%605 = load double, double* %61
%606 = load double, double* %53
%607 = fsub double %605, %606
%608 = load double, double* %61
%609 = load double, double* %53
%610 = fsub double %608, %609
%611 = load double, double* %62
%612 = load double, double* %55
%613 = fsub double %611, %612
%614 = load double, double* %62
%615 = load double, double* %55
%616 = fsub double %614, %615
%617 = fmul double %613, %616
%618 = call double @llvm.fmuladd.f64(double %607, double %610, double %617)
%619 = load double, double* %52
%620 = load double, double* %53
%621 = fsub double %619, %620
%622 = load double, double* %52
%623 = load double, double* %53
%624 = fsub double %622, %623
%625 = load double, double* %54
%626 = load double, double* %55
%627 = fsub double %625, %626
%628 = load double, double* %54
%629 = load double, double* %55
%630 = fsub double %628, %629
%631 = fmul double %627, %630
%632 = call double @llvm.fmuladd.f64(double %621, double %624, double %631)
%633 = fdiv double %618, %632
%634 = call double @sqrt(double %633)
store double %634, double* %64
%635 = load double, double* %65
%636 = load double, double* %66
%637 = load double, double* %65
%638 = fsub double %636, %637
%639 = load double, double* %63
%640 = call double @llvm.fmuladd.f64(double %638, double %639, double %635)
store double %640, double* %69
%641 = load double, double* %67
%642 = load double, double* %68
%643 = load double, double* %67
%644 = fsub double %642, %643
%645 = load double, double* %64
%646 = call double @llvm.fmuladd.f64(double %644, double %645, double %641)
store double %646, double* %70
%647 = load double, double* %69
%648 = load double, double* %70
%649 = fcmp ogt double %647, %648
%650 = zext i1 %649 to i64
%651 = select i1 %649, i32 1, i32 -1
%652 = load i32**, i32*** %29
%653 = load i32, i32* %20
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds i32*, i32** %652, i64 %654
%656 = load i32*, i32** %655
%657 = getelementptr inbounds i32, i32* %656, i64 2
store i32 %651, i32* %657
%658 = load i32, i32* %13
%659 = sitofp i32 %658 to double
%660 = load double, double* %63
%661 = fadd double %659, %660
%662 = load double*, double** %60
%663 = load i32, i32* %20
%664 = mul nsw i32 2, %663
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %662, i64 %665
store double %661, double* %666
%667 = load i32, i32* %14
%668 = sitofp i32 %667 to double
%669 = load double, double* %64
%670 = fadd double %668, %669
%671 = load double*, double** %60
%672 = load i32, i32* %20
%673 = mul nsw i32 2, %672
%674 = add nsw i32 %673, 1
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double, double* %671, i64 %675
store double %670, double* %676
%677 = load i32, i32* %20
%678 = add nsw i32 %677, 1
store i32 %678, i32* %20
br label %679
679: ; preds = %546, %545, %511, %477
%680 = load i32, i32* %14
%681 = add nsw i32 %680, 1
store i32 %681, i32* %14
br label %389
682: ; preds = %389
br label %683
683: ; preds = %682
%684 = load i32, i32* %13
%685 = add nsw i32 %684, 1
store i32 %685, i32* %13
br label %330
686: ; preds = %330
%687 = load i32, i32* %20
store i32 %687, i32* %17
%688 = mul nsw i32 2, %687
%689 = add nsw i32 %688, 2
%690 = call i32 (i32, i32, ...) bitcast (i32 (...)* @matrix_int_calloc to i32 (i32, i32, ...)*)(i32 %689, i32 3)
%691 = sext i32 %690 to i64
%692 = inttoptr i64 %691 to i32**
store i32** %692, i32*** %30
%693 = load i32, i32* %20
%694 = icmp eq i32 %693, 0
br i1 %694, label %695, label %696
695: ; preds = %686
br label %2153
696: ; preds = %686
%697 = load i32, i32* %20
%698 = load i32, i32* %27
%699 = icmp sgt i32 %697, %698
br i1 %699, label %700, label %702
700: ; preds = %696
%701 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0))
store i32 -2, i32* %20
br label %2153
702: ; preds = %696
store i32 0, i32* %13
br label %703
703: ; preds = %867, %702
%704 = load i32, i32* %13
%705 = load i32, i32* %20
%706 = icmp slt i32 %704, %705
br i1 %706, label %707, label %870
707: ; preds = %703
%708 = load i32**, i32*** %29
%709 = load i32, i32* %13
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds i32*, i32** %708, i64 %710
%712 = load i32*, i32** %711
%713 = getelementptr inbounds i32, i32* %712, i64 0
%714 = load i32, i32* %713
%715 = add nsw i32 %714, 1
store i32 %715, i32* %713
%716 = load i32**, i32*** %29
%717 = load i32, i32* %13
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds i32*, i32** %716, i64 %718
%720 = load i32*, i32** %719
%721 = getelementptr inbounds i32, i32* %720, i64 1
%722 = load i32, i32* %721
%723 = add nsw i32 %722, 2
store i32 %723, i32* %721
%724 = load i32, i32* %13
%725 = add nsw i32 %724, 1
store i32 %725, i32* %14
br label %726
726: ; preds = %863, %707
%727 = load i32, i32* %14
%728 = load i32, i32* %20
%729 = icmp slt i32 %727, %728
br i1 %729, label %730, label %866
730: ; preds = %726
%731 = load double*, double** %60
%732 = load i32, i32* %13
%733 = mul nsw i32 2, %732
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %731, i64 %734
%736 = load double, double* %735
%737 = load double*, double** %60
%738 = load i32, i32* %14
%739 = mul nsw i32 2, %738
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds double, double* %737, i64 %740
%742 = load double, double* %741
%743 = fcmp ogt double %736, %742
br i1 %743, label %744, label %753
744: ; preds = %730
%745 = load i32**, i32*** %29
%746 = load i32, i32* %13
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds i32*, i32** %745, i64 %747
%749 = load i32*, i32** %748
%750 = getelementptr inbounds i32, i32* %749, i64 0
%751 = load i32, i32* %750
%752 = add nsw i32 %751, 1
store i32 %752, i32* %750
br label %762
753: ; preds = %730
%754 = load i32**, i32*** %29
%755 = load i32, i32* %14
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds i32*, i32** %754, i64 %756
%758 = load i32*, i32** %757
%759 = getelementptr inbounds i32, i32* %758, i64 0
%760 = load i32, i32* %759
%761 = add nsw i32 %760, 1
store i32 %761, i32* %759
br label %762
762: ; preds = %753, %744
%763 = load double*, double** %60
%764 = load i32, i32* %13
%765 = mul nsw i32 2, %764
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds double, double* %763, i64 %766
%768 = load double, double* %767
%769 = load double*, double** %60
%770 = load i32, i32* %14
%771 = mul nsw i32 2, %770
%772 = add nsw i32 %771, 1
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds double, double* %769, i64 %773
%775 = load double, double* %774
%776 = fcmp ogt double %768, %775
br i1 %776, label %777, label %786
777: ; preds = %762
%778 = load i32**, i32*** %29
%779 = load i32, i32* %13
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds i32*, i32** %778, i64 %780
%782 = load i32*, i32** %781
%783 = getelementptr inbounds i32, i32* %782, i64 0
%784 = load i32, i32* %783
%785 = add nsw i32 %784, 1
store i32 %785, i32* %783
br label %795
786: ; preds = %762
%787 = load i32**, i32*** %29
%788 = load i32, i32* %14
%789 = sext i32 %788 to i64
%790 = getelementptr inbounds i32*, i32** %787, i64 %789
%791 = load i32*, i32** %790
%792 = getelementptr inbounds i32, i32* %791, i64 1
%793 = load i32, i32* %792
%794 = add nsw i32 %793, 1
store i32 %794, i32* %792
br label %795
795: ; preds = %786, %777
%796 = load double*, double** %60
%797 = load i32, i32* %13
%798 = mul nsw i32 2, %797
%799 = add nsw i32 %798, 1
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds double, double* %796, i64 %800
%802 = load double, double* %801
%803 = load double*, double** %60
%804 = load i32, i32* %14
%805 = mul nsw i32 2, %804
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds double, double* %803, i64 %806
%808 = load double, double* %807
%809 = fcmp ogt double %802, %808
br i1 %809, label %810, label %819
810: ; preds = %795
%811 = load i32**, i32*** %29
%812 = load i32, i32* %13
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds i32*, i32** %811, i64 %813
%815 = load i32*, i32** %814
%816 = getelementptr inbounds i32, i32* %815, i64 1
%817 = load i32, i32* %816
%818 = add nsw i32 %817, 1
store i32 %818, i32* %816
br label %828
819: ; preds = %795
%820 = load i32**, i32*** %29
%821 = load i32, i32* %14
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds i32*, i32** %820, i64 %822
%824 = load i32*, i32** %823
%825 = getelementptr inbounds i32, i32* %824, i64 0
%826 = load i32, i32* %825
%827 = add nsw i32 %826, 1
store i32 %827, i32* %825
br label %828
828: ; preds = %819, %810
%829 = load double*, double** %60
%830 = load i32, i32* %13
%831 = mul nsw i32 2, %830
%832 = add nsw i32 %831, 1
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double, double* %829, i64 %833
%835 = load double, double* %834
%836 = load double*, double** %60
%837 = load i32, i32* %14
%838 = mul nsw i32 2, %837
%839 = add nsw i32 %838, 1
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double, double* %836, i64 %840
%842 = load double, double* %841
%843 = fcmp ogt double %835, %842
br i1 %843, label %844, label %853
844: ; preds = %828
%845 = load i32**, i32*** %29
%846 = load i32, i32* %13
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds i32*, i32** %845, i64 %847
%849 = load i32*, i32** %848
%850 = getelementptr inbounds i32, i32* %849, i64 1
%851 = load i32, i32* %850
%852 = add nsw i32 %851, 1
store i32 %852, i32* %850
br label %862
853: ; preds = %828
%854 = load i32**, i32*** %29
%855 = load i32, i32* %14
%856 = sext i32 %855 to i64
%857 = getelementptr inbounds i32*, i32** %854, i64 %856
%858 = load i32*, i32** %857
%859 = getelementptr inbounds i32, i32* %858, i64 1
%860 = load i32, i32* %859
%861 = add nsw i32 %860, 1
store i32 %861, i32* %859
br label %862
862: ; preds = %853, %844
br label %863
863: ; preds = %862
%864 = load i32, i32* %14
%865 = add nsw i32 %864, 1
store i32 %865, i32* %14
br label %726
866: ; preds = %726
br label %867
867: ; preds = %866
%868 = load i32, i32* %13
%869 = add nsw i32 %868, 1
store i32 %869, i32* %13
br label %703
870: ; preds = %703
store i32 0, i32* %13
br label %871
871: ; preds = %991, %870
%872 = load i32, i32* %13
%873 = load i32, i32* %20
%874 = icmp slt i32 %872, %873
br i1 %874, label %875, label %994
875: ; preds = %871
%876 = load i32**, i32*** %29
%877 = load i32, i32* %13
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds i32*, i32** %876, i64 %878
%880 = load i32*, i32** %879
%881 = getelementptr inbounds i32, i32* %880, i64 1
%882 = load i32, i32* %881
%883 = load i32**, i32*** %30
%884 = load i32**, i32*** %29
%885 = load i32, i32* %13
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds i32*, i32** %884, i64 %886
%888 = load i32*, i32** %887
%889 = getelementptr inbounds i32, i32* %888, i64 0
%890 = load i32, i32* %889
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds i32*, i32** %883, i64 %891
%893 = load i32*, i32** %892
%894 = getelementptr inbounds i32, i32* %893, i64 0
store i32 %882, i32* %894
%895 = load i32**, i32*** %29
%896 = load i32, i32* %13
%897 = sext i32 %896 to i64
%898 = getelementptr inbounds i32*, i32** %895, i64 %897
%899 = load i32*, i32** %898
%900 = getelementptr inbounds i32, i32* %899, i64 2
%901 = load i32, i32* %900
%902 = load i32**, i32*** %30
%903 = load i32**, i32*** %29
%904 = load i32, i32* %13
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds i32*, i32** %903, i64 %905
%907 = load i32*, i32** %906
%908 = getelementptr inbounds i32, i32* %907, i64 0
%909 = load i32, i32* %908
%910 = sext i32 %909 to i64
%911 = getelementptr inbounds i32*, i32** %902, i64 %910
%912 = load i32*, i32** %911
%913 = getelementptr inbounds i32, i32* %912, i64 1
store i32 %901, i32* %913
%914 = load i32**, i32*** %29
%915 = load i32, i32* %13
%916 = sext i32 %915 to i64
%917 = getelementptr inbounds i32*, i32** %914, i64 %916
%918 = load i32*, i32** %917
%919 = getelementptr inbounds i32, i32* %918, i64 0
%920 = load i32, i32* %919
%921 = load i32**, i32*** %30
%922 = load i32**, i32*** %29
%923 = load i32, i32* %13
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds i32*, i32** %922, i64 %924
%926 = load i32*, i32** %925
%927 = getelementptr inbounds i32, i32* %926, i64 0
%928 = load i32, i32* %927
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds i32*, i32** %921, i64 %929
%931 = load i32*, i32** %930
%932 = getelementptr inbounds i32, i32* %931, i64 2
store i32 %920, i32* %932
%933 = load i32**, i32*** %29
%934 = load i32, i32* %13
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds i32*, i32** %933, i64 %935
%937 = load i32*, i32** %936
%938 = getelementptr inbounds i32, i32* %937, i64 0
%939 = load i32, i32* %938
%940 = load i32**, i32*** %30
%941 = load i32**, i32*** %29
%942 = load i32, i32* %13
%943 = sext i32 %942 to i64
%944 = getelementptr inbounds i32*, i32** %941, i64 %943
%945 = load i32*, i32** %944
%946 = getelementptr inbounds i32, i32* %945, i64 1
%947 = load i32, i32* %946
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds i32*, i32** %940, i64 %948
%950 = load i32*, i32** %949
%951 = getelementptr inbounds i32, i32* %950, i64 0
store i32 %939, i32* %951
%952 = load i32**, i32*** %29
%953 = load i32, i32* %13
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds i32*, i32** %952, i64 %954
%956 = load i32*, i32** %955
%957 = getelementptr inbounds i32, i32* %956, i64 2
%958 = load i32, i32* %957
%959 = sub nsw i32 0, %958
%960 = load i32**, i32*** %30
%961 = load i32**, i32*** %29
%962 = load i32, i32* %13
%963 = sext i32 %962 to i64
%964 = getelementptr inbounds i32*, i32** %961, i64 %963
%965 = load i32*, i32** %964
%966 = getelementptr inbounds i32, i32* %965, i64 1
%967 = load i32, i32* %966
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds i32*, i32** %960, i64 %968
%970 = load i32*, i32** %969
%971 = getelementptr inbounds i32, i32* %970, i64 1
store i32 %959, i32* %971
%972 = load i32**, i32*** %29
%973 = load i32, i32* %13
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds i32*, i32** %972, i64 %974
%976 = load i32*, i32** %975
%977 = getelementptr inbounds i32, i32* %976, i64 1
%978 = load i32, i32* %977
%979 = load i32**, i32*** %30
%980 = load i32**, i32*** %29
%981 = load i32, i32* %13
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds i32*, i32** %980, i64 %982
%984 = load i32*, i32** %983
%985 = getelementptr inbounds i32, i32* %984, i64 1
%986 = load i32, i32* %985
%987 = sext i32 %986 to i64
%988 = getelementptr inbounds i32*, i32** %979, i64 %987
%989 = load i32*, i32** %988
%990 = getelementptr inbounds i32, i32* %989, i64 2
store i32 %978, i32* %990
br label %991
991: ; preds = %875
%992 = load i32, i32* %13
%993 = add nsw i32 %992, 1
store i32 %993, i32* %13
br label %871
994: ; preds = %871
%995 = load i32, i32* %20
store i32 %995, i32* %27
br label %996
996: ; preds = %2033, %1343, %1106, %994
%997 = load i32, i32* %20
%998 = icmp ne i32 %997, 0
br i1 %998, label %999, label %2034
999: ; preds = %996
store i32 0, i32* %33
store i32 0, i32* %32
store i32 0, i32* %31
store i32 1, i32* %13
br label %1000
1000: ; preds = %1100, %999
%1001 = load i32, i32* %13
%1002 = load i32, i32* %20
%1003 = mul nsw i32 2, %1002
%1004 = add nsw i32 %1003, 1
%1005 = icmp slt i32 %1001, %1004
br i1 %1005, label %1006, label %1103
1006: ; preds = %1000
%1007 = load i32**, i32*** %30
%1008 = load i32, i32* %13
%1009 = sext i32 %1008 to i64
%1010 = getelementptr inbounds i32*, i32** %1007, i64 %1009
%1011 = load i32*, i32** %1010
%1012 = getelementptr inbounds i32, i32* %1011, i64 0
%1013 = load i32, i32* %1012
%1014 = load i32, i32* %13
%1015 = add nsw i32 %1014, 1
%1016 = icmp eq i32 %1013, %1015
br i1 %1016, label %1017, label %1099
1017: ; preds = %1006
store i32 1, i32* %14
br label %1018
1018: ; preds = %1093, %1017
%1019 = load i32, i32* %14
%1020 = load i32, i32* %20
%1021 = mul nsw i32 2, %1020
%1022 = sub nsw i32 %1021, 2
%1023 = icmp sle i32 %1019, %1022
br i1 %1023, label %1024, label %1096
1024: ; preds = %1018
%1025 = load i32, i32* %14
%1026 = load i32, i32* %13
%1027 = sub nsw i32 %1026, 1
%1028 = icmp sgt i32 %1025, %1027
br i1 %1028, label %1029, label %1072
1029: ; preds = %1024
%1030 = load i32**, i32*** %30
%1031 = load i32, i32* %14
%1032 = add nsw i32 %1031, 2
%1033 = sext i32 %1032 to i64
%1034 = getelementptr inbounds i32*, i32** %1030, i64 %1033
%1035 = load i32*, i32** %1034
%1036 = getelementptr inbounds i32, i32* %1035, i64 0
%1037 = load i32, i32* %1036
%1038 = load i32**, i32*** %30
%1039 = load i32, i32* %14
%1040 = sext i32 %1039 to i64
%1041 = getelementptr inbounds i32*, i32** %1038, i64 %1040
%1042 = load i32*, i32** %1041
%1043 = getelementptr inbounds i32, i32* %1042, i64 0
store i32 %1037, i32* %1043
%1044 = load i32**, i32*** %30
%1045 = load i32, i32* %14
%1046 = add nsw i32 %1045, 2
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds i32*, i32** %1044, i64 %1047
%1049 = load i32*, i32** %1048
%1050 = getelementptr inbounds i32, i32* %1049, i64 1
%1051 = load i32, i32* %1050
%1052 = load i32**, i32*** %30
%1053 = load i32, i32* %14
%1054 = sext i32 %1053 to i64
%1055 = getelementptr inbounds i32*, i32** %1052, i64 %1054
%1056 = load i32*, i32** %1055
%1057 = getelementptr inbounds i32, i32* %1056, i64 1
store i32 %1051, i32* %1057
%1058 = load i32**, i32*** %30
%1059 = load i32, i32* %14
%1060 = add nsw i32 %1059, 2
%1061 = sext i32 %1060 to i64
%1062 = getelementptr inbounds i32*, i32** %1058, i64 %1061
%1063 = load i32*, i32** %1062
%1064 = getelementptr inbounds i32, i32* %1063, i64 2
%1065 = load i32, i32* %1064
%1066 = load i32**, i32*** %30
%1067 = load i32, i32* %14
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds i32*, i32** %1066, i64 %1068
%1070 = load i32*, i32** %1069
%1071 = getelementptr inbounds i32, i32* %1070, i64 2
store i32 %1065, i32* %1071
br label %1072
1072: ; preds = %1029, %1024
%1073 = load i32**, i32*** %30
%1074 = load i32, i32* %14
%1075 = sext i32 %1074 to i64
%1076 = getelementptr inbounds i32*, i32** %1073, i64 %1075
%1077 = load i32*, i32** %1076
%1078 = getelementptr inbounds i32, i32* %1077, i64 0
%1079 = load i32, i32* %1078
%1080 = load i32, i32* %13
%1081 = add nsw i32 %1080, 1
%1082 = icmp sgt i32 %1079, %1081
br i1 %1082, label %1083, label %1092
1083: ; preds = %1072
%1084 = load i32**, i32*** %30
%1085 = load i32, i32* %14
%1086 = sext i32 %1085 to i64
%1087 = getelementptr inbounds i32*, i32** %1084, i64 %1086
%1088 = load i32*, i32** %1087
%1089 = getelementptr inbounds i32, i32* %1088, i64 0
%1090 = load i32, i32* %1089
%1091 = sub nsw i32 %1090, 2
store i32 %1091, i32* %1089
br label %1092
1092: ; preds = %1083, %1072
br label %1093
1093: ; preds = %1092
%1094 = load i32, i32* %14
%1095 = add nsw i32 %1094, 1
store i32 %1095, i32* %14
br label %1018
1096: ; preds = %1018
%1097 = load i32, i32* %20
%1098 = add nsw i32 %1097, -1
store i32 %1098, i32* %20
store i32 0, i32* %47
store i32 1, i32* %31
br label %1103
1099: ; preds = %1006
br label %1100
1100: ; preds = %1099
%1101 = load i32, i32* %13
%1102 = add nsw i32 %1101, 1
store i32 %1102, i32* %13
br label %1000
1103: ; preds = %1096, %1000
%1104 = load i32, i32* %31
%1105 = icmp eq i32 %1104, 1
br i1 %1105, label %1106, label %1107
1106: ; preds = %1103
br label %996
1107: ; preds = %1103
store i32 1, i32* %13
br label %1108
1108: ; preds = %1337, %1107
%1109 = load i32, i32* %13
%1110 = load i32, i32* %20
%1111 = mul nsw i32 2, %1110
%1112 = icmp slt i32 %1109, %1111
br i1 %1112, label %1113, label %1340
1113: ; preds = %1108
%1114 = load i32**, i32*** %30
%1115 = load i32, i32* %13
%1116 = add nsw i32 %1115, 1
%1117 = sext i32 %1116 to i64
%1118 = getelementptr inbounds i32*, i32** %1114, i64 %1117
%1119 = load i32*, i32** %1118
%1120 = getelementptr inbounds i32, i32* %1119, i64 0
%1121 = load i32, i32* %1120
%1122 = load i32**, i32*** %30
%1123 = load i32, i32* %13
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds i32*, i32** %1122, i64 %1124
%1126 = load i32*, i32** %1125
%1127 = getelementptr inbounds i32, i32* %1126, i64 0
%1128 = load i32, i32* %1127
%1129 = sub nsw i32 %1121, %1128
%1130 = call i32 @abs(i32 %1129)
%1131 = icmp eq i32 %1130, 1
br i1 %1131, label %1132, label %1336
1132: ; preds = %1113
%1133 = load i32**, i32*** %30
%1134 = load i32, i32* %13
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds i32*, i32** %1133, i64 %1135
%1137 = load i32*, i32** %1136
%1138 = getelementptr inbounds i32, i32* %1137, i64 1
%1139 = load i32, i32* %1138
%1140 = load i32**, i32*** %30
%1141 = load i32, i32* %13
%1142 = add nsw i32 %1141, 1
%1143 = sext i32 %1142 to i64
%1144 = getelementptr inbounds i32*, i32** %1140, i64 %1143
%1145 = load i32*, i32** %1144
%1146 = getelementptr inbounds i32, i32* %1145, i64 1
%1147 = load i32, i32* %1146
%1148 = icmp eq i32 %1139, %1147
br i1 %1148, label %1149, label %1336
1149: ; preds = %1132
%1150 = load i32**, i32*** %30
%1151 = load i32, i32* %13
%1152 = add nsw i32 %1151, 1
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds i32*, i32** %1150, i64 %1153
%1155 = load i32*, i32** %1154
%1156 = getelementptr inbounds i32, i32* %1155, i64 0
%1157 = load i32, i32* %1156
%1158 = load i32**, i32*** %30
%1159 = load i32, i32* %13
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds i32*, i32** %1158, i64 %1160
%1162 = load i32*, i32** %1161
%1163 = getelementptr inbounds i32, i32* %1162, i64 0
%1164 = load i32, i32* %1163
%1165 = icmp slt i32 %1157, %1164
br i1 %1165, label %1166, label %1175
1166: ; preds = %1149
%1167 = load i32**, i32*** %30
%1168 = load i32, i32* %13
%1169 = add nsw i32 %1168, 1
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds i32*, i32** %1167, i64 %1170
%1172 = load i32*, i32** %1171
%1173 = getelementptr inbounds i32, i32* %1172, i64 0
%1174 = load i32, i32* %1173
br label %1183
1175: ; preds = %1149
%1176 = load i32**, i32*** %30
%1177 = load i32, i32* %13
%1178 = sext i32 %1177 to i64
%1179 = getelementptr inbounds i32*, i32** %1176, i64 %1178
%1180 = load i32*, i32** %1179
%1181 = getelementptr inbounds i32, i32* %1180, i64 0
%1182 = load i32, i32* %1181
br label %1183
1183: ; preds = %1175, %1166
%1184 = phi i32 [ %1174, %1166 ], [ %1182, %1175 ]
store i32 %1184, i32* %15
store i32 1, i32* %14
br label %1185
1185: ; preds = %1330, %1183
%1186 = load i32, i32* %14
%1187 = load i32, i32* %20
%1188 = mul nsw i32 2, %1187
%1189 = sub nsw i32 %1188, 4
%1190 = icmp sle i32 %1186, %1189
br i1 %1190, label %1191, label %1333
1191: ; preds = %1185
%1192 = load i32, i32* %14
%1193 = load i32, i32* %15
%1194 = sub nsw i32 %1193, 3
%1195 = icmp sgt i32 %1192, %1194
br i1 %1195, label %1196, label %1239
1196: ; preds = %1191
%1197 = load i32**, i32*** %30
%1198 = load i32, i32* %14
%1199 = add nsw i32 %1198, 4
%1200 = sext i32 %1199 to i64
%1201 = getelementptr inbounds i32*, i32** %1197, i64 %1200
%1202 = load i32*, i32** %1201
%1203 = getelementptr inbounds i32, i32* %1202, i64 0
%1204 = load i32, i32* %1203
%1205 = load i32**, i32*** %30
%1206 = load i32, i32* %14
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds i32*, i32** %1205, i64 %1207
%1209 = load i32*, i32** %1208
%1210 = getelementptr inbounds i32, i32* %1209, i64 0
store i32 %1204, i32* %1210
%1211 = load i32**, i32*** %30
%1212 = load i32, i32* %14
%1213 = add nsw i32 %1212, 4
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds i32*, i32** %1211, i64 %1214
%1216 = load i32*, i32** %1215
%1217 = getelementptr inbounds i32, i32* %1216, i64 1
%1218 = load i32, i32* %1217
%1219 = load i32**, i32*** %30
%1220 = load i32, i32* %14
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds i32*, i32** %1219, i64 %1221
%1223 = load i32*, i32** %1222
%1224 = getelementptr inbounds i32, i32* %1223, i64 1
store i32 %1218, i32* %1224
%1225 = load i32**, i32*** %30
%1226 = load i32, i32* %14
%1227 = add nsw i32 %1226, 4
%1228 = sext i32 %1227 to i64
%1229 = getelementptr inbounds i32*, i32** %1225, i64 %1228
%1230 = load i32*, i32** %1229
%1231 = getelementptr inbounds i32, i32* %1230, i64 2
%1232 = load i32, i32* %1231
%1233 = load i32**, i32*** %30
%1234 = load i32, i32* %14
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds i32*, i32** %1233, i64 %1235
%1237 = load i32*, i32** %1236
%1238 = getelementptr inbounds i32, i32* %1237, i64 2
store i32 %1232, i32* %1238
br label %1288
1239: ; preds = %1191
%1240 = load i32, i32* %14
%1241 = load i32, i32* %13
%1242 = sub nsw i32 %1241, 1
%1243 = icmp sgt i32 %1240, %1242
br i1 %1243, label %1244, label %1287
1244: ; preds = %1239
%1245 = load i32**, i32*** %30
%1246 = load i32, i32* %14
%1247 = add nsw i32 %1246, 2
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds i32*, i32** %1245, i64 %1248
%1250 = load i32*, i32** %1249
%1251 = getelementptr inbounds i32, i32* %1250, i64 0
%1252 = load i32, i32* %1251
%1253 = load i32**, i32*** %30
%1254 = load i32, i32* %14
%1255 = sext i32 %1254 to i64
%1256 = getelementptr inbounds i32*, i32** %1253, i64 %1255
%1257 = load i32*, i32** %1256
%1258 = getelementptr inbounds i32, i32* %1257, i64 0
store i32 %1252, i32* %1258
%1259 = load i32**, i32*** %30
%1260 = load i32, i32* %14
%1261 = add nsw i32 %1260, 2
%1262 = sext i32 %1261 to i64
%1263 = getelementptr inbounds i32*, i32** %1259, i64 %1262
%1264 = load i32*, i32** %1263
%1265 = getelementptr inbounds i32, i32* %1264, i64 1
%1266 = load i32, i32* %1265
%1267 = load i32**, i32*** %30
%1268 = load i32, i32* %14
%1269 = sext i32 %1268 to i64
%1270 = getelementptr inbounds i32*, i32** %1267, i64 %1269
%1271 = load i32*, i32** %1270
%1272 = getelementptr inbounds i32, i32* %1271, i64 1
store i32 %1266, i32* %1272
%1273 = load i32**, i32*** %30
%1274 = load i32, i32* %14
%1275 = add nsw i32 %1274, 2
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds i32*, i32** %1273, i64 %1276
%1278 = load i32*, i32** %1277
%1279 = getelementptr inbounds i32, i32* %1278, i64 2
%1280 = load i32, i32* %1279
%1281 = load i32**, i32*** %30
%1282 = load i32, i32* %14
%1283 = sext i32 %1282 to i64
%1284 = getelementptr inbounds i32*, i32** %1281, i64 %1283
%1285 = load i32*, i32** %1284
%1286 = getelementptr inbounds i32, i32* %1285, i64 2
store i32 %1280, i32* %1286
br label %1287
1287: ; preds = %1244, %1239
br label %1288
1288: ; preds = %1287, %1196
%1289 = load i32**, i32*** %30
%1290 = load i32, i32* %14
%1291 = sext i32 %1290 to i64
%1292 = getelementptr inbounds i32*, i32** %1289, i64 %1291
%1293 = load i32*, i32** %1292
%1294 = getelementptr inbounds i32, i32* %1293, i64 0
%1295 = load i32, i32* %1294
%1296 = load i32, i32* %15
%1297 = add nsw i32 %1296, 1
%1298 = icmp sgt i32 %1295, %1297
br i1 %1298, label %1299, label %1308
1299: ; preds = %1288
%1300 = load i32**, i32*** %30
%1301 = load i32, i32* %14
%1302 = sext i32 %1301 to i64
%1303 = getelementptr inbounds i32*, i32** %1300, i64 %1302
%1304 = load i32*, i32** %1303
%1305 = getelementptr inbounds i32, i32* %1304, i64 0
%1306 = load i32, i32* %1305
%1307 = sub nsw i32 %1306, 4
store i32 %1307, i32* %1305
br label %1329
1308: ; preds = %1288
%1309 = load i32**, i32*** %30
%1310 = load i32, i32* %14
%1311 = sext i32 %1310 to i64
%1312 = getelementptr inbounds i32*, i32** %1309, i64 %1311
%1313 = load i32*, i32** %1312
%1314 = getelementptr inbounds i32, i32* %1313, i64 0
%1315 = load i32, i32* %1314
%1316 = load i32, i32* %13
%1317 = add nsw i32 %1316, 1
%1318 = icmp sgt i32 %1315, %1317
br i1 %1318, label %1319, label %1328
1319: ; preds = %1308
%1320 = load i32**, i32*** %30
%1321 = load i32, i32* %14
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds i32*, i32** %1320, i64 %1322
%1324 = load i32*, i32** %1323
%1325 = getelementptr inbounds i32, i32* %1324, i64 0
%1326 = load i32, i32* %1325
%1327 = sub nsw i32 %1326, 2
store i32 %1327, i32* %1325
br label %1328
1328: ; preds = %1319, %1308
br label %1329
1329: ; preds = %1328, %1299
br label %1330
1330: ; preds = %1329
%1331 = load i32, i32* %14
%1332 = add nsw i32 %1331, 1
store i32 %1332, i32* %14
br label %1185
1333: ; preds = %1185
%1334 = load i32, i32* %20
%1335 = sub nsw i32 %1334, 2
store i32 %1335, i32* %20
store i32 0, i32* %47
store i32 1, i32* %32
br label %1340
1336: ; preds = %1132, %1113
br label %1337
1337: ; preds = %1336
%1338 = load i32, i32* %13
%1339 = add nsw i32 %1338, 1
store i32 %1339, i32* %13
br label %1108
1340: ; preds = %1333, %1108
%1341 = load i32, i32* %32
%1342 = icmp eq i32 %1341, 1
br i1 %1342, label %1343, label %1344
1343: ; preds = %1340
br label %996
1344: ; preds = %1340
store i32 0, i32* %28
store i32 1, i32* %13
br label %1345
1345: ; preds = %1535, %1344
%1346 = load i32, i32* %13
%1347 = load i32, i32* %20
%1348 = mul nsw i32 2, %1347
%1349 = icmp slt i32 %1346, %1348
br i1 %1349, label %1350, label %1538
1350: ; preds = %1345
%1351 = load i32**, i32*** %30
%1352 = load i32, i32* %13
%1353 = sext i32 %1352 to i64
%1354 = getelementptr inbounds i32*, i32** %1351, i64 %1353
%1355 = load i32*, i32** %1354
%1356 = getelementptr inbounds i32, i32* %1355, i64 1
%1357 = load i32, i32* %1356
%1358 = load i32**, i32*** %30
%1359 = load i32, i32* %13
%1360 = add nsw i32 %1359, 1
%1361 = sext i32 %1360 to i64
%1362 = getelementptr inbounds i32*, i32** %1358, i64 %1361
%1363 = load i32*, i32** %1362
%1364 = getelementptr inbounds i32, i32* %1363, i64 1
%1365 = load i32, i32* %1364
%1366 = icmp eq i32 %1357, %1365
br i1 %1366, label %1367, label %1534
1367: ; preds = %1350
store i32 -1, i32* %14
br label %1368
1368: ; preds = %1530, %1367
%1369 = load i32, i32* %14
%1370 = icmp slt i32 %1369, 2
br i1 %1370, label %1371, label %1533
1371: ; preds = %1368
store i32 -1, i32* %15
br label %1372
1372: ; preds = %1526, %1371
%1373 = load i32, i32* %15
%1374 = icmp slt i32 %1373, 2
br i1 %1374, label %1375, label %1529
1375: ; preds = %1372
%1376 = load i32**, i32*** %30
%1377 = load i32, i32* %13
%1378 = sext i32 %1377 to i64
%1379 = getelementptr inbounds i32*, i32** %1376, i64 %1378
%1380 = load i32*, i32** %1379
%1381 = getelementptr inbounds i32, i32* %1380, i64 0
%1382 = load i32, i32* %1381
%1383 = load i32, i32* %20
%1384 = mul nsw i32 2, %1383
%1385 = icmp eq i32 %1382, %1384
br i1 %1385, label %1386, label %1390
1386: ; preds = %1375
%1387 = load i32, i32* %14
%1388 = icmp eq i32 %1387, 1
br i1 %1388, label %1389, label %1390
1389: ; preds = %1386
br label %1526
1390: ; preds = %1386, %1375
%1391 = load i32**, i32*** %30
%1392 = load i32**, i32*** %30
%1393 = load i32, i32* %13
%1394 = sext i32 %1393 to i64
%1395 = getelementptr inbounds i32*, i32** %1392, i64 %1394
%1396 = load i32*, i32** %1395
%1397 = getelementptr inbounds i32, i32* %1396, i64 0
%1398 = load i32, i32* %1397
%1399 = load i32, i32* %14
%1400 = add nsw i32 %1398, %1399
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds i32*, i32** %1391, i64 %1401
%1403 = load i32*, i32** %1402
%1404 = getelementptr inbounds i32, i32* %1403, i64 0
%1405 = load i32, i32* %1404
%1406 = load i32**, i32*** %30
%1407 = load i32, i32* %13
%1408 = add nsw i32 %1407, 1
%1409 = sext i32 %1408 to i64
%1410 = getelementptr inbounds i32*, i32** %1406, i64 %1409
%1411 = load i32*, i32** %1410
%1412 = getelementptr inbounds i32, i32* %1411, i64 0
%1413 = load i32, i32* %1412
%1414 = load i32, i32* %15
%1415 = add nsw i32 %1413, %1414
%1416 = icmp eq i32 %1405, %1415
br i1 %1416, label %1417, label %1525
1417: ; preds = %1390
%1418 = load i32, i32* %13
%1419 = load i32*, i32** %34
%1420 = load i32, i32* %28
%1421 = sext i32 %1420 to i64
%1422 = getelementptr inbounds i32, i32* %1419, i64 %1421
store i32 %1418, i32* %1422
%1423 = load i32**, i32*** %30
%1424 = load i32, i32* %13
%1425 = sext i32 %1424 to i64
%1426 = getelementptr inbounds i32*, i32** %1423, i64 %1425
%1427 = load i32*, i32** %1426
%1428 = getelementptr inbounds i32, i32* %1427, i64 0
%1429 = load i32, i32* %1428
%1430 = load i32*, i32** %37
%1431 = load i32, i32* %28
%1432 = sext i32 %1431 to i64
%1433 = getelementptr inbounds i32, i32* %1430, i64 %1432
store i32 %1429, i32* %1433
%1434 = load i32, i32* %13
%1435 = add nsw i32 %1434, 1
%1436 = load i32*, i32** %35
%1437 = load i32, i32* %28
%1438 = sext i32 %1437 to i64
%1439 = getelementptr inbounds i32, i32* %1436, i64 %1438
store i32 %1435, i32* %1439
%1440 = load i32**, i32*** %30
%1441 = load i32, i32* %13
%1442 = add nsw i32 %1441, 1
%1443 = sext i32 %1442 to i64
%1444 = getelementptr inbounds i32*, i32** %1440, i64 %1443
%1445 = load i32*, i32** %1444
%1446 = getelementptr inbounds i32, i32* %1445, i64 0
%1447 = load i32, i32* %1446
%1448 = load i32*, i32** %38
%1449 = load i32, i32* %28
%1450 = sext i32 %1449 to i64
%1451 = getelementptr inbounds i32, i32* %1448, i64 %1450
store i32 %1447, i32* %1451
%1452 = load i32*, i32** %37
%1453 = load i32, i32* %28
%1454 = sext i32 %1453 to i64
%1455 = getelementptr inbounds i32, i32* %1452, i64 %1454
%1456 = load i32, i32* %1455
%1457 = load i32, i32* %14
%1458 = add nsw i32 %1456, %1457
%1459 = load i32*, i32** %36
%1460 = load i32, i32* %28
%1461 = sext i32 %1460 to i64
%1462 = getelementptr inbounds i32, i32* %1459, i64 %1461
store i32 %1458, i32* %1462
%1463 = load i32*, i32** %38
%1464 = load i32, i32* %28
%1465 = sext i32 %1464 to i64
%1466 = getelementptr inbounds i32, i32* %1463, i64 %1465
%1467 = load i32, i32* %1466
%1468 = load i32, i32* %15
%1469 = add nsw i32 %1467, %1468
%1470 = load i32*, i32** %39
%1471 = load i32, i32* %28
%1472 = sext i32 %1471 to i64
%1473 = getelementptr inbounds i32, i32* %1470, i64 %1472
store i32 %1469, i32* %1473
%1474 = load i32*, i32** %34
%1475 = load i32, i32* %28
%1476 = sext i32 %1475 to i64
%1477 = getelementptr inbounds i32, i32* %1474, i64 %1476
%1478 = load i32, i32* %1477
%1479 = load i32, i32* %41
%1480 = icmp eq i32 %1478, %1479
br i1 %1480, label %1481, label %1522
1481: ; preds = %1417
%1482 = load i32*, i32** %37
%1483 = load i32, i32* %28
%1484 = sext i32 %1483 to i64
%1485 = getelementptr inbounds i32, i32* %1482, i64 %1484
%1486 = load i32, i32* %1485
%1487 = load i32, i32* %44
%1488 = icmp eq i32 %1486, %1487
br i1 %1488, label %1489, label %1522
1489: ; preds = %1481
%1490 = load i32*, i32** %35
%1491 = load i32, i32* %28
%1492 = sext i32 %1491 to i64
%1493 = getelementptr inbounds i32, i32* %1490, i64 %1492
%1494 = load i32, i32* %1493
%1495 = load i32, i32* %42
%1496 = icmp eq i32 %1494, %1495
br i1 %1496, label %1497, label %1522
1497: ; preds = %1489
%1498 = load i32*, i32** %38
%1499 = load i32, i32* %28
%1500 = sext i32 %1499 to i64
%1501 = getelementptr inbounds i32, i32* %1498, i64 %1500
%1502 = load i32, i32* %1501
%1503 = load i32, i32* %45
%1504 = icmp eq i32 %1502, %1503
br i1 %1504, label %1505, label %1522
1505: ; preds = %1497
%1506 = load i32*, i32** %36
%1507 = load i32, i32* %28
%1508 = sext i32 %1507 to i64
%1509 = getelementptr inbounds i32, i32* %1506, i64 %1508
%1510 = load i32, i32* %1509
%1511 = load i32, i32* %43
%1512 = icmp eq i32 %1510, %1511
br i1 %1512, label %1513, label %1522
1513: ; preds = %1505
%1514 = load i32*, i32** %39
%1515 = load i32, i32* %28
%1516 = sext i32 %1515 to i64
%1517 = getelementptr inbounds i32, i32* %1514, i64 %1516
%1518 = load i32, i32* %1517
%1519 = load i32, i32* %46
%1520 = icmp eq i32 %1518, %1519
br i1 %1520, label %1521, label %1522
1521: ; preds = %1513
br label %1526
1522: ; preds = %1513, %1505, %1497, %1489, %1481, %1417
%1523 = load i32, i32* %28
%1524 = add nsw i32 %1523, 1
store i32 %1524, i32* %28
br label %1525
1525: ; preds = %1522, %1390
br label %1526
1526: ; preds = %1525, %1521, %1389
%1527 = load i32, i32* %15
%1528 = add nsw i32 %1527, 2
store i32 %1528, i32* %15
br label %1372
1529: ; preds = %1372
br label %1530
1530: ; preds = %1529
%1531 = load i32, i32* %14
%1532 = add nsw i32 %1531, 2
store i32 %1532, i32* %14
br label %1368
1533: ; preds = %1368
br label %1534
1534: ; preds = %1533, %1350
br label %1535
1535: ; preds = %1534
%1536 = load i32, i32* %13
%1537 = add nsw i32 %1536, 1
store i32 %1537, i32* %13
br label %1345
1538: ; preds = %1345
%1539 = load i32, i32* %28
%1540 = icmp sgt i32 %1539, 0
br i1 %1540, label %1541, label %2018
1541: ; preds = %1538
store i32 0, i32* %13
br label %1542
1542: ; preds = %1786, %1541
%1543 = load i32, i32* %13
%1544 = load i32, i32* %28
%1545 = icmp slt i32 %1543, %1544
br i1 %1545, label %1546, label %1789
1546: ; preds = %1542
%1547 = load i32*, i32** %37
%1548 = load i32, i32* %13
%1549 = sext i32 %1548 to i64
%1550 = getelementptr inbounds i32, i32* %1547, i64 %1549
%1551 = load i32, i32* %1550
%1552 = load i32*, i32** %38
%1553 = load i32, i32* %13
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds i32, i32* %1552, i64 %1554
%1556 = load i32, i32* %1555
%1557 = sub nsw i32 %1551, %1556
%1558 = call i32 @abs(i32 %1557)
%1559 = icmp eq i32 %1558, 1
br i1 %1559, label %1588, label %1560
1560: ; preds = %1546
%1561 = load i32*, i32** %39
%1562 = load i32, i32* %13
%1563 = sext i32 %1562 to i64
%1564 = getelementptr inbounds i32, i32* %1561, i64 %1563
%1565 = load i32, i32* %1564
%1566 = load i32*, i32** %34
%1567 = load i32, i32* %13
%1568 = sext i32 %1567 to i64
%1569 = getelementptr inbounds i32, i32* %1566, i64 %1568
%1570 = load i32, i32* %1569
%1571 = sub nsw i32 %1565, %1570
%1572 = call i32 @abs(i32 %1571)
%1573 = icmp eq i32 %1572, 1
br i1 %1573, label %1588, label %1574
1574: ; preds = %1560
%1575 = load i32*, i32** %36
%1576 = load i32, i32* %13
%1577 = sext i32 %1576 to i64
%1578 = getelementptr inbounds i32, i32* %1575, i64 %1577
%1579 = load i32, i32* %1578
%1580 = load i32*, i32** %35
%1581 = load i32, i32* %13
%1582 = sext i32 %1581 to i64
%1583 = getelementptr inbounds i32, i32* %1580, i64 %1582
%1584 = load i32, i32* %1583
%1585 = sub nsw i32 %1579, %1584
%1586 = call i32 @abs(i32 %1585)
%1587 = icmp eq i32 %1586, 1
br i1 %1587, label %1588, label %1590
1588: ; preds = %1574, %1560, %1546
%1589 = load i32, i32* %13
store i32 %1589, i32* %28
store i32 1, i32* %33
br label %1789
1590: ; preds = %1574
%1591 = load i32**, i32*** %30
%1592 = load i32*, i32** %39
%1593 = load i32, i32* %13
%1594 = sext i32 %1593 to i64
%1595 = getelementptr inbounds i32, i32* %1592, i64 %1594
%1596 = load i32, i32* %1595
%1597 = mul nsw i32 2, %1596
%1598 = load i32*, i32** %38
%1599 = load i32, i32* %13
%1600 = sext i32 %1599 to i64
%1601 = getelementptr inbounds i32, i32* %1598, i64 %1600
%1602 = load i32, i32* %1601
%1603 = sub nsw i32 %1597, %1602
%1604 = sext i32 %1603 to i64
%1605 = getelementptr inbounds i32*, i32** %1591, i64 %1604
%1606 = load i32*, i32** %1605
%1607 = getelementptr inbounds i32, i32* %1606, i64 0
%1608 = load i32, i32* %1607
%1609 = load i32*, i32** %34
%1610 = load i32, i32* %13
%1611 = sext i32 %1610 to i64
%1612 = getelementptr inbounds i32, i32* %1609, i64 %1611
%1613 = load i32, i32* %1612
%1614 = mul nsw i32 2, %1613
%1615 = load i32*, i32** %35
%1616 = load i32, i32* %13
%1617 = sext i32 %1616 to i64
%1618 = getelementptr inbounds i32, i32* %1615, i64 %1617
%1619 = load i32, i32* %1618
%1620 = sub nsw i32 %1614, %1619
%1621 = icmp eq i32 %1608, %1620
br i1 %1621, label %1622, label %1655
1622: ; preds = %1590
%1623 = load i32**, i32*** %30
%1624 = load i32*, i32** %39
%1625 = load i32, i32* %13
%1626 = sext i32 %1625 to i64
%1627 = getelementptr inbounds i32, i32* %1624, i64 %1626
%1628 = load i32, i32* %1627
%1629 = mul nsw i32 2, %1628
%1630 = load i32*, i32** %38
%1631 = load i32, i32* %13
%1632 = sext i32 %1631 to i64
%1633 = getelementptr inbounds i32, i32* %1630, i64 %1632
%1634 = load i32, i32* %1633
%1635 = sub nsw i32 %1629, %1634
%1636 = sext i32 %1635 to i64
%1637 = getelementptr inbounds i32*, i32** %1623, i64 %1636
%1638 = load i32*, i32** %1637
%1639 = getelementptr inbounds i32, i32* %1638, i64 1
%1640 = load i32, i32* %1639
%1641 = load i32**, i32*** %30
%1642 = load i32*, i32** %38
%1643 = load i32, i32* %13
%1644 = sext i32 %1643 to i64
%1645 = getelementptr inbounds i32, i32* %1642, i64 %1644
%1646 = load i32, i32* %1645
%1647 = sext i32 %1646 to i64
%1648 = getelementptr inbounds i32*, i32** %1641, i64 %1647
%1649 = load i32*, i32** %1648
%1650 = getelementptr inbounds i32, i32* %1649, i64 1
%1651 = load i32, i32* %1650
%1652 = icmp eq i32 %1640, %1651
br i1 %1652, label %1653, label %1655
1653: ; preds = %1622
%1654 = load i32, i32* %13
store i32 %1654, i32* %28
store i32 1, i32* %33
br label %1789
1655: ; preds = %1622, %1590
%1656 = load i32**, i32*** %30
%1657 = load i32*, i32** %36
%1658 = load i32, i32* %13
%1659 = sext i32 %1658 to i64
%1660 = getelementptr inbounds i32, i32* %1657, i64 %1659
%1661 = load i32, i32* %1660
%1662 = mul nsw i32 2, %1661
%1663 = load i32*, i32** %37
%1664 = load i32, i32* %13
%1665 = sext i32 %1664 to i64
%1666 = getelementptr inbounds i32, i32* %1663, i64 %1665
%1667 = load i32, i32* %1666
%1668 = sub nsw i32 %1662, %1667
%1669 = sext i32 %1668 to i64
%1670 = getelementptr inbounds i32*, i32** %1656, i64 %1669
%1671 = load i32*, i32** %1670
%1672 = getelementptr inbounds i32, i32* %1671, i64 0
%1673 = load i32, i32* %1672
%1674 = load i32*, i32** %35
%1675 = load i32, i32* %13
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds i32, i32* %1674, i64 %1676
%1678 = load i32, i32* %1677
%1679 = mul nsw i32 2, %1678
%1680 = load i32*, i32** %34
%1681 = load i32, i32* %13
%1682 = sext i32 %1681 to i64
%1683 = getelementptr inbounds i32, i32* %1680, i64 %1682
%1684 = load i32, i32* %1683
%1685 = sub nsw i32 %1679, %1684
%1686 = icmp eq i32 %1673, %1685
br i1 %1686, label %1687, label %1720
1687: ; preds = %1655
%1688 = load i32**, i32*** %30
%1689 = load i32*, i32** %36
%1690 = load i32, i32* %13
%1691 = sext i32 %1690 to i64
%1692 = getelementptr inbounds i32, i32* %1689, i64 %1691
%1693 = load i32, i32* %1692
%1694 = mul nsw i32 2, %1693
%1695 = load i32*, i32** %37
%1696 = load i32, i32* %13
%1697 = sext i32 %1696 to i64
%1698 = getelementptr inbounds i32, i32* %1695, i64 %1697
%1699 = load i32, i32* %1698
%1700 = sub nsw i32 %1694, %1699
%1701 = sext i32 %1700 to i64
%1702 = getelementptr inbounds i32*, i32** %1688, i64 %1701
%1703 = load i32*, i32** %1702
%1704 = getelementptr inbounds i32, i32* %1703, i64 1
%1705 = load i32, i32* %1704
%1706 = load i32**, i32*** %30
%1707 = load i32*, i32** %37
%1708 = load i32, i32* %13
%1709 = sext i32 %1708 to i64
%1710 = getelementptr inbounds i32, i32* %1707, i64 %1709
%1711 = load i32, i32* %1710
%1712 = sext i32 %1711 to i64
%1713 = getelementptr inbounds i32*, i32** %1706, i64 %1712
%1714 = load i32*, i32** %1713
%1715 = getelementptr inbounds i32, i32* %1714, i64 1
%1716 = load i32, i32* %1715
%1717 = icmp eq i32 %1705, %1716
br i1 %1717, label %1718, label %1720
1718: ; preds = %1687
%1719 = load i32, i32* %13
store i32 %1719, i32* %28
store i32 1, i32* %33
br label %1789
1720: ; preds = %1687, %1655
%1721 = load i32**, i32*** %30
%1722 = load i32*, i32** %38
%1723 = load i32, i32* %13
%1724 = sext i32 %1723 to i64
%1725 = getelementptr inbounds i32, i32* %1722, i64 %1724
%1726 = load i32, i32* %1725
%1727 = mul nsw i32 2, %1726
%1728 = load i32*, i32** %39
%1729 = load i32, i32* %13
%1730 = sext i32 %1729 to i64
%1731 = getelementptr inbounds i32, i32* %1728, i64 %1730
%1732 = load i32, i32* %1731
%1733 = sub nsw i32 %1727, %1732
%1734 = sext i32 %1733 to i64
%1735 = getelementptr inbounds i32*, i32** %1721, i64 %1734
%1736 = load i32*, i32** %1735
%1737 = getelementptr inbounds i32, i32* %1736, i64 0
%1738 = load i32, i32* %1737
%1739 = load i32*, i32** %37
%1740 = load i32, i32* %13
%1741 = sext i32 %1740 to i64
%1742 = getelementptr inbounds i32, i32* %1739, i64 %1741
%1743 = load i32, i32* %1742
%1744 = mul nsw i32 2, %1743
%1745 = load i32*, i32** %36
%1746 = load i32, i32* %13
%1747 = sext i32 %1746 to i64
%1748 = getelementptr inbounds i32, i32* %1745, i64 %1747
%1749 = load i32, i32* %1748
%1750 = sub nsw i32 %1744, %1749
%1751 = icmp eq i32 %1738, %1750
br i1 %1751, label %1752, label %1785
1752: ; preds = %1720
%1753 = load i32**, i32*** %30
%1754 = load i32*, i32** %38
%1755 = load i32, i32* %13
%1756 = sext i32 %1755 to i64
%1757 = getelementptr inbounds i32, i32* %1754, i64 %1756
%1758 = load i32, i32* %1757
%1759 = mul nsw i32 2, %1758
%1760 = load i32*, i32** %39
%1761 = load i32, i32* %13
%1762 = sext i32 %1761 to i64
%1763 = getelementptr inbounds i32, i32* %1760, i64 %1762
%1764 = load i32, i32* %1763
%1765 = sub nsw i32 %1759, %1764
%1766 = sext i32 %1765 to i64
%1767 = getelementptr inbounds i32*, i32** %1753, i64 %1766
%1768 = load i32*, i32** %1767
%1769 = getelementptr inbounds i32, i32* %1768, i64 1
%1770 = load i32, i32* %1769
%1771 = load i32**, i32*** %30
%1772 = load i32*, i32** %39
%1773 = load i32, i32* %13
%1774 = sext i32 %1773 to i64
%1775 = getelementptr inbounds i32, i32* %1772, i64 %1774
%1776 = load i32, i32* %1775
%1777 = sext i32 %1776 to i64
%1778 = getelementptr inbounds i32*, i32** %1771, i64 %1777
%1779 = load i32*, i32** %1778
%1780 = getelementptr inbounds i32, i32* %1779, i64 1
%1781 = load i32, i32* %1780
%1782 = icmp eq i32 %1770, %1781
br i1 %1782, label %1783, label %1785
1783: ; preds = %1752
%1784 = load i32, i32* %13
store i32 %1784, i32* %28
store i32 1, i32* %33
br label %1789
1785: ; preds = %1752, %1720
br label %1786
1786: ; preds = %1785
%1787 = load i32, i32* %13
%1788 = add nsw i32 %1787, 1
store i32 %1788, i32* %13
br label %1542
1789: ; preds = %1783, %1718, %1653, %1588, %1542
%1790 = load i32, i32* %33
%1791 = icmp eq i32 %1790, 0
br i1 %1791, label %1792, label %1796
1792: ; preds = %1789
%1793 = call i32 (...) @rand()
%1794 = load i32, i32* %28
%1795 = srem i32 %1793, %1794
store i32 %1795, i32* %28
br label %1796
1796: ; preds = %1792, %1789
%1797 = load i32*, i32** %39
%1798 = load i32, i32* %28
%1799 = sext i32 %1798 to i64
%1800 = getelementptr inbounds i32, i32* %1797, i64 %1799
%1801 = load i32, i32* %1800
%1802 = load i32**, i32*** %30
%1803 = load i32*, i32** %34
%1804 = load i32, i32* %28
%1805 = sext i32 %1804 to i64
%1806 = getelementptr inbounds i32, i32* %1803, i64 %1805
%1807 = load i32, i32* %1806
%1808 = sext i32 %1807 to i64
%1809 = getelementptr inbounds i32*, i32** %1802, i64 %1808
%1810 = load i32*, i32** %1809
%1811 = getelementptr inbounds i32, i32* %1810, i64 0
store i32 %1801, i32* %1811
store i32 %1801, i32* %41
%1812 = load i32*, i32** %36
%1813 = load i32, i32* %28
%1814 = sext i32 %1813 to i64
%1815 = getelementptr inbounds i32, i32* %1812, i64 %1814
%1816 = load i32, i32* %1815
%1817 = load i32**, i32*** %30
%1818 = load i32*, i32** %35
%1819 = load i32, i32* %28
%1820 = sext i32 %1819 to i64
%1821 = getelementptr inbounds i32, i32* %1818, i64 %1820
%1822 = load i32, i32* %1821
%1823 = sext i32 %1822 to i64
%1824 = getelementptr inbounds i32*, i32** %1817, i64 %1823
%1825 = load i32*, i32** %1824
%1826 = getelementptr inbounds i32, i32* %1825, i64 0
store i32 %1816, i32* %1826
store i32 %1816, i32* %42
%1827 = load i32*, i32** %35
%1828 = load i32, i32* %28
%1829 = sext i32 %1828 to i64
%1830 = getelementptr inbounds i32, i32* %1827, i64 %1829
%1831 = load i32, i32* %1830
%1832 = load i32**, i32*** %30
%1833 = load i32*, i32** %36
%1834 = load i32, i32* %28
%1835 = sext i32 %1834 to i64
%1836 = getelementptr inbounds i32, i32* %1833, i64 %1835
%1837 = load i32, i32* %1836
%1838 = sext i32 %1837 to i64
%1839 = getelementptr inbounds i32*, i32** %1832, i64 %1838
%1840 = load i32*, i32** %1839
%1841 = getelementptr inbounds i32, i32* %1840, i64 0
store i32 %1831, i32* %1841
store i32 %1831, i32* %43
%1842 = load i32*, i32** %38
%1843 = load i32, i32* %28
%1844 = sext i32 %1843 to i64
%1845 = getelementptr inbounds i32, i32* %1842, i64 %1844
%1846 = load i32, i32* %1845
%1847 = load i32**, i32*** %30
%1848 = load i32*, i32** %37
%1849 = load i32, i32* %28
%1850 = sext i32 %1849 to i64
%1851 = getelementptr inbounds i32, i32* %1848, i64 %1850
%1852 = load i32, i32* %1851
%1853 = sext i32 %1852 to i64
%1854 = getelementptr inbounds i32*, i32** %1847, i64 %1853
%1855 = load i32*, i32** %1854
%1856 = getelementptr inbounds i32, i32* %1855, i64 0
store i32 %1846, i32* %1856
store i32 %1846, i32* %44
%1857 = load i32*, i32** %37
%1858 = load i32, i32* %28
%1859 = sext i32 %1858 to i64
%1860 = getelementptr inbounds i32, i32* %1857, i64 %1859
%1861 = load i32, i32* %1860
%1862 = load i32**, i32*** %30
%1863 = load i32*, i32** %38
%1864 = load i32, i32* %28
%1865 = sext i32 %1864 to i64
%1866 = getelementptr inbounds i32, i32* %1863, i64 %1865
%1867 = load i32, i32* %1866
%1868 = sext i32 %1867 to i64
%1869 = getelementptr inbounds i32*, i32** %1862, i64 %1868
%1870 = load i32*, i32** %1869
%1871 = getelementptr inbounds i32, i32* %1870, i64 0
store i32 %1861, i32* %1871
store i32 %1861, i32* %45
%1872 = load i32*, i32** %34
%1873 = load i32, i32* %28
%1874 = sext i32 %1873 to i64
%1875 = getelementptr inbounds i32, i32* %1872, i64 %1874
%1876 = load i32, i32* %1875
%1877 = load i32**, i32*** %30
%1878 = load i32*, i32** %39
%1879 = load i32, i32* %28
%1880 = sext i32 %1879 to i64
%1881 = getelementptr inbounds i32, i32* %1878, i64 %1880
%1882 = load i32, i32* %1881
%1883 = sext i32 %1882 to i64
%1884 = getelementptr inbounds i32*, i32** %1877, i64 %1883
%1885 = load i32*, i32** %1884
%1886 = getelementptr inbounds i32, i32* %1885, i64 0
store i32 %1876, i32* %1886
store i32 %1876, i32* %46
%1887 = load i32**, i32*** %30
%1888 = load i32*, i32** %35
%1889 = load i32, i32* %28
%1890 = sext i32 %1889 to i64
%1891 = getelementptr inbounds i32, i32* %1888, i64 %1890
%1892 = load i32, i32* %1891
%1893 = sext i32 %1892 to i64
%1894 = getelementptr inbounds i32*, i32** %1887, i64 %1893
%1895 = load i32*, i32** %1894
%1896 = getelementptr inbounds i32, i32* %1895, i64 1
%1897 = load i32, i32* %1896
store i32 %1897, i32* %40
%1898 = load i32**, i32*** %30
%1899 = load i32*, i32** %34
%1900 = load i32, i32* %28
%1901 = sext i32 %1900 to i64
%1902 = getelementptr inbounds i32, i32* %1899, i64 %1901
%1903 = load i32, i32* %1902
%1904 = sext i32 %1903 to i64
%1905 = getelementptr inbounds i32*, i32** %1898, i64 %1904
%1906 = load i32*, i32** %1905
%1907 = getelementptr inbounds i32, i32* %1906, i64 1
%1908 = load i32, i32* %1907
%1909 = load i32**, i32*** %30
%1910 = load i32*, i32** %35
%1911 = load i32, i32* %28
%1912 = sext i32 %1911 to i64
%1913 = getelementptr inbounds i32, i32* %1910, i64 %1912
%1914 = load i32, i32* %1913
%1915 = sext i32 %1914 to i64
%1916 = getelementptr inbounds i32*, i32** %1909, i64 %1915
%1917 = load i32*, i32** %1916
%1918 = getelementptr inbounds i32, i32* %1917, i64 1
store i32 %1908, i32* %1918
%1919 = load i32, i32* %40
%1920 = load i32**, i32*** %30
%1921 = load i32*, i32** %34
%1922 = load i32, i32* %28
%1923 = sext i32 %1922 to i64
%1924 = getelementptr inbounds i32, i32* %1921, i64 %1923
%1925 = load i32, i32* %1924
%1926 = sext i32 %1925 to i64
%1927 = getelementptr inbounds i32*, i32** %1920, i64 %1926
%1928 = load i32*, i32** %1927
%1929 = getelementptr inbounds i32, i32* %1928, i64 1
store i32 %1919, i32* %1929
%1930 = load i32**, i32*** %30
%1931 = load i32*, i32** %37
%1932 = load i32, i32* %28
%1933 = sext i32 %1932 to i64
%1934 = getelementptr inbounds i32, i32* %1931, i64 %1933
%1935 = load i32, i32* %1934
%1936 = sext i32 %1935 to i64
%1937 = getelementptr inbounds i32*, i32** %1930, i64 %1936
%1938 = load i32*, i32** %1937
%1939 = getelementptr inbounds i32, i32* %1938, i64 1
%1940 = load i32, i32* %1939
store i32 %1940, i32* %40
%1941 = load i32**, i32*** %30
%1942 = load i32*, i32** %36
%1943 = load i32, i32* %28
%1944 = sext i32 %1943 to i64
%1945 = getelementptr inbounds i32, i32* %1942, i64 %1944
%1946 = load i32, i32* %1945
%1947 = sext i32 %1946 to i64
%1948 = getelementptr inbounds i32*, i32** %1941, i64 %1947
%1949 = load i32*, i32** %1948
%1950 = getelementptr inbounds i32, i32* %1949, i64 1
%1951 = load i32, i32* %1950
%1952 = load i32**, i32*** %30
%1953 = load i32*, i32** %37
%1954 = load i32, i32* %28
%1955 = sext i32 %1954 to i64
%1956 = getelementptr inbounds i32, i32* %1953, i64 %1955
%1957 = load i32, i32* %1956
%1958 = sext i32 %1957 to i64
%1959 = getelementptr inbounds i32*, i32** %1952, i64 %1958
%1960 = load i32*, i32** %1959
%1961 = getelementptr inbounds i32, i32* %1960, i64 1
store i32 %1951, i32* %1961
%1962 = load i32, i32* %40
%1963 = load i32**, i32*** %30
%1964 = load i32*, i32** %36
%1965 = load i32, i32* %28
%1966 = sext i32 %1965 to i64
%1967 = getelementptr inbounds i32, i32* %1964, i64 %1966
%1968 = load i32, i32* %1967
%1969 = sext i32 %1968 to i64
%1970 = getelementptr inbounds i32*, i32** %1963, i64 %1969
%1971 = load i32*, i32** %1970
%1972 = getelementptr inbounds i32, i32* %1971, i64 1
store i32 %1962, i32* %1972
%1973 = load i32**, i32*** %30
%1974 = load i32*, i32** %39
%1975 = load i32, i32* %28
%1976 = sext i32 %1975 to i64
%1977 = getelementptr inbounds i32, i32* %1974, i64 %1976
%1978 = load i32, i32* %1977
%1979 = sext i32 %1978 to i64
%1980 = getelementptr inbounds i32*, i32** %1973, i64 %1979
%1981 = load i32*, i32** %1980
%1982 = getelementptr inbounds i32, i32* %1981, i64 1
%1983 = load i32, i32* %1982
store i32 %1983, i32* %40
%1984 = load i32**, i32*** %30
%1985 = load i32*, i32** %38
%1986 = load i32, i32* %28
%1987 = sext i32 %1986 to i64
%1988 = getelementptr inbounds i32, i32* %1985, i64 %1987
%1989 = load i32, i32* %1988
%1990 = sext i32 %1989 to i64
%1991 = getelementptr inbounds i32*, i32** %1984, i64 %1990
%1992 = load i32*, i32** %1991
%1993 = getelementptr inbounds i32, i32* %1992, i64 1
%1994 = load i32, i32* %1993
%1995 = load i32**, i32*** %30
%1996 = load i32*, i32** %39
%1997 = load i32, i32* %28
%1998 = sext i32 %1997 to i64
%1999 = getelementptr inbounds i32, i32* %1996, i64 %1998
%2000 = load i32, i32* %1999
%2001 = sext i32 %2000 to i64
%2002 = getelementptr inbounds i32*, i32** %1995, i64 %2001
%2003 = load i32*, i32** %2002
%2004 = getelementptr inbounds i32, i32* %2003, i64 1
store i32 %1994, i32* %2004
%2005 = load i32, i32* %40
%2006 = load i32**, i32*** %30
%2007 = load i32*, i32** %38
%2008 = load i32, i32* %28
%2009 = sext i32 %2008 to i64
%2010 = getelementptr inbounds i32, i32* %2007, i64 %2009
%2011 = load i32, i32* %2010
%2012 = sext i32 %2011 to i64
%2013 = getelementptr inbounds i32*, i32** %2006, i64 %2012
%2014 = load i32*, i32** %2013
%2015 = getelementptr inbounds i32, i32* %2014, i64 1
store i32 %2005, i32* %2015
%2016 = load i32, i32* %47
%2017 = add nsw i32 %2016, 1
store i32 %2017, i32* %47
br label %2018
2018: ; preds = %1796, %1538
%2019 = load i32, i32* %31
%2020 = icmp eq i32 %2019, 0
br i1 %2020, label %2021, label %2028
2021: ; preds = %2018
%2022 = load i32, i32* %32
%2023 = icmp eq i32 %2022, 0
br i1 %2023, label %2024, label %2028
2024: ; preds = %2021
%2025 = load i32, i32* %33
%2026 = icmp eq i32 %2025, 0
br i1 %2026, label %2027, label %2028
2027: ; preds = %2024
br label %2034
2028: ; preds = %2024, %2021, %2018
%2029 = load i32, i32* %47
%2030 = icmp sgt i32 %2029, 50
br i1 %2030, label %2031, label %2033
2031: ; preds = %2028
%2032 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0))
br label %2034
2033: ; preds = %2028
br label %996
2034: ; preds = %2031, %2027, %996
%2035 = load i32, i32* %20
%2036 = icmp sgt i32 %2035, 0
br i1 %2036, label %2037, label %2152
2037: ; preds = %2034
store i32 0, i32* %13
br label %2038
2038: ; preds = %2139, %2037
%2039 = load i32, i32* %13
%2040 = load i32, i32* %27
%2041 = icmp slt i32 %2039, %2040
br i1 %2041, label %2042, label %2142
2042: ; preds = %2038
%2043 = load i32**, i32*** %30
%2044 = getelementptr inbounds i32*, i32** %2043, i64 1
%2045 = load i32*, i32** %2044
%2046 = getelementptr inbounds i32, i32* %2045, i64 2
%2047 = load i32, i32* %2046
%2048 = load i32**, i32*** %29
%2049 = load i32, i32* %13
%2050 = sext i32 %2049 to i64
%2051 = getelementptr inbounds i32*, i32** %2048, i64 %2050
%2052 = load i32*, i32** %2051
%2053 = getelementptr inbounds i32, i32* %2052, i64 0
%2054 = load i32, i32* %2053
%2055 = icmp eq i32 %2047, %2054
br i1 %2055, label %2056, label %2064
2056: ; preds = %2042
%2057 = load double*, double** %60
%2058 = load i32, i32* %13
%2059 = mul nsw i32 2, %2058
%2060 = sext i32 %2059 to i64
%2061 = getelementptr inbounds double, double* %2057, i64 %2060
%2062 = load double, double* %2061
%2063 = load double*, double** %11
store double %2062, double* %2063
br label %2064
2064: ; preds = %2056, %2042
%2065 = load i32**, i32*** %30
%2066 = getelementptr inbounds i32*, i32** %2065, i64 1
%2067 = load i32*, i32** %2066
%2068 = getelementptr inbounds i32, i32* %2067, i64 2
%2069 = load i32, i32* %2068
%2070 = load i32**, i32*** %29
%2071 = load i32, i32* %13
%2072 = sext i32 %2071 to i64
%2073 = getelementptr inbounds i32*, i32** %2070, i64 %2072
%2074 = load i32*, i32** %2073
%2075 = getelementptr inbounds i32, i32* %2074, i64 1
%2076 = load i32, i32* %2075
%2077 = icmp eq i32 %2069, %2076
br i1 %2077, label %2078, label %2087
2078: ; preds = %2064
%2079 = load double*, double** %60
%2080 = load i32, i32* %13
%2081 = mul nsw i32 2, %2080
%2082 = add nsw i32 %2081, 1
%2083 = sext i32 %2082 to i64
%2084 = getelementptr inbounds double, double* %2079, i64 %2083
%2085 = load double, double* %2084
%2086 = load double*, double** %11
store double %2085, double* %2086
br label %2087
2087: ; preds = %2078, %2064
%2088 = load i32**, i32*** %30
%2089 = load i32, i32* %20
%2090 = mul nsw i32 2, %2089
%2091 = sext i32 %2090 to i64
%2092 = getelementptr inbounds i32*, i32** %2088, i64 %2091
%2093 = load i32*, i32** %2092
%2094 = getelementptr inbounds i32, i32* %2093, i64 2
%2095 = load i32, i32* %2094
%2096 = load i32**, i32*** %29
%2097 = load i32, i32* %13
%2098 = sext i32 %2097 to i64
%2099 = getelementptr inbounds i32*, i32** %2096, i64 %2098
%2100 = load i32*, i32** %2099
%2101 = getelementptr inbounds i32, i32* %2100, i64 0
%2102 = load i32, i32* %2101
%2103 = icmp eq i32 %2095, %2102
br i1 %2103, label %2104, label %2112
2104: ; preds = %2087
%2105 = load double*, double** %60
%2106 = load i32, i32* %13
%2107 = mul nsw i32 2, %2106
%2108 = sext i32 %2107 to i64
%2109 = getelementptr inbounds double, double* %2105, i64 %2108
%2110 = load double, double* %2109
%2111 = load double*, double** %12
store double %2110, double* %2111
br label %2112
2112: ; preds = %2104, %2087
%2113 = load i32**, i32*** %30
%2114 = load i32, i32* %20
%2115 = mul nsw i32 2, %2114
%2116 = sext i32 %2115 to i64
%2117 = getelementptr inbounds i32*, i32** %2113, i64 %2116
%2118 = load i32*, i32** %2117
%2119 = getelementptr inbounds i32, i32* %2118, i64 2
%2120 = load i32, i32* %2119
%2121 = load i32**, i32*** %29
%2122 = load i32, i32* %13
%2123 = sext i32 %2122 to i64
%2124 = getelementptr inbounds i32*, i32** %2121, i64 %2123
%2125 = load i32*, i32** %2124
%2126 = getelementptr inbounds i32, i32* %2125, i64 1
%2127 = load i32, i32* %2126
%2128 = icmp eq i32 %2120, %2127
br i1 %2128, label %2129, label %2138
2129: ; preds = %2112
%2130 = load double*, double** %60
%2131 = load i32, i32* %13
%2132 = mul nsw i32 2, %2131
%2133 = add nsw i32 %2132, 1
%2134 = sext i32 %2133 to i64
%2135 = getelementptr inbounds double, double* %2130, i64 %2134
%2136 = load double, double* %2135
%2137 = load double*, double** %12
store double %2136, double* %2137
br label %2138
2138: ; preds = %2129, %2112
br label %2139
2139: ; preds = %2138
%2140 = load i32, i32* %13
%2141 = add nsw i32 %2140, 1
store i32 %2141, i32* %13
br label %2038
2142: ; preds = %2038
%2143 = load double*, double** %12
%2144 = load double, double* %2143
%2145 = load double*, double** %11
%2146 = load double, double* %2145
%2147 = fsub double %2144, %2146
%2148 = load i32, i32* %16
%2149 = sitofp i32 %2148 to double
%2150 = fdiv double %2147, %2149
%2151 = load double*, double** %10
store double %2150, double* %2151
br label %2152
2152: ; preds = %2142, %2034
br label %2153
2153: ; preds = %2152, %700, %695
%2154 = load i32**, i32*** %29
%2155 = load i32, i32* %27
%2156 = call i32 (i32**, i32, ...) bitcast (i32 (...)* @matrix_int_free to i32 (i32**, i32, ...)*)(i32** %2154, i32 %2155)
%2157 = load i32**, i32*** %30
%2158 = load i32, i32* %17
%2159 = mul nsw i32 2, %2158
%2160 = add nsw i32 %2159, 1
%2161 = call i32 (i32**, i32, ...) bitcast (i32 (...)* @matrix_int_free to i32 (i32**, i32, ...)*)(i32** %2157, i32 %2160)
%2162 = load double*, double** %60
%2163 = call i32 (double*, ...) bitcast (i32 (...)* @vector_double_free to i32 (double*, ...)*)(double* %2162)
%2164 = load double*, double** %78
%2165 = call i32 (double*, ...) bitcast (i32 (...)* @vector_double_free to i32 (double*, ...)*)(double* %2164)
%2166 = load i32, i32* %20
ret i32 %2166
}

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