void Contour(double **d, int ilb, int iub, int jlb, int jub, double *x,
             double *y, int nc, double *z,
             void (*ConrecLine)(double, double, double, double, double)) {
  int m1, m2, m3, case_value;
  double dmin, dmax, x1 = 0, x2 = 0, y1 = 0, y2 = 0;
  int i, j, k, m;
  double h[5];
  int sh[5];
  double xh[5], yh[5];
  int im[4] = {0, 1, 1, 0}, jm[4] = {0, 0, 1, 1};
  int castab[3][3][3] = {{{0, 0, 8}, {0, 2, 5}, {7, 6, 9}},
                         {{0, 3, 4}, {1, 3, 1}, {4, 3, 0}},
                         {{9, 6, 7}, {5, 2, 0}, {8, 0, 0}}};
  double temp1, temp2;
  for (j = (jub - 1); j >= jlb; j--) {
    for (i = ilb; i <= iub - 1; i++) {
      temp1 = (d[i][j] < d[i][j + 1] ? d[i][j] : d[i][j + 1]);
      temp2 = (d[i + 1][j] < d[i + 1][j + 1] ? d[i + 1][j] : d[i + 1][j + 1]);
      dmin = (temp1 < temp2 ? temp1 : temp2);
      temp1 = (d[i][j] > d[i][j + 1] ? d[i][j] : d[i][j + 1]);
      temp2 = (d[i + 1][j] > d[i + 1][j + 1] ? d[i + 1][j] : d[i + 1][j + 1]);
      dmax = (temp1 > temp2 ? temp1 : temp2);
      if (dmax < z[0] || dmin > z[nc - 1])
        continue;
      for (k = 0; k < nc; k++) {
        if (z[k] < dmin || z[k] > dmax)
          continue;
        for (m = 4; m >= 0; m--) {
          if (m > 0) {
            h[m] = d[i + im[m - 1]][j + jm[m - 1]] - z[k];
            xh[m] = x[i + im[m - 1]];
            yh[m] = y[j + jm[m - 1]];
          } else {
            h[0] = 0.25 * (h[1] + h[2] + h[3] + h[4]);
            xh[0] = 0.50 * (x[i] + x[i + 1]);
            yh[0] = 0.50 * (y[j] + y[j + 1]);
          }
          if (h[m] > 0.0)
            sh[m] = 1;
          else if (h[m] < 0.0)
            sh[m] = -1;
          else
            sh[m] = 0;
        }
        for (m = 1; m <= 4; m++) {
          m1 = m;
          m2 = 0;
          if (m != 4)
            m3 = m + 1;
          else
            m3 = 1;
          if ((case_value = castab[sh[m1] + 1][sh[m2] + 1][sh[m3] + 1]) == 0)
            continue;
          switch (case_value) {
          case 1:
            x1 = xh[m1];
            y1 = yh[m1];
            x2 = xh[m2];
            y2 = yh[m2];
            break;
          case 2:
            x1 = xh[m2];
            y1 = yh[m2];
            x2 = xh[m3];
            y2 = yh[m3];
            break;
          case 3:
            x1 = xh[m3];
            y1 = yh[m3];
            x2 = xh[m1];
            y2 = yh[m1];
            break;
          case 4:
            x1 = xh[m1];
            y1 = yh[m1];
            x2 = (h[m3] * xh[m2] - h[m2] * xh[m3]) / (h[m3] - h[m2]);
            y2 = (h[m3] * yh[m2] - h[m2] * yh[m3]) / (h[m3] - h[m2]);
            break;
          case 5:
            x1 = xh[m2];
            y1 = yh[m2];
            x2 = (h[m1] * xh[m3] - h[m3] * xh[m1]) / (h[m1] - h[m3]);
            y2 = (h[m1] * yh[m3] - h[m3] * yh[m1]) / (h[m1] - h[m3]);
            break;
          case 6:
            x1 = xh[m1];
            y1 = yh[m1];
            x2 = (h[m2] * xh[m1] - h[m1] * xh[m2]) / (h[m2] - h[m1]);
            y2 = (h[m2] * yh[m1] - h[m1] * yh[m2]) / (h[m2] - h[m1]);
            break;
          case 7:
            x1 = (h[m2] * xh[m1] - h[m1] * xh[m2]) / (h[m2] - h[m1]);
            y1 = (h[m2] * yh[m1] - h[m1] * yh[m2]) / (h[m2] - h[m1]);
            x2 = (h[m3] * xh[m2] - h[m2] * xh[m3]) / (h[m3] - h[m2]);
            y2 = (h[m3] * yh[m2] - h[m2] * yh[m3]) / (h[m3] - h[m2]);
            break;
          case 8:
            x1 = (h[m3] * xh[m2] - h[m2] * xh[m3]) / (h[m3] - h[m2]);
            y1 = (h[m3] * yh[m2] - h[m2] * yh[m3]) / (h[m3] - h[m2]);
            x2 = (h[m1] * xh[m3] - h[m3] * xh[m1]) / (h[m1] - h[m3]);
            y2 = (h[m1] * yh[m3] - h[m3] * yh[m1]) / (h[m1] - h[m3]);
            break;
          case 9:
            x1 = (h[m1] * xh[m3] - h[m3] * xh[m1]) / (h[m1] - h[m3]);
            y1 = (h[m1] * yh[m3] - h[m3] * yh[m1]) / (h[m1] - h[m3]);
            x2 = (h[m2] * xh[m1] - h[m1] * xh[m2]) / (h[m2] - h[m1]);
            y2 = (h[m2] * yh[m1] - h[m1] * yh[m2]) / (h[m2] - h[m1]);
            break;
          default:
            break;
          }
          ConrecLine(x1, y1, x2, y2, z[k]);
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<Contour>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x1f4a(%rip),%rax
mov    %rax,-0x130(%rbp)
mov    0x1f44(%rip),%rax
mov    %rax,-0x128(%rbp)
mov    0x1f3e(%rip),%rax
mov    %rax,-0x140(%rbp)
mov    0x1f38(%rip),%rax
mov    %rax,-0x138(%rbp)
lea    -0x1b0(%rbp),%rdi
lea    0x1e9b(%rip),%rsi
mov    $0x6c,%edx
call   1030 <memcpy@plt>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     2221 <Contour+0x1111>
mov    -0xc(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     220e <Contour+0x10fe>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1236 <Contour+0x126>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
jmp    1258 <Contour+0x148>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    12d2 <Contour+0x1c2>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    12f9 <Contour+0x1e9>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm1
ff
movsd  -0x1c0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1338 <Contour+0x228>
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
jmp    1348 <Contour+0x238>
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    13ac <Contour+0x29c>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
jmp    13ce <Contour+0x2be>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1444 <Contour+0x334>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
jmp    146b <Contour+0x35b>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
ucomisd -0x1c0(%rbp),%xmm0
ff
jbe    14a6 <Contour+0x396>
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
jmp    14b6 <Contour+0x3a6>
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
ja     14f7 <Contour+0x3e7>
movsd  -0x38(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    14fc <Contour+0x3ec>
jmp    2200 <Contour+0x10f0>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    21fb <Contour+0x10eb>
mov    0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     1543 <Contour+0x433>
mov    0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1548 <Contour+0x438>
jmp    21ed <Contour+0x10dd>
movl   $0x4,-0x70(%rbp)
cmpl   $0x0,-0x70(%rbp)
jl     1729 <Contour+0x619>
cmpl   $0x0,-0x70(%rbp)
jle    1613 <Contour+0x503>
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x70(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    -0x130(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x68(%rbp),%ecx
mov    -0x70(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    -0x140(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movslq -0x70(%rbp),%rax
movsd  %xmm0,-0xa0(%rbp,%rax,8)
ff ff
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x70(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    -0x130(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x70(%rbp),%rax
movsd  %xmm0,-0xf0(%rbp,%rax,8)
ff ff
mov    0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x70(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
add    -0x140(%rbp,%rdx,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x70(%rbp),%rax
movsd  %xmm0,-0x120(%rbp,%rax,8)
ff ff
jmp    16aa <Contour+0x59a>
movsd  -0x98(%rbp),%xmm1
ff
addsd  -0x90(%rbp),%xmm1
ff
addsd  -0x88(%rbp),%xmm1
ff
addsd  -0x80(%rbp),%xmm1
movsd  0x19d0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1995(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0x1962(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movslq -0x70(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    16d8 <Contour+0x5c8>
movslq -0x70(%rbp),%rax
movl   $0x1,-0xc0(%rbp,%rax,4)
jmp    1716 <Contour+0x606>
movslq -0x70(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp,%rax,8),%xmm0
ff ff
jbe    1702 <Contour+0x5f2>
movslq -0x70(%rbp),%rax
movl   $0xffffffff,-0xc0(%rbp,%rax,4)
ff ff ff ff
jmp    1711 <Contour+0x601>
movslq -0x70(%rbp),%rax
movl   $0x0,-0xc0(%rbp,%rax,4)
jmp    1716 <Contour+0x606>
jmp    171b <Contour+0x60b>
mov    -0x70(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
jmp    154f <Contour+0x43f>
movl   $0x1,-0x70(%rbp)
cmpl   $0x4,-0x70(%rbp)
jg     21e8 <Contour+0x10d8>
mov    -0x70(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x70(%rbp)
je     175f <Contour+0x64f>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1766 <Contour+0x656>
movl   $0x1,-0x2c(%rbp)
movslq -0x24(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
mov    -0xc0(%rbp,%rcx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    -0xc0(%rbp,%rcx,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
cmp    $0x0,%eax
jne    17c2 <Contour+0x6b2>
jmp    21da <Contour+0x10ca>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x1f8(%rbp)
sub    $0x8,%eax
ja     21ae <Contour+0x109e>
mov    -0x1f8(%rbp),%rax
lea    0x1828(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x58(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x50(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x28(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x58(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x50(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x2c(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x58(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x50(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x58(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x28(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x28(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x58(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x48(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x58(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x28(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x28(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x2c(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x2c(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
mulsd  -0xf0(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x24(%rbp),%rax
movsd  -0x120(%rbp,%rax,8),%xmm2
ff ff
movslq -0x24(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x28(%rbp),%rax
mulsd  -0x120(%rbp,%rax,8),%xmm1
ff ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x28(%rbp),%rax
movsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x24(%rbp),%rax
subsd  -0xa0(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    21b3 <Contour+0x10a3>
jmp    21b3 <Contour+0x10a3>
mov    0x28(%rbp),%rax
movsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm3
mov    0x20(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm4
call   *%rax
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1730 <Contour+0x620>
jmp    21ed <Contour+0x10dd>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1503 <Contour+0x3f3>
jmp    2200 <Contour+0x10f0>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11ca <Contour+0xba>
jmp    2213 <Contour+0x1103>
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
jmp    11b8 <Contour+0xa8>
add    $0x200,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Contour>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %edx,0x1c(%rsp)
mov    %esi,0x18(%rsp)
cmp    %ecx,%r8d
jle    18c1 <Contour+0x7c1>
mov    0x1c0(%rsp),%rbx
mov    0x1b8(%rsp),%r10d
mov    0x1b0(%rsp),%r12
lea    -0x1(%r10),%eax
movslq %eax,%r13
movslq 0x18(%rsp),%rax
mov    %rax,0xf0(%rsp)
movslq %r8d,%r11
movslq %ecx,%rax
mov    %rax,0xf8(%rsp)
movslq 0x1c(%rsp),%r8
mov    %r10d,%r10d
xorpd  %xmm0,%xmm0
movapd %xmm0,0x160(%rsp)
xorpd  %xmm7,%xmm7
lea    0xee4(%rip),%r15
lea    0xead(%rip),%r14
xorpd  %xmm0,%xmm0
movapd %xmm0,0x150(%rsp)
mov    %r9,0x120(%rsp)
mov    %rdi,0x118(%rsp)
mov    %r10,0x110(%rsp)
mov    %r13,0x108(%rsp)
mov    %r8,0x100(%rsp)
jmp    11ce <Contour+0xce>
nopw   0x0(%rax,%rax,1)
cmp    0xf8(%rsp),%r11
jle    18c1 <Contour+0x7c1>
mov    %r11,%rdx
add    $0xffffffffffffffff,%r11
mov    0x18(%rsp),%eax
cmp    0x1c(%rsp),%eax
jge    11c0 <Contour+0xc0>
mov    0xf0(%rsp),%rbp
mov    %r11,0x130(%rsp)
mov    %rdx,0x128(%rsp)
jmp    1215 <Contour+0x115>
nopl   0x0(%rax)
mov    0x108(%rsp),%r13
mov    0x100(%rsp),%r8
cmp    %r8,%rbp
je     11c0 <Contour+0xc0>
mov    %rbp,%rsi
mov    (%rdi,%rbp,8),%rax
mov    0x8(%rdi,%rbp,8),%rcx
movsd  (%rax,%r11,8),%xmm4
movsd  (%rax,%rdx,8),%xmm6
add    $0x1,%rbp
movsd  (%rcx,%r11,8),%xmm1
movsd  (%rcx,%rdx,8),%xmm3
movapd %xmm4,%xmm5
maxsd  %xmm6,%xmm5
movapd %xmm1,%xmm0
maxsd  %xmm3,%xmm0
maxsd  %xmm0,%xmm5
movsd  (%rbx),%xmm2
ucomisd %xmm5,%xmm2
ja     1210 <Contour+0x110>
mov    %rsi,0xc8(%rsp)
minsd  %xmm6,%xmm4
minsd  %xmm3,%xmm1
minsd  %xmm1,%xmm4
ucomisd (%rbx,%r13,8),%xmm4
ja     1210 <Contour+0x110>
mov    0x1b8(%rsp),%eax
test   %eax,%eax
jle    1210 <Contour+0x110>
xor    %r13d,%r13d
mov    %rbp,0x148(%rsp)
mov    0xc8(%rsp),%rcx
movsd  %xmm4,0x140(%rsp)
movsd  %xmm5,0x138(%rsp)
ucomisd %xmm2,%xmm4
ja     18a2 <Contour+0x7a2>
nop
ucomisd %xmm5,%xmm2
ja     18a2 <Contour+0x7a2>
mov    (%rdi,%rcx,8),%rax
movsd  (%rax,%rdx,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,0xc0(%rsp)
movsd  (%r9,%rcx,8),%xmm1
movsd  %xmm1,0x80(%rsp)
movsd  (%r12,%rdx,8),%xmm9
movsd  %xmm9,0x50(%rsp)
ucomisd %xmm7,%xmm3
jbe    1300 <Contour+0x200>
movl   $0x1,0x10(%rsp)
jmp    1318 <Contour+0x218>
nopl   0x0(%rax)
ucomisd %xmm3,%xmm7
jbe    1310 <Contour+0x210>
movl   $0xffffffff,0x10(%rsp)
ff
jmp    1318 <Contour+0x218>
movl   $0x0,0x10(%rsp)
mov    (%rdi,%rbp,8),%rax
movsd  (%rax,%rdx,8),%xmm4
subsd  %xmm2,%xmm4
movsd  %xmm4,0xb8(%rsp)
movsd  (%r9,%rbp,8),%xmm5
movapd %xmm5,%xmm8
movsd  %xmm5,0x78(%rsp)
movsd  %xmm9,0x48(%rsp)
ucomisd %xmm7,%xmm4
jbe    1360 <Contour+0x260>
movl   $0x1,0xc(%rsp)
jmp    1378 <Contour+0x278>
cs nopw 0x0(%rax,%rax,1)
ucomisd %xmm4,%xmm7
jbe    1370 <Contour+0x270>
movl   $0xffffffff,0xc(%rsp)
ff
jmp    1378 <Contour+0x278>
movl   $0x0,0xc(%rsp)
mov    (%rdi,%rbp,8),%rax
movsd  (%rax,%r11,8),%xmm6
subsd  %xmm2,%xmm6
movsd  %xmm6,0xb0(%rsp)
movsd  %xmm8,0x70(%rsp)
movsd  (%r12,%r11,8),%xmm5
movsd  %xmm5,0x40(%rsp)
ucomisd %xmm7,%xmm6
jbe    13c0 <Contour+0x2c0>
movl   $0x1,0x8(%rsp)
jmp    13d8 <Contour+0x2d8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomisd %xmm6,%xmm7
jbe    13d0 <Contour+0x2d0>
movl   $0xffffffff,0x8(%rsp)
ff
jmp    13d8 <Contour+0x2d8>
movl   $0x0,0x8(%rsp)
mov    (%rdi,%rcx,8),%rax
movsd  (%rax,%r11,8),%xmm0
subsd  %xmm2,%xmm0
movsd  %xmm0,0xa8(%rsp)
movsd  %xmm1,0x68(%rsp)
movsd  %xmm5,0x38(%rsp)
ucomisd %xmm7,%xmm0
jbe    1410 <Contour+0x310>
movl   $0x1,0x4(%rsp)
mov    $0x1,%ecx
jmp    142f <Contour+0x32f>
ucomisd %xmm0,%xmm7
jbe    1425 <Contour+0x325>
movl   $0xffffffff,0x4(%rsp)
ff
mov    $0xffffffff,%ecx
jmp    142f <Contour+0x32f>
movl   $0x0,0x4(%rsp)
xor    %ecx,%ecx
addsd  %xmm6,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm3,%xmm0
mulsd  0xbbd(%rip),%xmm0
movsd  %xmm0,0xa0(%rsp)
unpcklpd %xmm5,%xmm1
unpcklpd %xmm9,%xmm8
addpd  %xmm1,%xmm8
mulpd  0xbad(%rip),%xmm8
movlpd %xmm8,0x60(%rsp)
movapd %xmm8,0x20(%rsp)
movhpd %xmm8,0x30(%rsp)
ucomisd %xmm7,%xmm0
jbe    1490 <Contour+0x390>
movl   $0x1,(%rsp)
mov    $0x2,%r12d
jmp    14af <Contour+0x3af>
nopl   (%rax)
ucomisd %xmm0,%xmm7
jbe    14a2 <Contour+0x3a2>
movl   $0xffffffff,(%rsp)
xor    %r12d,%r12d
jmp    14af <Contour+0x3af>
movl   $0x0,(%rsp)
mov    $0x1,%r12d
movapd %xmm0,%xmm1
xorpd  0xb65(%rip),%xmm0
movapd %xmm1,0x90(%rsp)
unpcklpd %xmm1,%xmm1
movapd %xmm1,0xe0(%rsp)
pshufd $0x44,%xmm0,%xmm0
movdqa %xmm0,0xd0(%rsp)
mov    $0x2,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%ecx
cmp    $0x5,%rbp
mov    %rbp,%rax
mov    $0x1,%edx
cmove  %rdx,%rax
movslq %ecx,%rcx
movslq (%rsp,%rax,4),%rdx
lea    (%rcx,%rcx,8),%rcx
lea    (%r15,%rcx,4),%rcx
lea    (%r12,%r12,2),%rsi
lea    (%rcx,%rsi,4),%rcx
mov    0x4(%rcx,%rdx,4),%ecx
cmp    $0x9,%rcx
ja     1544 <Contour+0x444>
movslq (%r14,%rcx,4),%rcx
add    %r14,%rcx
jmp    *%rcx
movsd  0x58(%rsp,%rbp,8),%xmm6
movhpd 0x28(%rsp,%rbp,8),%xmm6
movapd 0x20(%rsp),%xmm2
jmp    1800 <Contour+0x700>
movapd 0x160(%rsp),%xmm2
movapd 0x150(%rsp),%xmm6
jmp    1800 <Contour+0x700>
movsd  0x60(%rsp,%rax,8),%xmm2
movhpd 0x30(%rsp,%rax,8),%xmm2
movapd 0x20(%rsp),%xmm6
jmp    1800 <Contour+0x700>
movsd  0x58(%rsp,%rbp,8),%xmm2
movhpd 0x28(%rsp,%rbp,8),%xmm2
movsd  0x60(%rsp,%rax,8),%xmm6
movhpd 0x30(%rsp,%rax,8),%xmm6
jmp    1800 <Contour+0x700>
movsd  0xa0(%rsp,%rax,8),%xmm2
movapd %xmm2,%xmm0
subsd  0x90(%rsp),%xmm0
movsd  0x60(%rsp,%rax,8),%xmm1
movhpd 0x30(%rsp,%rax,8),%xmm1
mulpd  0xd0(%rsp),%xmm1
unpcklpd %xmm2,%xmm2
mulpd  0x20(%rsp),%xmm2
addpd  %xmm1,%xmm2
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm2
movsd  0x58(%rsp,%rbp,8),%xmm6
movhpd 0x28(%rsp,%rbp,8),%xmm6
jmp    1800 <Contour+0x700>
movsd  0x98(%rsp,%rbp,8),%xmm0
movsd  0xa0(%rsp,%rax,8),%xmm1
movapd %xmm0,%xmm4
subsd  %xmm1,%xmm4
movsd  0x58(%rsp,%rbp,8),%xmm3
movhpd 0x28(%rsp,%rbp,8),%xmm3
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
unpcklpd %xmm0,%xmm0
movsd  0x60(%rsp,%rax,8),%xmm2
movhpd 0x30(%rsp,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
subpd  %xmm1,%xmm2
unpcklpd %xmm4,%xmm4
divpd  %xmm4,%xmm2
movapd 0x20(%rsp),%xmm6
jmp    1800 <Contour+0x700>
movsd  0x98(%rsp,%rbp,8),%xmm0
movapd 0x90(%rsp),%xmm1
subsd  %xmm0,%xmm1
unpcklpd %xmm0,%xmm0
mulpd  0x20(%rsp),%xmm0
movsd  0x58(%rsp,%rbp,8),%xmm6
movhpd 0x28(%rsp,%rbp,8),%xmm6
movapd 0xe0(%rsp),%xmm2
mulpd  %xmm6,%xmm2
subpd  %xmm0,%xmm2
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm2
jmp    1800 <Contour+0x700>
movsd  0x98(%rsp,%rbp,8),%xmm0
movapd 0x90(%rsp),%xmm4
movapd %xmm4,%xmm1
subsd  %xmm0,%xmm1
unpcklpd %xmm0,%xmm0
movsd  0x58(%rsp,%rbp,8),%xmm6
movhpd 0x28(%rsp,%rbp,8),%xmm6
movapd 0x20(%rsp),%xmm3
mulpd  %xmm3,%xmm0
mulpd  0xe0(%rsp),%xmm6
subpd  %xmm0,%xmm6
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm6
movsd  0xa0(%rsp,%rax,8),%xmm2
movapd %xmm2,%xmm0
subsd  %xmm4,%xmm0
movsd  0x60(%rsp,%rax,8),%xmm1
movhpd 0x30(%rsp,%rax,8),%xmm1
mulpd  0xd0(%rsp),%xmm1
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm2
jmp    1800 <Contour+0x700>
movsd  0xa0(%rsp,%rax,8),%xmm0
movapd %xmm0,%xmm6
movsd  0x98(%rsp,%rbp,8),%xmm2
movapd %xmm2,%xmm5
subsd  %xmm0,%xmm5
movsd  0x60(%rsp,%rax,8),%xmm3
movhpd 0x30(%rsp,%rax,8),%xmm3
subsd  0x90(%rsp),%xmm0
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
mulpd  0xd0(%rsp),%xmm3
unpcklpd %xmm6,%xmm6
movsd  0x58(%rsp,%rbp,8),%xmm4
movhpd 0x28(%rsp,%rbp,8),%xmm4
mulpd  %xmm6,%xmm4
mulpd  0x20(%rsp),%xmm6
addpd  %xmm3,%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
subpd  %xmm4,%xmm2
unpcklpd %xmm5,%xmm5
divpd  %xmm5,%xmm2
jmp    1800 <Contour+0x700>
movsd  0x98(%rsp,%rbp,8),%xmm0
movsd  0xa0(%rsp,%rax,8),%xmm1
movapd %xmm0,%xmm4
subsd  %xmm1,%xmm4
movsd  0x58(%rsp,%rbp,8),%xmm2
movhpd 0x28(%rsp,%rbp,8),%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
movapd 0x90(%rsp),%xmm3
subsd  %xmm0,%xmm3
unpcklpd %xmm0,%xmm0
movsd  0x60(%rsp,%rax,8),%xmm6
movhpd 0x30(%rsp,%rax,8),%xmm6
mulpd  %xmm0,%xmm6
subpd  %xmm1,%xmm6
unpcklpd %xmm4,%xmm4
divpd  %xmm4,%xmm6
mulpd  0x20(%rsp),%xmm0
mulpd  0xe0(%rsp),%xmm2
subpd  %xmm0,%xmm2
unpcklpd %xmm3,%xmm3
divpd  %xmm3,%xmm2
nopl   (%rax)
movsd  (%rbx,%r13,8),%xmm4
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
movapd %xmm6,0x150(%rsp)
movapd %xmm6,%xmm0
movapd %xmm2,0x160(%rsp)
call   *0x1c8(%rsp)
xorpd  %xmm7,%xmm7
cmp    $0x5,%rbp
je     1850 <Contour+0x750>
mov    (%rsp,%rbp,4),%ecx
add    $0x1,%rbp
jmp    14f0 <Contour+0x3f0>
nopl   0x0(%rax)
mov    0x120(%rsp),%r9
mov    0x118(%rsp),%rdi
mov    0x1b0(%rsp),%r12
mov    0x130(%rsp),%r11
mov    0x110(%rsp),%r10
mov    0x128(%rsp),%rdx
mov    0x148(%rsp),%rbp
mov    0xc8(%rsp),%rcx
movsd  0x140(%rsp),%xmm4
movsd  0x138(%rsp),%xmm5
add    $0x1,%r13
cmp    %r10,%r13
je     1200 <Contour+0x100>
movsd  (%rbx,%r13,8),%xmm2
ucomisd %xmm2,%xmm4
jbe    12b0 <Contour+0x1b0>
jmp    18a2 <Contour+0x7a2>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.Contour.castab = [3 x [3 x [3 x i32]]] [[3 x [3 x i32]] [[3 x i32] [i32 0, i32 0, i32 8], [3 x i32] [i32 0, i32 2, i32 5], [3 x i32] [i32 7, i32 6, i32 9]], [3 x [3 x i32]] [[3 x i32] [i32 0, i32 3, i32 4], [3 x i32] [i32 1, i32 3, i32 1], [3 x i32] [i32 4, i32 3, i32 0]], [3 x [3 x i32]] [[3 x i32] [i32 9, i32 6, i32 7], [3 x i32] [i32 5, i32 2, i32 0], [3 x i32] [i32 8, i32 0, i32 0]]]
define void @Contour(double** nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4, double* nocapture %5, double* nocapture %6, i32 %7, double* nocapture %8, void (double, double, double, double, double)* nocapture %9) {
%11 = alloca [5 x double]
%12 = alloca [5 x i32]
%13 = alloca [5 x double]
%14 = alloca [5 x double]
%15 = bitcast [5 x double]* %11 to i8*
%16 = bitcast [5 x i32]* %12 to i8*
%17 = bitcast [5 x double]* %13 to i8*
%18 = bitcast [5 x double]* %14 to i8*
%19 = icmp sgt i32 %4, %3
br i1 %19, label %20, label %449
20: ; preds = %10
%21 = icmp slt i32 %1, %2
%22 = add nsw i32 %7, -1
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds double, double* %8, i64 %23
%25 = icmp sgt i32 %7, 0
%26 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 1
%27 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 2
%28 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 3
%29 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 4
%30 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 0
%31 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 0
%32 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 0
%33 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 0
%34 = sext i32 %1 to i64
%35 = sext i32 %4 to i64
%36 = sext i32 %3 to i64
%37 = sext i32 %2 to i64
%38 = zext i32 %7 to i64
%39 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 4
%40 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 4
%41 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 4
%42 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 4
%43 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 4
%44 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 3
%45 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 3
%46 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 3
%47 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 3
%48 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 3
%49 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 2
%50 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 2
%51 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 2
%52 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 2
%53 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 2
%54 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 1
%55 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 1
%56 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 1
%57 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 1
%58 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 1
br label %63
59: ; preds = %445, %63
%60 = phi <2 x double> [ %65, %63 ], [ %446, %445 ]
%61 = phi <2 x double> [ %66, %63 ], [ %447, %445 ]
%62 = icmp sgt i64 %67, %36
br i1 %62, label %63, label %449
63: ; preds = %20, %59
%64 = phi i64 [ %35, %20 ], [ %67, %59 ]
%65 = phi <2 x double> [ zeroinitializer, %20 ], [ %60, %59 ]
%66 = phi <2 x double> [ zeroinitializer, %20 ], [ %61, %59 ]
%67 = add nsw i64 %64, -1
br i1 %21, label %68, label %59
68: ; preds = %63
%69 = getelementptr inbounds double, double* %6, i64 %67
%70 = getelementptr inbounds double, double* %6, i64 %64
br label %71
71: ; preds = %68, %445
%72 = phi i64 [ %34, %68 ], [ %83, %445 ]
%73 = phi <2 x double> [ %65, %68 ], [ %446, %445 ]
%74 = phi <2 x double> [ %66, %68 ], [ %447, %445 ]
%75 = getelementptr inbounds double*, double** %0, i64 %72
%76 = load double*, double** %75
%77 = getelementptr inbounds double, double* %76, i64 %67
%78 = load double, double* %77
%79 = getelementptr inbounds double, double* %76, i64 %64
%80 = load double, double* %79
%81 = fcmp olt double %78, %80
%82 = select i1 %81, double %78, double %80
%83 = add nsw i64 %72, 1
%84 = getelementptr inbounds double*, double** %0, i64 %83
%85 = load double*, double** %84
%86 = getelementptr inbounds double, double* %85, i64 %67
%87 = load double, double* %86
%88 = getelementptr inbounds double, double* %85, i64 %64
%89 = load double, double* %88
%90 = fcmp olt double %87, %89
%91 = select i1 %90, double %87, double %89
%92 = fcmp olt double %82, %91
%93 = select i1 %92, double %82, double %91
%94 = fcmp ogt double %78, %80
%95 = select i1 %94, double %78, double %80
%96 = fcmp ogt double %87, %89
%97 = select i1 %96, double %87, double %89
%98 = fcmp ogt double %95, %97
%99 = select i1 %98, double %95, double %97
%100 = load double, double* %8
%101 = fcmp olt double %99, %100
br i1 %101, label %445, label %102
102: ; preds = %71
%103 = load double, double* %24
%104 = fcmp ogt double %93, %103
%105 = xor i1 %25, true
%106 = or i1 %104, %105
br i1 %106, label %445, label %107
107: ; preds = %102
%108 = getelementptr inbounds double, double* %5, i64 %72
%109 = getelementptr inbounds double, double* %5, i64 %83
br label %110
110: ; preds = %442, %107
%111 = phi double [ %100, %107 ], [ %444, %442 ]
%112 = phi i64 [ 0, %107 ], [ %440, %442 ]
%113 = phi <2 x double> [ %73, %107 ], [ %438, %442 ]
%114 = phi <2 x double> [ %74, %107 ], [ %439, %442 ]
%115 = getelementptr inbounds double, double* %8, i64 %112
%116 = fcmp olt double %111, %93
%117 = fcmp ogt double %111, %99
%118 = select i1 %116, i1 true, i1 %117
br i1 %118, label %437, label %119
119: ; preds = %110
%120 = load double*, double** %75
%121 = getelementptr inbounds double, double* %120, i64 %64
%122 = load double, double* %121
%123 = fsub double %122, %111
store double %123, double* %29
%124 = load double, double* %108
store double %124, double* %39
%125 = load double, double* %70
store double %125, double* %40
%126 = fcmp ogt double %123, 0.000000e+00
br i1 %126, label %127, label %128
127: ; preds = %119
store i32 1, i32* %43
br label %132
128: ; preds = %119
%129 = fcmp olt double %123, 0.000000e+00
br i1 %129, label %130, label %131
130: ; preds = %128
store i32 -1, i32* %42
br label %132
131: ; preds = %128
store i32 0, i32* %41
br label %132
132: ; preds = %127, %131, %130
%133 = load double*, double** %84
%134 = getelementptr inbounds double, double* %133, i64 %64
%135 = load double, double* %134
%136 = fsub double %135, %111
store double %136, double* %28
%137 = load double, double* %109
store double %137, double* %44
store double %125, double* %45
%138 = fcmp ogt double %136, 0.000000e+00
br i1 %138, label %143, label %139
139: ; preds = %132
%140 = fcmp olt double %136, 0.000000e+00
br i1 %140, label %142, label %141
141: ; preds = %139
store i32 0, i32* %46
br label %144
142: ; preds = %139
store i32 -1, i32* %47
br label %144
143: ; preds = %132
store i32 1, i32* %48
br label %144
144: ; preds = %143, %142, %141
%145 = load double*, double** %84
%146 = getelementptr inbounds double, double* %145, i64 %67
%147 = load double, double* %146
%148 = fsub double %147, %111
store double %148, double* %27
store double %137, double* %49
%149 = load double, double* %69
store double %149, double* %50
%150 = fcmp ogt double %148, 0.000000e+00
br i1 %150, label %155, label %151
151: ; preds = %144
%152 = fcmp olt double %148, 0.000000e+00
br i1 %152, label %154, label %153
153: ; preds = %151
store i32 0, i32* %51
br label %156
154: ; preds = %151
store i32 -1, i32* %52
br label %156
155: ; preds = %144
store i32 1, i32* %53
br label %156
156: ; preds = %155, %154, %153
%157 = load double*, double** %75
%158 = getelementptr inbounds double, double* %157, i64 %67
%159 = load double, double* %158
%160 = fsub double %159, %111
store double %160, double* %26
store double %124, double* %54
store double %149, double* %55
%161 = fcmp ogt double %160, 0.000000e+00
br i1 %161, label %166, label %162
162: ; preds = %156
%163 = fcmp olt double %160, 0.000000e+00
br i1 %163, label %165, label %164
164: ; preds = %162
store i32 0, i32* %56
br label %167
165: ; preds = %162
store i32 -1, i32* %57
br label %167
166: ; preds = %156
store i32 1, i32* %58
br label %167
167: ; preds = %166, %165, %164
%168 = phi i32 [ 1, %166 ], [ -1, %165 ], [ 0, %164 ]
%169 = fadd double %160, %148
%170 = fadd double %169, %136
%171 = fadd double %170, %123
%172 = fmul double %171, 2.500000e-01
store double %172, double* %30
%173 = insertelement <2 x double> poison, double %124, i64 0
%174 = insertelement <2 x double> %173, double %149, i64 1
%175 = insertelement <2 x double> poison, double %137, i64 0
%176 = insertelement <2 x double> %175, double %125, i64 1
%177 = fadd <2 x double> %174, %176
%178 = fmul <2 x double> %177, <double 5.000000e-01, double 5.000000e-01>
%179 = extractelement <2 x double> %178, i64 0
store double %179, double* %31
%180 = extractelement <2 x double> %178, i64 1
store double %180, double* %32
%181 = fcmp ogt double %172, 0.000000e+00
br i1 %181, label %186, label %182
182: ; preds = %167
%183 = fcmp olt double %172, 0.000000e+00
br i1 %183, label %185, label %184
184: ; preds = %182
store i32 0, i32* %33
br label %187
185: ; preds = %182
store i32 -1, i32* %33
br label %187
186: ; preds = %167
store i32 1, i32* %33
br label %187
187: ; preds = %186, %185, %184
%188 = phi i64 [ 2, %186 ], [ 0, %185 ], [ 1, %184 ]
%189 = fneg double %172
%190 = insertelement <2 x double> poison, double %172, i64 0
%191 = shufflevector <2 x double> %190, <2 x double> poison, <2 x i32> zeroinitializer
%192 = insertelement <2 x double> poison, double %189, i64 0
%193 = shufflevector <2 x double> %192, <2 x double> poison, <2 x i32> zeroinitializer
%194 = insertelement <2 x double> poison, double %172, i64 0
%195 = shufflevector <2 x double> %194, <2 x double> poison, <2 x i32> zeroinitializer
%196 = insertelement <2 x double> poison, double %189, i64 0
%197 = shufflevector <2 x double> %196, <2 x double> poison, <2 x i32> zeroinitializer
%198 = insertelement <2 x double> poison, double %189, i64 0
%199 = shufflevector <2 x double> %198, <2 x double> poison, <2 x i32> zeroinitializer
%200 = insertelement <2 x double> poison, double %172, i64 0
%201 = shufflevector <2 x double> %200, <2 x double> poison, <2 x i32> zeroinitializer
br label %202
202: ; preds = %434, %187
%203 = phi i32 [ %168, %187 ], [ %436, %434 ]
%204 = phi i64 [ 1, %187 ], [ %208, %434 ]
%205 = phi <2 x double> [ %113, %187 ], [ %431, %434 ]
%206 = phi <2 x double> [ %114, %187 ], [ %432, %434 ]
%207 = icmp eq i64 %204, 4
%208 = add nuw nsw i64 %204, 1
%209 = add nsw i32 %203, 1
%210 = sext i32 %209 to i64
%211 = and i64 %208, 4294967295
%212 = select i1 %207, i64 1, i64 %211
%213 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %212
%214 = load i32, i32* %213
%215 = add nsw i32 %214, 1
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [3 x [3 x [3 x i32]]], [3 x [3 x [3 x i32]]]* @__const.Contour.castab, i64 0, i64 %210, i64 %188, i64 %216
%218 = load i32, i32* %217
switch i32 %218, label %422 [
i32 0, label %430
i32 1, label %219
i32 2, label %226
i32 3, label %233
i32 4, label %246
i32 5, label %269
i32 6, label %297
i32 7, label %315
i32 8, label %349
i32 9, label %385
]
219: ; preds = %202
%220 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%221 = load double, double* %220
%222 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%223 = load double, double* %222
%224 = insertelement <2 x double> poison, double %221, i64 0
%225 = insertelement <2 x double> %224, double %223, i64 1
br label %422
226: ; preds = %202
%227 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%228 = load double, double* %227
%229 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%230 = load double, double* %229
%231 = insertelement <2 x double> poison, double %228, i64 0
%232 = insertelement <2 x double> %231, double %230, i64 1
br label %422
233: ; preds = %202
%234 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%235 = load double, double* %234
%236 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%237 = load double, double* %236
%238 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%239 = load double, double* %238
%240 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%241 = load double, double* %240
%242 = insertelement <2 x double> poison, double %239, i64 0
%243 = insertelement <2 x double> %242, double %241, i64 1
%244 = insertelement <2 x double> poison, double %235, i64 0
%245 = insertelement <2 x double> %244, double %237, i64 1
br label %422
246: ; preds = %202
%247 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%248 = load double, double* %247
%249 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%250 = load double, double* %249
%251 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %212
%252 = load double, double* %251
%253 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%254 = load double, double* %253
%255 = fsub double %252, %172
%256 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%257 = load double, double* %256
%258 = insertelement <2 x double> poison, double %254, i64 0
%259 = insertelement <2 x double> %258, double %257, i64 1
%260 = fmul <2 x double> %259, %197
%261 = insertelement <2 x double> poison, double %252, i64 0
%262 = shufflevector <2 x double> %261, <2 x double> poison, <2 x i32> zeroinitializer
%263 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %262, <2 x double> %178, <2 x double> %260)
%264 = insertelement <2 x double> poison, double %255, i64 0
%265 = shufflevector <2 x double> %264, <2 x double> poison, <2 x i32> zeroinitializer
%266 = fdiv <2 x double> %263, %265
%267 = insertelement <2 x double> poison, double %248, i64 0
%268 = insertelement <2 x double> %267, double %250, i64 1
br label %422
269: ; preds = %202
%270 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %204
%271 = load double, double* %270
%272 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%273 = load double, double* %272
%274 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %212
%275 = load double, double* %274
%276 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%277 = load double, double* %276
%278 = fneg double %275
%279 = fsub double %271, %275
%280 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%281 = load double, double* %280
%282 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%283 = load double, double* %282
%284 = insertelement <2 x double> poison, double %277, i64 0
%285 = insertelement <2 x double> %284, double %283, i64 1
%286 = insertelement <2 x double> poison, double %278, i64 0
%287 = shufflevector <2 x double> %286, <2 x double> poison, <2 x i32> zeroinitializer
%288 = fmul <2 x double> %285, %287
%289 = insertelement <2 x double> poison, double %271, i64 0
%290 = shufflevector <2 x double> %289, <2 x double> poison, <2 x i32> zeroinitializer
%291 = insertelement <2 x double> poison, double %273, i64 0
%292 = insertelement <2 x double> %291, double %281, i64 1
%293 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %290, <2 x double> %292, <2 x double> %288)
%294 = insertelement <2 x double> poison, double %279, i64 0
%295 = shufflevector <2 x double> %294, <2 x double> poison, <2 x i32> zeroinitializer
%296 = fdiv <2 x double> %293, %295
br label %422
297: ; preds = %202
%298 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%299 = load double, double* %298
%300 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%301 = load double, double* %300
%302 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %204
%303 = load double, double* %302
%304 = fneg double %303
%305 = fsub double %172, %303
%306 = insertelement <2 x double> poison, double %304, i64 0
%307 = shufflevector <2 x double> %306, <2 x double> poison, <2 x i32> zeroinitializer
%308 = fmul <2 x double> %178, %307
%309 = insertelement <2 x double> poison, double %299, i64 0
%310 = insertelement <2 x double> %309, double %301, i64 1
%311 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %195, <2 x double> %310, <2 x double> %308)
%312 = insertelement <2 x double> poison, double %305, i64 0
%313 = shufflevector <2 x double> %312, <2 x double> poison, <2 x i32> zeroinitializer
%314 = fdiv <2 x double> %311, %313
br label %422
315: ; preds = %202
%316 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%317 = load double, double* %316
%318 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %204
%319 = load double, double* %318
%320 = fneg double %319
%321 = fsub double %172, %319
%322 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%323 = load double, double* %322
%324 = insertelement <2 x double> poison, double %320, i64 0
%325 = shufflevector <2 x double> %324, <2 x double> poison, <2 x i32> zeroinitializer
%326 = fmul <2 x double> %178, %325
%327 = insertelement <2 x double> poison, double %317, i64 0
%328 = insertelement <2 x double> %327, double %323, i64 1
%329 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %201, <2 x double> %328, <2 x double> %326)
%330 = insertelement <2 x double> poison, double %321, i64 0
%331 = shufflevector <2 x double> %330, <2 x double> poison, <2 x i32> zeroinitializer
%332 = fdiv <2 x double> %329, %331
%333 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %212
%334 = load double, double* %333
%335 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%336 = load double, double* %335
%337 = fsub double %334, %172
%338 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%339 = load double, double* %338
%340 = insertelement <2 x double> poison, double %336, i64 0
%341 = insertelement <2 x double> %340, double %339, i64 1
%342 = fmul <2 x double> %341, %193
%343 = insertelement <2 x double> poison, double %334, i64 0
%344 = shufflevector <2 x double> %343, <2 x double> poison, <2 x i32> zeroinitializer
%345 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %344, <2 x double> %178, <2 x double> %342)
%346 = insertelement <2 x double> poison, double %337, i64 0
%347 = shufflevector <2 x double> %346, <2 x double> poison, <2 x i32> zeroinitializer
%348 = fdiv <2 x double> %345, %347
br label %422
349: ; preds = %202
%350 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %212
%351 = load double, double* %350
%352 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%353 = load double, double* %352
%354 = fsub double %351, %172
%355 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%356 = load double, double* %355
%357 = insertelement <2 x double> poison, double %353, i64 0
%358 = insertelement <2 x double> %357, double %356, i64 1
%359 = fmul <2 x double> %358, %199
%360 = insertelement <2 x double> poison, double %351, i64 0
%361 = shufflevector <2 x double> %360, <2 x double> poison, <2 x i32> zeroinitializer
%362 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %361, <2 x double> %178, <2 x double> %359)
%363 = insertelement <2 x double> poison, double %354, i64 0
%364 = shufflevector <2 x double> %363, <2 x double> poison, <2 x i32> zeroinitializer
%365 = fdiv <2 x double> %362, %364
%366 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %204
%367 = load double, double* %366
%368 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%369 = load double, double* %368
%370 = fneg double %351
%371 = fsub double %367, %351
%372 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%373 = load double, double* %372
%374 = insertelement <2 x double> poison, double %369, i64 0
%375 = insertelement <2 x double> %374, double %373, i64 1
%376 = insertelement <2 x double> poison, double %370, i64 0
%377 = shufflevector <2 x double> %376, <2 x double> poison, <2 x i32> zeroinitializer
%378 = fmul <2 x double> %375, %377
%379 = insertelement <2 x double> poison, double %367, i64 0
%380 = shufflevector <2 x double> %379, <2 x double> poison, <2 x i32> zeroinitializer
%381 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %380, <2 x double> %358, <2 x double> %378)
%382 = insertelement <2 x double> poison, double %371, i64 0
%383 = shufflevector <2 x double> %382, <2 x double> poison, <2 x i32> zeroinitializer
%384 = fdiv <2 x double> %381, %383
br label %422
385: ; preds = %202
%386 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %204
%387 = load double, double* %386
%388 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %212
%389 = load double, double* %388
%390 = getelementptr inbounds [5 x double], [5 x double]* %11, i64 0, i64 %212
%391 = load double, double* %390
%392 = getelementptr inbounds [5 x double], [5 x double]* %13, i64 0, i64 %204
%393 = load double, double* %392
%394 = fneg double %391
%395 = fsub double %387, %391
%396 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %212
%397 = load double, double* %396
%398 = getelementptr inbounds [5 x double], [5 x double]* %14, i64 0, i64 %204
%399 = load double, double* %398
%400 = insertelement <2 x double> poison, double %393, i64 0
%401 = insertelement <2 x double> %400, double %399, i64 1
%402 = insertelement <2 x double> poison, double %394, i64 0
%403 = shufflevector <2 x double> %402, <2 x double> poison, <2 x i32> zeroinitializer
%404 = fmul <2 x double> %401, %403
%405 = insertelement <2 x double> poison, double %387, i64 0
%406 = shufflevector <2 x double> %405, <2 x double> poison, <2 x i32> zeroinitializer
%407 = insertelement <2 x double> poison, double %389, i64 0
%408 = insertelement <2 x double> %407, double %397, i64 1
%409 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %406, <2 x double> %408, <2 x double> %404)
%410 = insertelement <2 x double> poison, double %395, i64 0
%411 = shufflevector <2 x double> %410, <2 x double> poison, <2 x i32> zeroinitializer
%412 = fdiv <2 x double> %409, %411
%413 = fneg double %387
%414 = fsub double %172, %387
%415 = insertelement <2 x double> poison, double %413, i64 0
%416 = shufflevector <2 x double> %415, <2 x double> poison, <2 x i32> zeroinitializer
%417 = fmul <2 x double> %178, %416
%418 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %191, <2 x double> %401, <2 x double> %417)
%419 = insertelement <2 x double> poison, double %414, i64 0
%420 = shufflevector <2 x double> %419, <2 x double> poison, <2 x i32> zeroinitializer
%421 = fdiv <2 x double> %418, %420
br label %422
422: ; preds = %202, %385, %349, %315, %297, %269, %246, %233, %226, %219
%423 = phi <2 x double> [ %421, %385 ], [ %384, %349 ], [ %348, %315 ], [ %314, %297 ], [ %296, %269 ], [ %266, %246 ], [ %243, %233 ], [ %232, %226 ], [ %178, %219 ], [ %205, %202 ]
%424 = phi <2 x double> [ %412, %385 ], [ %365, %349 ], [ %332, %315 ], [ %310, %297 ], [ %178, %269 ], [ %268, %246 ], [ %245, %233 ], [ %178, %226 ], [ %225, %219 ], [ %206, %202 ]
%425 = load double, double* %115
%426 = extractelement <2 x double> %423, i64 0
%427 = extractelement <2 x double> %423, i64 1
%428 = extractelement <2 x double> %424, i64 0
%429 = extractelement <2 x double> %424, i64 1
tail call void %9(double %428, double %429, double %426, double %427, double %425)
br label %430
430: ; preds = %202, %422
%431 = phi <2 x double> [ %205, %202 ], [ %423, %422 ]
%432 = phi <2 x double> [ %206, %202 ], [ %424, %422 ]
%433 = icmp eq i64 %208, 5
br i1 %433, label %437, label %434
434: ; preds = %430
%435 = getelementptr inbounds [5 x i32], [5 x i32]* %12, i64 0, i64 %208
%436 = load i32, i32* %435
br label %202
437: ; preds = %430, %110
%438 = phi <2 x double> [ %113, %110 ], [ %431, %430 ]
%439 = phi <2 x double> [ %114, %110 ], [ %432, %430 ]
%440 = add nuw nsw i64 %112, 1
%441 = icmp eq i64 %440, %38
br i1 %441, label %445, label %442
442: ; preds = %437
%443 = getelementptr inbounds double, double* %8, i64 %440
%444 = load double, double* %443
br label %110
445: ; preds = %437, %102, %71
%446 = phi <2 x double> [ %73, %71 ], [ %73, %102 ], [ %438, %437 ]
%447 = phi <2 x double> [ %74, %71 ], [ %74, %102 ], [ %439, %437 ]
%448 = icmp eq i64 %83, %37
br i1 %448, label %59, label %71
449: ; preds = %59, %10
ret void
}