void uv_to_p_grid(int nlon, int nlat, double *grid1x, double *grid1y,
                  double *grid2x, double *grid2y, double *grid3x,
                  double *grid3y) {
  int gridsizex;
  int i, j;
  double gx, gy;
  double gx2, gy2;
  double *gxhelp, *gyhelp;
  gridsizex = (nlon + 2) * nlat;
  gxhelp = (double *)Malloc(
      __func__,
      "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
      "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Mrotuvb.c",
      165, (gridsizex * sizeof(double)));
  gyhelp = (double *)Malloc(
      __func__,
      "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
      "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Mrotuvb.c",
      166, (gridsizex * sizeof(double)));
  for (j = 0; j < nlat; j++)
    for (i = 0; i < nlon; i++) {
      gxhelp[((j) * (nlon + 2) + (i + 1))] = grid1x[((j) * (nlon) + (i))];
      gyhelp[((j) * (nlon + 2) + (i + 1))] = grid1y[((j) * (nlon) + (i))];
    }
  for (j = 0; j < nlat; j++) {
    gxhelp[((j) * (nlon + 2) + (0))] = gxhelp[((j) * (nlon + 2) + (nlon))];
    gxhelp[((j) * (nlon + 2) + (nlon + 1))] = gxhelp[((j) * (nlon + 2) + (1))];
    gyhelp[((j) * (nlon + 2) + (0))] = gyhelp[((j) * (nlon + 2) + (nlon))];
    gyhelp[((j) * (nlon + 2) + (nlon + 1))] = gyhelp[((j) * (nlon + 2) + (1))];
  }
  for (j = 0; j < nlat; j++)
    for (i = 0; i < nlon; i++) {
      grid3x[((j) * (nlon) + (i))] = (gxhelp[((j) * (nlon + 2) + (i))] +
                                      gxhelp[((j) * (nlon + 2) + (i + 1))]) *
                                     0.5;
      if ((gxhelp[((j) * (nlon + 2) + (i))] > 340 &&
           gxhelp[((j) * (nlon + 2) + (i + 1))] < 20) ||
          (gxhelp[((j) * (nlon + 2) + (i))] < 20 &&
           gxhelp[((j) * (nlon + 2) + (i + 1))] > 340)) {
        if (grid3x[((j) * (nlon) + (i))] < 180)
          grid3x[((j) * (nlon) + (i))] += 180;
        else
          grid3x[((j) * (nlon) + (i))] -= 180;
      }
      grid3y[((j) * (nlon) + (i))] = (gyhelp[((j) * (nlon + 2) + (i))] +
                                      gyhelp[((j) * (nlon + 2) + (i + 1))]) *
                                     0.5;
    }
  for (j = 0; j < nlat; j++)
    for (i = 0; i < nlon; i++) {
      gxhelp[((j) * (nlon + 2) + (i + 1))] = grid2x[((j) * (nlon) + (i))];
      gyhelp[((j) * (nlon + 2) + (i + 1))] = grid2y[((j) * (nlon) + (i))];
    }
  for (j = 0; j < nlat; j++) {
    gxhelp[((j) * (nlon + 2) + (0))] = gxhelp[((j) * (nlon + 2) + (nlon))];
    gxhelp[((j) * (nlon + 2) + (nlon + 1))] = gxhelp[((j) * (nlon + 2) + (1))];
    gyhelp[((j) * (nlon + 2) + (0))] = gyhelp[((j) * (nlon + 2) + (nlon))];
    gyhelp[((j) * (nlon + 2) + (nlon + 1))] = gyhelp[((j) * (nlon + 2) + (1))];
  }
  for (j = 1; j < nlat - 1; j++)
    for (i = 0; i < nlon; i++) {
      gx = (gxhelp[((j) * (nlon + 2) + (i + 1))] +
            gxhelp[((j - 1) * (nlon + 2) + (i + 1))]) *
           0.5;
      if ((gxhelp[((j) * (nlon + 2) + (i + 1))] > 340 &&
           gxhelp[((j - 1) * (nlon + 2) + (i + 1))] < 20) ||
          (gxhelp[((j) * (nlon + 2) + (i + 1))] < 20 &&
           gxhelp[((j - 1) * (nlon + 2) + (i + 1))] > 340)) {
        if (gx < 180)
          gx += 180;
        else
          gx -= 180;
      }
      gy = (gyhelp[((j) * (nlon + 2) + (i + 1))] +
            gyhelp[((j - 1) * (nlon + 2) + (i + 1))]) *
           0.5;
      gx2 = (gx + grid3x[((j) * (nlon) + (i))]) * 0.5;
      if ((gx > 340 && grid3x[((j) * (nlon) + (i))] < 20) ||
          (gx < 20 && grid3x[((j) * (nlon) + (i))] > 340)) {
        if (gx2 < 180)
          gx2 += 180;
        else
          gx2 -= 180;
      }
      gy2 = (gy + grid3y[((j) * (nlon) + (i))]) * 0.5;
      grid3x[((j) * (nlon) + (i))] = gx2;
      grid3y[((j) * (nlon) + (i))] = gy2;
    }
  Free(__func__,
       "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
       "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Mrotuvb.c",
       255, (gxhelp));
  Free(__func__,
       "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
       "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/Mrotuvb.c",
       256, (gyhelp));
}


x86 assembly (clang, -O0):
<uv_to_p_grid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%eax
add    $0x2,%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
lea    0xebe(%rip),%rdi
lea    0xec4(%rip),%rsi
mov    $0xa5,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x60(%rbp)
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
lea    0xe96(%rip),%rdi
lea    0xe9c(%rip),%rsi
mov    $0xa6,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1256 <uv_to_p_grid+0x136>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1243 <uv_to_p_grid+0x123>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11bd <uv_to_p_grid+0x9d>
jmp    1248 <uv_to_p_grid+0x128>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11aa <uv_to_p_grid+0x8a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1359 <uv_to_p_grid+0x239>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    125d <uv_to_p_grid+0x13d>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1588 <uv_to_p_grid+0x468>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1575 <uv_to_p_grid+0x455>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xc46(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xc01(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1437 <uv_to_p_grid+0x317>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xbe4(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
ja     1492 <uv_to_p_grid+0x372>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xbbb(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    150a <uv_to_p_grid+0x3ea>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb78(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    150a <uv_to_p_grid+0x3ea>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xb6d(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    14de <uv_to_p_grid+0x3be>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0xb49(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1505 <uv_to_p_grid+0x3e5>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xb1c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    150a <uv_to_p_grid+0x3ea>
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xabb(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1373 <uv_to_p_grid+0x253>
jmp    157a <uv_to_p_grid+0x45a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1360 <uv_to_p_grid+0x240>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    163b <uv_to_p_grid+0x51b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1628 <uv_to_p_grid+0x508>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15a2 <uv_to_p_grid+0x482>
jmp    162d <uv_to_p_grid+0x50d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    158f <uv_to_p_grid+0x46f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    173e <uv_to_p_grid+0x61e>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x4(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1642 <uv_to_p_grid+0x522>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1a86 <uv_to_p_grid+0x966>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a73 <uv_to_p_grid+0x953>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x854(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x81b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1820 <uv_to_p_grid+0x700>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x7fb(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
ja     1883 <uv_to_p_grid+0x763>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x7cd(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    18c8 <uv_to_p_grid+0x7a8>
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x787(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    18c8 <uv_to_p_grid+0x7a8>
movsd  0x78d(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    18ad <uv_to_p_grid+0x78d>
movsd  0x77a(%rip),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    18c3 <uv_to_p_grid+0x7a3>
movsd  -0x40(%rbp),%xmm0
movsd  0x75e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    18c8 <uv_to_p_grid+0x7a8>
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x6f5(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x6c9(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0x6ab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1983 <uv_to_p_grid+0x863>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x698(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
ja     19be <uv_to_p_grid+0x89e>
movsd  0x685(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    1a03 <uv_to_p_grid+0x8e3>
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x64c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1a03 <uv_to_p_grid+0x8e3>
movsd  0x652(%rip),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    19e8 <uv_to_p_grid+0x8c8>
movsd  0x63f(%rip),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    19fe <uv_to_p_grid+0x8de>
movsd  -0x50(%rbp),%xmm0
movsd  0x623(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1a03 <uv_to_p_grid+0x8e3>
movsd  -0x48(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x5e2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    175d <uv_to_p_grid+0x63d>
jmp    1a78 <uv_to_p_grid+0x958>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1745 <uv_to_p_grid+0x625>
mov    -0x60(%rbp),%rcx
lea    0x58f(%rip),%rdi
lea    0x595(%rip),%rsi
mov    $0xff,%edx
mov    $0x0,%al
call   1040 <Free@plt>
mov    -0x68(%rbp),%rcx
lea    0x571(%rip),%rdi
lea    0x577(%rip),%rsi
mov    $0x100,%edx
mov    $0x0,%al
call   1040 <Free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<uv_to_p_grid>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,0x68(%rsp)
mov    %r8,0x88(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rdx,0x38(%rsp)
mov    %esi,%ebx
mov    %edi,%r15d
mov    0x168(%rsp),%rax
mov    %rax,0xc0(%rsp)
mov    0x160(%rsp),%rax
mov    %rax,0xb8(%rsp)
lea    0x2(%r15),%r14d
mov    %r14d,%eax
imul   %esi,%eax
movslq %eax,%rbp
shl    $0x3,%rbp
lea    0x1ee3(%rip),%r12
lea    0x1ee9(%rip),%rsi
mov    %r12,%rdi
mov    $0xa5,%edx
mov    %rbp,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
movslq %eax,%r13
mov    %r12,%rdi
lea    0x1eca(%rip),%rsi
mov    $0xa6,%edx
mov    %rbp,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
movslq %eax,%r12
test   %ebx,%ebx
jle    206e <uv_to_p_grid+0xf4e>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0xf8(%rsp)
movslq %r15d,%rdx
movslq %r14d,%rax
mov    %rax,0xa0(%rsp)
mov    %rbx,0xa8(%rsp)
mov    %ebx,%eax
mov    %rax,0x30(%rsp)
mov    %r15d,%eax
lea    0x8(%r13),%r9
lea    0x8(%r13,%rax,8),%rsi
lea    0x8(%r12),%r14
lea    (%r12,%rax,8),%rcx
add    $0x8,%rcx
mov    %eax,%edi
and    $0xfffffffc,%edi
mov    %rdi,0xc8(%rsp)
add    $0xfffffffffffffffc,%rdi
mov    %rdi,0x100(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rcx,0x90(%rsp)
cmp    %rcx,%r9
setb   %cl
mov    %rsi,0x98(%rsp)
cmp    %rsi,%r14
setb   %bl
and    %cl,%bl
mov    %bl,0xd8(%rsp)
mov    %rax,%rcx
mov    %rdi,%rax
mov    %rdi,0xd0(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xb0(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x108(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0xf0(%rsp)
mov    %rdx,0x80(%rsp)
lea    0x10(,%rdx,8),%rax
mov    %rax,0x40(%rsp)
mov    %r12,0x28(%rsp)
lea    0x38(%r12),%rbx
mov    %r13,0x20(%rsp)
lea    0x38(%r13),%rdi
mov    0x8(%rsp),%rdx
lea    0x30(%rdx),%rbp
mov    0x38(%rsp),%rax
lea    0x30(%rax),%rsi
lea    0x8(%rax),%r10
lea    0x8(%rdx),%r8
xor    %r13d,%r13d
mov    %r9,0xe8(%rsp)
mov    %r14,0xe0(%rsp)
mov    %r14,%r12
mov    %r15,0x18(%rsp)
mov    %rcx,(%rsp)
jmp    1324 <uv_to_p_grid+0x204>
xchg   %ax,%ax
add    $0x1,%r13
mov    0x40(%rsp),%rdx
add    %rdx,%rbx
add    %rdx,%rdi
mov    0xf0(%rsp),%rax
add    %rax,%rbp
add    %rax,%rsi
add    %rdx,%r12
add    %rdx,%r9
add    %rax,%r10
add    %rax,%r8
cmp    0x30(%rsp),%r13
je     162f <uv_to_p_grid+0x50f>
test   %r15d,%r15d
jle    12f0 <uv_to_p_grid+0x1d0>
mov    %r13,%rdx
imul   0x80(%rsp),%rdx
mov    %r13,%rax
imul   0xa0(%rsp),%rax
mov    %rax,0x58(%rsp)
cmp    $0x4,%r15d
mov    %rdx,0x60(%rsp)
jae    1360 <uv_to_p_grid+0x240>
xor    %r14d,%r14d
jmp    1560 <uv_to_p_grid+0x440>
nopl   0x0(%rax)
mov    0x40(%rsp),%r14
imul   %r13,%r14
mov    0xe8(%rsp),%rax
add    %r14,%rax
mov    %rax,0x48(%rsp)
mov    0x98(%rsp),%rax
add    %r14,%rax
mov    %rax,0x10(%rsp)
mov    0xe0(%rsp),%rax
add    %r14,%rax
mov    %rax,0x50(%rsp)
add    0x90(%rsp),%r14
lea    (%rdx,%rcx,1),%r11
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,8),%r15
mov    %r15,0x78(%rsp)
lea    (%rax,%r11,8),%rcx
mov    %rcx,0x70(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r11,8),%r11
mov    0x48(%rsp),%rax
cmp    %rcx,%rax
setb   %cl
cmp    %r15,0x10(%rsp)
seta   %r15b
and    %cl,%r15b
or     0xd8(%rsp),%r15b
cmp    %r11,%rax
mov    0x8(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
setb   0x48(%rsp)
cmp    %rdx,0x10(%rsp)
seta   0x10(%rsp)
mov    0x50(%rsp),%rax
cmp    0x70(%rsp),%rax
setb   %cl
cmp    0x78(%rsp),%r14
seta   0x78(%rsp)
cmp    %r11,%rax
setb   %al
cmp    %rdx,%r14
seta   %r11b
test   %r15b,%r15b
jne    1549 <uv_to_p_grid+0x429>
mov    0x10(%rsp),%dl
and    %dl,0x48(%rsp)
jne    1549 <uv_to_p_grid+0x429>
and    0x78(%rsp),%cl
jne    1549 <uv_to_p_grid+0x429>
mov    $0x0,%r14d
and    %r11b,%al
mov    0x18(%rsp),%r15
mov    (%rsp),%rcx
jne    1560 <uv_to_p_grid+0x440>
cmpq   $0x0,0x100(%rsp)
je     1615 <uv_to_p_grid+0x4f5>
mov    0xb0(%rsp),%rcx
xor    %edx,%edx
mov    0x8(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rdx,8),%xmm0
movups -0x20(%rsi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rdi,%rdx,8)
movups %xmm1,-0x20(%rdi,%rdx,8)
movups -0x30(%rbp,%rdx,8),%xmm0
movups -0x20(%rbp,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movups -0x10(%rsi,%rdx,8),%xmm0
movups (%rsi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rdi,%rdx,8)
movups %xmm1,(%rdi,%rdx,8)
movupd -0x10(%rbp,%rdx,8),%xmm0
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd %xmm0,-0x10(%rbx,%rdx,8)
movupd %xmm1,(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1480 <uv_to_p_grid+0x360>
testb  $0x1,0xd0(%rsp)
01
je     152f <uv_to_p_grid+0x40f>
mov    0x60(%rsp),%rax
add    %rdx,%rax
mov    0x38(%rsp),%rcx
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
or     $0x1,%rdx
add    0x58(%rsp),%rdx
mov    0x20(%rsp),%rcx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
mov    0x28(%rsp),%rax
movupd %xmm0,(%rax,%rdx,8)
movupd %xmm1,0x10(%rax,%rdx,8)
mov    0xc8(%rsp),%rax
mov    %rax,%r14
mov    (%rsp),%rcx
cmp    %rcx,%rax
je     12f0 <uv_to_p_grid+0x1d0>
jmp    1560 <uv_to_p_grid+0x440>
xor    %r14d,%r14d
mov    0x18(%rsp),%r15
mov    (%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rdx
test   $0x1,%cl
je     15b0 <uv_to_p_grid+0x490>
mov    0x60(%rsp),%r15
add    %r14,%r15
mov    0x38(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mov    %r14,%rdx
or     $0x1,%rdx
mov    0x58(%rsp),%r11
add    %rdx,%r11
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%r11,8)
mov    0x8(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mov    0x18(%rsp),%r15
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rax,%r11,8)
not    %r14
cmp    0x108(%rsp),%r14
je     12f0 <uv_to_p_grid+0x1d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r10,%rdx,8),%xmm0
movsd  %xmm0,(%r9,%rdx,8)
movsd  -0x8(%r8,%rdx,8),%xmm0
movsd  %xmm0,(%r12,%rdx,8)
movsd  (%r10,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r9,%rdx,8)
movsd  (%r8,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r12,%rdx,8)
lea    0x2(%rdx),%rax
mov    %rax,%rdx
cmp    %rax,%rcx
jne    15d0 <uv_to_p_grid+0x4b0>
jmp    12f0 <uv_to_p_grid+0x1d0>
xor    %edx,%edx
mov    0x8(%rsp),%r14
testb  $0x1,0xd0(%rsp)
01
jne    14e5 <uv_to_p_grid+0x3c5>
jmp    152f <uv_to_p_grid+0x40f>
mov    0xa8(%rsp),%rax
test   %eax,%eax
mov    0x20(%rsp),%r13
mov    0x28(%rsp),%r12
mov    0x40(%rsp),%rbx
mov    0x30(%rsp),%rdi
jle    206e <uv_to_p_grid+0xf4e>
mov    0x80(%rsp),%rcx
lea    0x8(,%rcx,8),%rsi
add    %r13,%rsi
lea    (%r12,%rcx,8),%rbp
add    $0x8,%rbp
xor    %ecx,%ecx
mov    %rdi,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rsi,%rcx,1),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,1)
movsd  0x8(%r13,%rcx,1),%xmm0
movsd  %xmm0,(%rsi,%rcx,1)
movsd  -0x8(%rbp,%rcx,1),%xmm0
movsd  %xmm0,(%r12,%rcx,1)
movsd  0x8(%r12,%rcx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,1)
add    %rbx,%rcx
add    $0xffffffffffffffff,%rdx
jne    1680 <uv_to_p_grid+0x560>
mov    %rbp,0x110(%rsp)
mov    %rsi,0x118(%rsp)
test   %eax,%eax
jle    206e <uv_to_p_grid+0xf4e>
mov    (%rsp),%rax
and    $0xfffffffe,%eax
mov    %rax,0x50(%rsp)
lea    0x8(%r12),%rsi
lea    0x8(%r13),%r10
xor    %r8d,%r8d
movsd  0x1955(%rip),%xmm0
movsd  0x1954(%rip),%xmm11
movsd  0x1953(%rip),%xmm10
movsd  0x1932(%rip),%xmm8
lea    0x191b(%rip),%r11
movapd 0x18e2(%rip),%xmm9
movapd 0x18e9(%rip),%xmm13
movapd 0x18f0(%rip),%xmm12
mov    0xc0(%rsp),%r9
mov    0xb8(%rsp),%r14
jmp    1774 <uv_to_p_grid+0x654>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
add    %rbx,%rsi
add    %rbx,%r10
mov    0xf0(%rsp),%rax
add    %rax,%r14
add    %rax,%r9
add    %rbx,%r12
cmp    %rdi,%r8
je     1a51 <uv_to_p_grid+0x931>
test   %r15d,%r15d
jle    1750 <uv_to_p_grid+0x630>
cmp    $0x1,%r15d
jne    1790 <uv_to_p_grid+0x670>
xor    %ecx,%ecx
jmp    1a07 <uv_to_p_grid+0x8e7>
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rax
imul   0x80(%rsp),%rax
mov    (%rsp),%rcx
add    %rax,%rcx
mov    %rbx,%rdi
imul   %r8,%rdi
lea    (%rdi,%r13,1),%r15
mov    %r15,0x10(%rsp)
mov    0x98(%rsp),%rdx
add    %rdi,%rdx
mov    0x28(%rsp),%rbx
add    %rdi,%rbx
mov    %rbx,0x58(%rsp)
add    0x90(%rsp),%rdi
mov    0xb8(%rsp),%rbp
lea    0x0(,%rax,8),%rbx
add    %rbp,%rbx
lea    0x0(%rbp,%rcx,8),%rbp
mov    0xc0(%rsp),%r13
lea    0x0(,%rax,8),%rax
add    %r13,%rax
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cmp    %rcx,%rbx
setb   0x8(%rsp)
cmp    %rbp,%rax
setb   0x60(%rsp)
cmp    %rbx,%rdx
seta   %r13b
cmp    %rbp,%r15
setb   0x38(%rsp)
cmp    %rbx,%rdi
seta   %r15b
mov    0x58(%rsp),%rbx
cmp    %rbp,%rbx
setb   %bpl
cmp    %rax,%rdx
seta   %dl
cmp    %rcx,0x10(%rsp)
setb   0x10(%rsp)
cmp    %rax,%rdi
seta   %dil
cmp    %rcx,%rbx
setb   %al
mov    0x60(%rsp),%cl
test   %cl,0x8(%rsp)
jne    19b2 <uv_to_p_grid+0x892>
and    0x38(%rsp),%r13b
jne    19b2 <uv_to_p_grid+0x892>
and    %bpl,%r15b
mov    0x18(%rsp),%r15
mov    0x20(%rsp),%r13
mov    0x40(%rsp),%rbx
jne    19a9 <uv_to_p_grid+0x889>
and    0x10(%rsp),%dl
jne    19a9 <uv_to_p_grid+0x889>
mov    $0x0,%ecx
and    %al,%dil
mov    0x30(%rsp),%rdi
jne    1a07 <uv_to_p_grid+0x8e7>
xor    %ecx,%ecx
mov    0x50(%rsp),%rdx
jmp    18d7 <uv_to_p_grid+0x7b7>
nop
movupd -0x8(%rsi,%rcx,8),%xmm1
movupd (%rsi,%rcx,8),%xmm2
addpd  %xmm1,%xmm2
mulpd  %xmm9,%xmm2
movupd %xmm2,(%r9,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
je     199b <uv_to_p_grid+0x87b>
movupd -0x8(%r10,%rcx,8),%xmm3
movupd (%r10,%rcx,8),%xmm7
addpd  %xmm3,%xmm7
mulpd  %xmm9,%xmm7
movupd %xmm7,(%r14,%rcx,8)
movupd -0x8(%r10,%rcx,8),%xmm4
movupd (%r10,%rcx,8),%xmm3
movapd %xmm13,%xmm5
cmpnltpd %xmm4,%xmm5
movapd %xmm13,%xmm1
cmpltpd %xmm4,%xmm1
movapd %xmm3,%xmm2
cmpltpd %xmm12,%xmm2
cmpltpd %xmm12,%xmm4
movapd %xmm13,%xmm6
cmpltpd %xmm3,%xmm6
cmpnltpd %xmm12,%xmm3
andpd  %xmm4,%xmm6
andpd  %xmm1,%xmm3
orpd   %xmm5,%xmm3
andpd  %xmm6,%xmm3
andpd  %xmm1,%xmm2
orpd   %xmm3,%xmm2
movd   %xmm2,%eax
test   $0x1,%al
je     196e <uv_to_p_grid+0x84e>
xor    %eax,%eax
ucomisd %xmm7,%xmm8
seta   %al
movsd  (%r11,%rax,8),%xmm1
addsd  %xmm7,%xmm1
movsd  %xmm1,(%r14,%rcx,8)
pextrw $0x4,%xmm2,%eax
test   $0x1,%al
je     18b0 <uv_to_p_grid+0x790>
unpckhpd %xmm7,%xmm7
xor    %eax,%eax
ucomisd %xmm7,%xmm8
seta   %al
addsd  (%r11,%rax,8),%xmm7
movsd  %xmm7,0x8(%r14,%rcx,8)
jmp    18b0 <uv_to_p_grid+0x790>
mov    %rdx,%rcx
cmp    (%rsp),%rdx
jne    1a07 <uv_to_p_grid+0x8e7>
jmp    1750 <uv_to_p_grid+0x630>
xor    %ecx,%ecx
mov    0x30(%rsp),%rdi
jmp    1a07 <uv_to_p_grid+0x8e7>
xor    %ecx,%ecx
mov    0x18(%rsp),%r15
mov    0x20(%rsp),%r13
mov    0x40(%rsp),%rbx
mov    0x30(%rsp),%rdi
jmp    1a07 <uv_to_p_grid+0x8e7>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
ucomisd %xmm3,%xmm8
seta   %al
addsd  (%r11,%rax,8),%xmm3
movsd  %xmm3,(%r14,%rdx,8)
movsd  (%r12,%rdx,8),%xmm1
addsd  0x8(%r12,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rdx,8)
cmp    %rcx,(%rsp)
je     1750 <uv_to_p_grid+0x630>
mov    %rcx,%rdx
movsd  -0x8(%r10,%rcx,8),%xmm3
add    $0x1,%rcx
addsd  (%r10,%rdx,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,(%r14,%rdx,8)
movsd  -0x8(%r10,%rdx,8),%xmm7
ucomisd %xmm11,%xmm7
jbe    1a3b <uv_to_p_grid+0x91b>
ucomisd (%r10,%rdx,8),%xmm10
ja     19d0 <uv_to_p_grid+0x8b0>
ucomisd %xmm7,%xmm10
jbe    19e6 <uv_to_p_grid+0x8c6>
movsd  (%r10,%rdx,8),%xmm1
ucomisd %xmm11,%xmm1
ja     19d0 <uv_to_p_grid+0x8b0>
jmp    19e6 <uv_to_p_grid+0x8c6>
cmpl   $0x0,0xa8(%rsp)
mov    0x28(%rsp),%r12
jle    206e <uv_to_p_grid+0xf4e>
lea    0x8(%r13),%r11
lea    0x8(%r12),%r14
cmp    0x90(%rsp),%r11
setb   %al
cmp    0x98(%rsp),%r14
setb   %cl
and    %al,%cl
mov    %cl,0xb0(%rsp)
mov    (%rsp),%rcx
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x120(%rsp)
mov    0xd0(%rsp),%rax
and    %rax,0xf8(%rsp)
lea    0x38(%r12),%rsi
mov    0xa0(%rsp),%rdx
lea    0x0(,%rdx,8),%rax
lea    -0x10(,%rdx,8),%rdx
ff
mov    %rdx,0x58(%rsp)
lea    0x38(%r13),%rdi
mov    0x68(%rsp),%r9
lea    0x30(%r9),%rbx
mov    0x88(%rsp),%rdx
lea    0x30(%rdx),%rbp
lea    0x8(%rdx),%r8
lea    0x8(%r9),%r10
xor    %r9d,%r9d
mov    %r11,0xd8(%rsp)
mov    %r14,0xc8(%rsp)
mov    %r14,%r13
mov    %rax,0x60(%rsp)
jmp    1b46 <uv_to_p_grid+0xa26>
nopl   (%rax)
add    $0x1,%r9
mov    0x60(%rsp),%rax
add    %rax,%rsi
add    %rax,%rdi
mov    0x58(%rsp),%rdx
add    %rdx,%rbx
add    %rdx,%rbp
add    %rax,%r13
add    %rax,%r11
add    %rdx,%r8
add    %rdx,%r10
cmp    0x30(%rsp),%r9
mov    0x18(%rsp),%r15
je     1e6e <uv_to_p_grid+0xd4e>
test   %r15d,%r15d
jle    1b10 <uv_to_p_grid+0x9f0>
mov    %r9,%rax
imul   0x80(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    %r9,%rax
imul   0xa0(%rsp),%rax
mov    %rax,0x10(%rsp)
cmpl   $0x4,0x18(%rsp)
jae    1c30 <uv_to_p_grid+0xb10>
xor    %r14d,%r14d
mov    %r14,%rdx
test   $0x1,%cl
je     1bce <uv_to_p_grid+0xaae>
mov    0x8(%rsp),%r15
add    %r14,%r15
mov    0x88(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
mov    %r14,%rdx
or     $0x1,%rdx
mov    0x10(%rsp),%r12
add    %rdx,%r12
mov    0x20(%rsp),%rax
movsd  %xmm1,(%rax,%r12,8)
mov    0x68(%rsp),%rax
movsd  (%rax,%r15,8),%xmm1
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax,%r12,8)
mov    0x28(%rsp),%r12
not    %r14
cmp    0x108(%rsp),%r14
je     1b10 <uv_to_p_grid+0x9f0>
nop
movsd  -0x8(%r8,%rdx,8),%xmm1
movsd  %xmm1,(%r11,%rdx,8)
movsd  -0x8(%r10,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
movsd  (%r8,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r11,%rdx,8)
movsd  (%r10,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rdx,8)
lea    0x2(%rdx),%rax
mov    %rax,%rdx
cmp    %rax,%rcx
jne    1be0 <uv_to_p_grid+0xac0>
jmp    1b10 <uv_to_p_grid+0x9f0>
cs nopw 0x0(%rax,%rax,1)
mov    0x40(%rsp),%rax
imul   %r9,%rax
mov    0xd8(%rsp),%rdx
add    %rax,%rdx
mov    %rdx,0x70(%rsp)
mov    0x98(%rsp),%rdx
add    %rax,%rdx
mov    %rdx,0x48(%rsp)
mov    0xc8(%rsp),%rdx
add    %rax,%rdx
mov    %rdx,0x38(%rsp)
add    0x90(%rsp),%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rcx,1),%r12
mov    0x88(%rsp),%rcx
lea    (%rcx,%rdx,8),%r14
mov    %r14,0x50(%rsp)
lea    (%rcx,%r12,8),%r15
mov    %r15,0x78(%rsp)
mov    0x68(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
mov    %rcx,0xe8(%rsp)
mov    0x70(%rsp),%rdx
cmp    %r15,%rdx
setb   0xe0(%rsp)
mov    0x48(%rsp),%r15
cmp    %r14,%r15
seta   %r12b
and    0xe0(%rsp),%r12b
or     0xb0(%rsp),%r12b
cmp    %rcx,%rdx
mov    0x8(%rsp),%rdx
mov    0x68(%rsp),%rcx
lea    (%rcx,%rdx,8),%r14
setb   0x70(%rsp)
cmp    %r14,%r15
seta   0x48(%rsp)
mov    0x38(%rsp),%r15
cmp    0x78(%rsp),%r15
setb   %cl
cmp    0x50(%rsp),%rax
seta   0x50(%rsp)
cmp    0xe8(%rsp),%r15
setb   %dl
cmp    %r14,%rax
seta   %r15b
test   %r12b,%r12b
jne    1e5d <uv_to_p_grid+0xd3d>
mov    0x48(%rsp),%al
and    %al,0x70(%rsp)
mov    0x28(%rsp),%r12
jne    1e3f <uv_to_p_grid+0xd1f>
and    0x50(%rsp),%cl
jne    1e3f <uv_to_p_grid+0xd1f>
mov    $0x0,%r14d
and    %r15b,%dl
mov    (%rsp),%rcx
jne    1b7b <uv_to_p_grid+0xa5b>
cmpq   $0x0,0x100(%rsp)
je     1e4b <uv_to_p_grid+0xd2b>
mov    0xf8(%rsp),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rbp,%rdx,8),%xmm1
movups -0x20(%rbp,%rdx,8),%xmm2
movups %xmm1,-0x30(%rdi,%rdx,8)
movups %xmm2,-0x20(%rdi,%rdx,8)
movups -0x30(%rbx,%rdx,8),%xmm1
movups -0x20(%rbx,%rdx,8),%xmm2
movups %xmm1,-0x30(%rsi,%rdx,8)
movups %xmm2,-0x20(%rsi,%rdx,8)
movups -0x10(%rbp,%rdx,8),%xmm1
movups 0x0(%rbp,%rdx,8),%xmm2
movups %xmm1,-0x10(%rdi,%rdx,8)
movups %xmm2,(%rdi,%rdx,8)
movupd -0x10(%rbx,%rdx,8),%xmm1
movupd (%rbx,%rdx,8),%xmm2
movupd %xmm1,-0x10(%rsi,%rdx,8)
movupd %xmm2,(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1d70 <uv_to_p_grid+0xc50>
testb  $0x1,0xd0(%rsp)
01
je     1e22 <uv_to_p_grid+0xd02>
mov    0x8(%rsp),%rax
add    %rdx,%rax
mov    0x88(%rsp),%rcx
movups (%rcx,%rax,8),%xmm1
movups 0x10(%rcx,%rax,8),%xmm2
or     $0x1,%rdx
add    0x10(%rsp),%rdx
mov    0x20(%rsp),%rcx
movups %xmm1,(%rcx,%rdx,8)
movups %xmm2,0x10(%rcx,%rdx,8)
mov    0x68(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm1
movupd 0x10(%rcx,%rax,8),%xmm2
movupd %xmm1,(%r12,%rdx,8)
movupd %xmm2,0x10(%r12,%rdx,8)
mov    0x120(%rsp),%rax
mov    %rax,%r14
mov    (%rsp),%rcx
cmp    %rcx,%rax
je     1b10 <uv_to_p_grid+0x9f0>
jmp    1b7b <uv_to_p_grid+0xa5b>
xor    %r14d,%r14d
mov    (%rsp),%rcx
jmp    1b7b <uv_to_p_grid+0xa5b>
xor    %edx,%edx
testb  $0x1,0xd0(%rsp)
01
jne    1dd5 <uv_to_p_grid+0xcb5>
jmp    1e22 <uv_to_p_grid+0xd02>
xor    %r14d,%r14d
mov    0x28(%rsp),%r12
mov    (%rsp),%rcx
jmp    1b7b <uv_to_p_grid+0xa5b>
mov    0xa8(%rsp),%r10
test   %r10d,%r10d
mov    0x20(%rsp),%r13
mov    0x30(%rsp),%rdi
jle    206e <uv_to_p_grid+0xf4e>
mov    0xa0(%rsp),%rdx
lea    -0x10(,%rdx,8),%rcx
ff
add    %r13,%rcx
lea    (%r12,%rdx,8),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
mov    0x118(%rsp),%rbp
mov    0x110(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,1),%xmm1
movsd  %xmm1,0x0(%r13,%rsi,1)
movsd  0x8(%r13,%rsi,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,1)
movsd  (%rdx,%rsi,1),%xmm1
movsd  %xmm1,(%r12,%rsi,1)
movsd  0x8(%r12,%rsi,1),%xmm1
movsd  %xmm1,(%rbx,%rsi,1)
add    %rax,%rsi
add    $0xffffffffffffffff,%rdi
jne    1ec0 <uv_to_p_grid+0xda0>
cmp    $0x3,%r10d
jl     206e <uv_to_p_grid+0xf4e>
add    $0xffffffff,%r10d
mov    0xb8(%rsp),%rcx
mov    0x80(%rsp),%rdx
lea    (%rcx,%rdx,8),%rsi
mov    0xc0(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdi
shlq   $0x3,(%rsp)
lea    0x18(,%rdx,8),%r9
add    %r13,%r9
lea    0x18(%r12,%rdx,8),%rcx
mov    $0x1,%r8d
movsd  0x1116(%rip),%xmm4
mov    %r12,%rbx
mov    %r13,%rdx
jmp    1f8c <uv_to_p_grid+0xe6c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
mov    0xf0(%rsp),%rbp
add    %rbp,%rsi
add    %rbp,%rdi
mov    0x40(%rsp),%rbp
add    %rbp,%rdx
add    %rbp,%rbx
add    %rbp,%r9
add    %rbp,%rcx
cmp    %r10,%r8
je     206e <uv_to_p_grid+0xf4e>
test   %r15d,%r15d
jle    1f60 <uv_to_p_grid+0xe40>
xor    %ebp,%ebp
jmp    1fd0 <uv_to_p_grid+0xeb0>
cs nopw 0x0(%rax,%rax,1)
nop
addsd  %xmm4,%xmm6
movsd  (%rcx,%rbp,1),%xmm1
addsd  0x8(%rbx,%rbp,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rbp,1),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm6,(%rsi,%rbp,1)
movsd  %xmm1,(%rdi,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,(%rsp)
je     1f60 <uv_to_p_grid+0xe40>
movsd  (%r9,%rbp,1),%xmm6
movsd  0x8(%rdx,%rbp,1),%xmm3
movapd %xmm6,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm5
ucomisd %xmm11,%xmm6
jbe    1ff6 <uv_to_p_grid+0xed6>
ucomisd %xmm3,%xmm10
ja     2004 <uv_to_p_grid+0xee4>
ucomisd %xmm6,%xmm10
jbe    2024 <uv_to_p_grid+0xf04>
ucomisd %xmm11,%xmm3
jbe    2024 <uv_to_p_grid+0xf04>
ucomisd %xmm5,%xmm8
jbe    2020 <uv_to_p_grid+0xf00>
addsd  %xmm8,%xmm5
jmp    2024 <uv_to_p_grid+0xf04>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  %xmm4,%xmm5
movsd  (%rsi,%rbp,1),%xmm3
movapd %xmm5,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm0,%xmm6
ucomisd %xmm11,%xmm5
jbe    2043 <uv_to_p_grid+0xf23>
ucomisd %xmm3,%xmm10
ja     2059 <uv_to_p_grid+0xf39>
ucomisd %xmm5,%xmm10
jbe    1fa4 <uv_to_p_grid+0xe84>
ucomisd %xmm11,%xmm3
jbe    1fa4 <uv_to_p_grid+0xe84>
ucomisd %xmm6,%xmm8
jbe    1fa0 <uv_to_p_grid+0xe80>
addsd  %xmm8,%xmm6
jmp    1fa4 <uv_to_p_grid+0xe84>
lea    0xff3(%rip),%rbx
lea    0xff9(%rip),%rbp
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0xff,%edx
mov    %r13,%rcx
xor    %eax,%eax
call   1040 <Free@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x100,%edx
mov    %r12,%rcx
xor    %eax,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <Free@plt>

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

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