void mastrfu(int gridID, int zaxisID, double *array1, double *array2, int nmiss,
             double missval) {
  int nlev;
  int nlat;
  int ilev, ilat, n;
  double *plevel, *phi, *cosphi, *dummy;
  double fact = 4 * atan(1.0) * 6371000 / 9.81;
  double **field1, **field2;
  char units[256];
  nlat = gridInqSize(gridID);
  nlev = zaxisInqSize(zaxisID);
  phi = (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/Mastrfu.c",
      45, (nlat * sizeof(double)));
  dummy = (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/Mastrfu.c",
      46, (nlat * sizeof(double)));
  cosphi = (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/Mastrfu.c",
      47, (nlat * sizeof(double)));
  plevel = (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/Mastrfu.c",
      48, (nlev * sizeof(double)));
  field1 = (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/Mastrfu.c",
      49, (nlev * sizeof(double *)));
  field2 = (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/Mastrfu.c",
      50, (nlev * sizeof(double *)));
  zaxisInqLevels(zaxisID, plevel);
  gridInqYvals(gridID, phi);
  gridInqYunits(gridID, units);
  if (memcmp(units, "degree", 6) == 0)
    for (ilat = 0; ilat < nlat; ilat++)
      phi[ilat] *= (3.14159265358979323846 / 180.);
  for (ilat = 0; ilat < nlat; ilat++)
    phi[ilat] = sin(phi[ilat]);
  for (ilat = 0; ilat < nlat; ilat++)
    cosphi[ilat] = sqrt(1.0 - phi[ilat] * phi[ilat]);
  for (ilev = 0; ilev < nlev; ilev++) {
    field1[ilev] = array1 + ilev * nlat;
    field2[ilev] = array2 + ilev * nlat;
  }
  for (ilev = 0; ilev < nlev; ilev++)
    for (ilat = 0; ilat < nlat; ilat++)
      field2[ilev][ilat] = 0.0;
  if (nmiss == 0) {
    for (ilev = nlev - 1; ilev >= 0; ilev--)
      for (n = ilev; n < nlev - 1; n++)
        for (ilat = 0; ilat < nlat; ilat++) {
          field2[ilev][ilat] += fact * (field1[n][ilat] + field1[n + 1][ilat]) *
                                cosphi[ilat] * (plevel[n] - plevel[n + 1]);
        }
  } else {
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilev = nlev - 1; ilev >= 0; ilev--)
        for (n = ilev; n < nlev - 1; n++) {
          if ((((field1[n][ilat]) != (field1[n][ilat])) ||
                       ((missval) != (missval))
                   ? (((field1[n][ilat]) != (field1[n][ilat])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(field1[n][ilat] < missval ||
                       missval < field1[n][ilat]))) {
            field2[ilev][ilat] = missval;
            break;
          } else
            field2[ilev][ilat] += fact *
                                  (field1[n][ilat] + field1[n + 1][ilat]) *
                                  cosphi[ilat] * (plevel[n] - plevel[n + 1]);
        }
  }
  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/Mastrfu.c",
       102, (field2));
  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/Mastrfu.c",
       103, (field1));
  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/Mastrfu.c",
       104, (plevel));
  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/Mastrfu.c",
       105, (cosphi));
  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/Mastrfu.c",
       106, (dummy));
  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/Mastrfu.c",
       107, (phi));
}


x86 assembly (clang, -O0):
<mastrfu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  0xe3e(%rip),%xmm0
call   1080 <atan@plt>
movaps %xmm0,%xmm1
movsd  0xe26(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe12(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xdfe(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   10d0 <gridInqSize@plt>
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%edi
mov    $0x0,%al
call   1040 <zaxisInqSize@plt>
mov    %eax,-0x2c(%rbp)
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
lea    0xdf4(%rip),%rdi
lea    0xdf5(%rip),%rsi
mov    $0x2d,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x50(%rbp)
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
lea    0xdcc(%rip),%rdi
lea    0xdcd(%rip),%rsi
mov    $0x2e,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x60(%rbp)
movslq -0x30(%rbp),%rcx
shl    $0x3,%rcx
lea    0xda4(%rip),%rdi
lea    0xda5(%rip),%rsi
mov    $0x2f,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x58(%rbp)
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
lea    0xd7c(%rip),%rdi
lea    0xd7d(%rip),%rsi
mov    $0x30,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x48(%rbp)
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
lea    0xd54(%rip),%rdi
lea    0xd55(%rip),%rsi
mov    $0x31,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x70(%rbp)
movslq -0x2c(%rbp),%rcx
shl    $0x3,%rcx
lea    0xd2c(%rip),%rdi
lea    0xd2d(%rip),%rsi
mov    $0x32,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x48(%rbp),%rsi
mov    $0x0,%al
call   10c0 <zaxisInqLevels@plt>
mov    -0x4(%rbp),%edi
mov    -0x50(%rbp),%rsi
mov    $0x0,%al
call   1070 <gridInqYvals@plt>
mov    -0x4(%rbp),%edi
lea    -0x180(%rbp),%rsi
mov    $0x0,%al
call   10b0 <gridInqYunits@plt>
lea    -0x180(%rbp),%rdi
lea    0xd63(%rip),%rsi
mov    $0x6,%edx
call   1050 <memcmp@plt>
cmp    $0x0,%eax
jne    13a3 <mastrfu+0x1f3>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    139e <mastrfu+0x1ee>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0xc9a(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    136a <mastrfu+0x1ba>
jmp    13a3 <mastrfu+0x1f3>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    13e3 <mastrfu+0x233>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1060 <sin@plt>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13aa <mastrfu+0x1fa>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1457 <mastrfu+0x2a7>
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0xbe5(%rip),%xmm1
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13ea <mastrfu+0x23a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14b8 <mastrfu+0x308>
mov    -0x10(%rbp),%rdx
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rdx
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    145e <mastrfu+0x2ae>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1517 <mastrfu+0x367>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1504 <mastrfu+0x354>
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14d2 <mastrfu+0x322>
jmp    1509 <mastrfu+0x359>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14bf <mastrfu+0x30f>
cmpl   $0x0,-0x1c(%rbp)
jne    161d <mastrfu+0x46d>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1618 <mastrfu+0x468>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1605 <mastrfu+0x455>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15f2 <mastrfu+0x442>
movsd  -0x68(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1552 <mastrfu+0x3a2>
jmp    15f7 <mastrfu+0x447>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    153a <mastrfu+0x38a>
jmp    160a <mastrfu+0x45a>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    152a <mastrfu+0x37a>
jmp    184a <mastrfu+0x69a>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1845 <mastrfu+0x695>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1832 <mastrfu+0x682>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    181f <mastrfu+0x66f>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    16ab <mastrfu+0x4fb>
jp     16ab <mastrfu+0x4fb>
movsd  -0x28(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jne    16ab <mastrfu+0x4fb>
jp     16ab <mastrfu+0x4fb>
jmp    171f <mastrfu+0x56f>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    16e6 <mastrfu+0x536>
jp     16e6 <mastrfu+0x536>
jmp    1710 <mastrfu+0x560>
movsd  -0x28(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jne    1701 <mastrfu+0x551>
jp     1701 <mastrfu+0x551>
jmp    1710 <mastrfu+0x560>
mov    $0x1,%al
test   $0x1,%al
jne    1767 <mastrfu+0x5b7>
jmp    1786 <mastrfu+0x5d6>
xor    %eax,%eax
test   $0x1,%al
jne    1767 <mastrfu+0x5b7>
jmp    1786 <mastrfu+0x5d6>
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     1786 <mastrfu+0x5d6>
movsd  -0x28(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     1786 <mastrfu+0x5d6>
movsd  -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    181f <mastrfu+0x66f>
movsd  -0x68(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x70(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x48(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1811 <mastrfu+0x661>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1649 <mastrfu+0x499>
jmp    1824 <mastrfu+0x674>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1639 <mastrfu+0x489>
jmp    1837 <mastrfu+0x687>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1624 <mastrfu+0x474>
jmp    184a <mastrfu+0x69a>
mov    -0x78(%rbp),%rcx
lea    0x7d3(%rip),%rdi
lea    0x7d4(%rip),%rsi
mov    $0x66,%edx
mov    $0x0,%al
call   1090 <Free@plt>
mov    -0x70(%rbp),%rcx
lea    0x7b5(%rip),%rdi
lea    0x7b6(%rip),%rsi
mov    $0x67,%edx
mov    $0x0,%al
call   1090 <Free@plt>
mov    -0x48(%rbp),%rcx
lea    0x797(%rip),%rdi
lea    0x798(%rip),%rsi
mov    $0x68,%edx
mov    $0x0,%al
call   1090 <Free@plt>
mov    -0x58(%rbp),%rcx
lea    0x779(%rip),%rdi
lea    0x77a(%rip),%rsi
mov    $0x69,%edx
mov    $0x0,%al
call   1090 <Free@plt>
mov    -0x60(%rbp),%rcx
lea    0x75b(%rip),%rdi
lea    0x75c(%rip),%rsi
mov    $0x6a,%edx
mov    $0x0,%al
call   1090 <Free@plt>
mov    -0x50(%rbp),%rcx
lea    0x73d(%rip),%rdi
lea    0x73e(%rip),%rsi
mov    $0x6b,%edx
mov    $0x0,%al
call   1090 <Free@plt>
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mastrfu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
movsd  %xmm0,0x40(%rsp)
mov    %r8d,0x68(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x18(%rsp)
mov    %esi,%r14d
mov    %esi,0x38(%rsp)
mov    %edi,%ebx
mov    %edi,0x20(%rsp)
movsd  0xe15(%rip),%xmm0
call   1080 <atan@plt>
mov    %ebx,%edi
xor    %eax,%eax
call   10d0 <gridInqSize@plt>
mov    %eax,%ebp
mov    %r14d,%edi
xor    %eax,%eax
call   1040 <zaxisInqSize@plt>
mov    %eax,%r14d
mov    %ebp,0xc(%rsp)
movslq %ebp,%rax
mov    %rax,0x78(%rsp)
lea    0x0(,%rax,8),%rbx
lea    0xe1d(%rip),%r13
lea    0xe1e(%rip),%r12
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x2d,%edx
mov    %rbx,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
movslq %eax,%rbp
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x2e,%edx
mov    %rbx,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
mov    %eax,0x74(%rsp)
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x2f,%edx
mov    %rbx,0x58(%rsp)
mov    %rbx,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
mov    %eax,0x28(%rsp)
mov    %r14,0x30(%rsp)
movslq %r14d,%rax
mov    %rax,0x50(%rsp)
lea    0x0(,%rax,8),%r14
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x30,%edx
mov    %r14,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
movslq %eax,%r15
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x31,%edx
mov    %r14,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
mov    %eax,0x10(%rsp)
mov    %r13,%rdi
mov    %r12,%rsi
mov    $0x32,%edx
mov    %r14,%rcx
xor    %eax,%eax
call   1030 <Malloc@plt>
mov    %eax,%r14d
mov    0x38(%rsp),%edi
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <zaxisInqLevels@plt>
mov    0x20(%rsp),%ebx
mov    %ebx,%edi
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <gridInqYvals@plt>
lea    0x90(%rsp),%rsi
mov    %ebx,%edi
xor    %eax,%eax
call   10b0 <gridInqYunits@plt>
mov    $0x72676564,%eax
xor    0x90(%rsp),%eax
movzwl 0x94(%rsp),%ecx
xor    $0x6565,%ecx
or     %eax,%ecx
jne    1429 <mastrfu+0x279>
cmpl   $0x0,0xc(%rsp)
jle    1429 <mastrfu+0x279>
mov    0xc(%rsp),%ecx
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1345 <mastrfu+0x195>
xor    %ecx,%ecx
jmp    13fd <mastrfu+0x24d>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1c5f <mastrfu+0xaaf>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movapd 0xcad(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x0(%rbp,%rdx,8),%xmm1
movupd 0x10(%rbp,%rdx,8),%xmm2
movupd 0x20(%rbp,%rdx,8),%xmm3
movupd 0x30(%rbp,%rdx,8),%xmm4
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x0(%rbp,%rdx,8)
movupd %xmm2,0x10(%rbp,%rdx,8)
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm4
movupd %xmm3,0x20(%rbp,%rdx,8)
movupd %xmm4,0x30(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1380 <mastrfu+0x1d0>
test   $0x1,%sil
je     13f8 <mastrfu+0x248>
movupd 0x0(%rbp,%rdx,8),%xmm0
movupd 0x10(%rbp,%rdx,8),%xmm1
movapd 0xc3c(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm1
movupd %xmm0,0x0(%rbp,%rdx,8)
movupd %xmm1,0x10(%rbp,%rdx,8)
cmp    %rax,%rcx
je     1429 <mastrfu+0x279>
movsd  0xc03(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1410 <mastrfu+0x260>
movslq 0x28(%rsp),%r13
cmpl   $0x0,0xc(%rsp)
mov    %rbp,0x60(%rsp)
movsd  0x40(%rsp),%xmm3
mov    0x18(%rsp),%r10
mov    0x48(%rsp),%rbx
jle    1627 <mastrfu+0x477>
mov    %r14d,0x20(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,%r12d
lea    -0x1(%r12),%rcx
mov    %eax,%r14d
and    $0x3,%r14d
mov    %rcx,0x38(%rsp)
cmp    $0x3,%rcx
mov    %r12,0x28(%rsp)
jae    147a <mastrfu+0x2ca>
xor    %ebx,%ebx
jmp    14cd <mastrfu+0x31d>
and    $0xfffffffc,%r12d
xor    %ebx,%ebx
movsd  0x0(%rbp,%rbx,8),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x0(%rbp,%rbx,8)
movsd  0x8(%rbp,%rbx,8),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x8(%rbp,%rbx,8)
movsd  0x10(%rbp,%rbx,8),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x10(%rbp,%rbx,8)
movsd  0x18(%rbp,%rbx,8),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x18(%rbp,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r12
jne    1480 <mastrfu+0x2d0>
test   %r14,%r14
je     14f8 <mastrfu+0x348>
mov    0x60(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
xor    %ebp,%ebp
nopl   (%rax)
movsd  (%rbx,%rbp,8),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    14e0 <mastrfu+0x330>
cmpl   $0x0,0xc(%rsp)
mov    0x60(%rsp),%rbp
movsd  0x40(%rsp),%xmm3
mov    0x18(%rsp),%r10
mov    0x48(%rsp),%rbx
movsd  0xae6(%rip),%xmm2
mov    0x20(%rsp),%r14d
jle    1627 <mastrfu+0x477>
cmpq   $0x0,0x38(%rsp)
je     15db <mastrfu+0x42b>
mov    0x28(%rsp),%rbx
and    $0xfffffffe,%ebx
xor    %r12d,%r12d
xorpd  %xmm4,%xmm4
jmp    157c <mastrfu+0x3cc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
call   10a0 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0xa9f(%rip),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x18(%rsp),%r10
movsd  %xmm0,0x8(%r13,%r12,8)
add    $0x2,%r12
cmp    %r12,%rbx
je     15de <mastrfu+0x42e>
movsd  0x0(%rbp,%r12,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm2,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jb     15a0 <mastrfu+0x3f0>
sqrtsd %xmm0,%xmm0
jmp    15b1 <mastrfu+0x401>
nopl   0x0(%rax,%rax,1)
call   10a0 <sqrt@plt>
xorpd  %xmm4,%xmm4
movsd  0xa4f(%rip),%xmm2
movsd  %xmm0,0x0(%r13,%r12,8)
movsd  0x8(%rbp,%r12,8),%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm2,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm4,%xmm0
jb     1550 <mastrfu+0x3a0>
sqrtsd %xmm0,%xmm0
jmp    1561 <mastrfu+0x3b1>
xor    %r12d,%r12d
testb  $0x1,0x28(%rsp)
mov    0x48(%rsp),%rbx
je     1627 <mastrfu+0x477>
movsd  0x0(%rbp,%r12,8),%xmm0
mulsd  %xmm0,%xmm0
subsd  %xmm0,%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jb     160c <mastrfu+0x45c>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    1620 <mastrfu+0x470>
movapd %xmm2,%xmm0
call   10a0 <sqrt@plt>
mov    0x18(%rsp),%r10
movsd  0x40(%rsp),%xmm3
movsd  %xmm0,0x0(%r13,%r12,8)
movslq 0x10(%rsp),%rax
mov    %rax,0x10(%rsp)
movslq %r14d,%r14
mov    0x30(%rsp),%rax
test   %eax,%eax
mov    0xc(%rsp),%r12d
jle    1810 <mastrfu+0x660>
mov    %eax,%edx
lea    -0x1(%rdx),%rsi
and    $0x3,%eax
mov    %rax,0x88(%rsp)
mov    %rsi,0x80(%rsp)
cmp    $0x3,%rsi
mov    %rdx,0x38(%rsp)
jae    1676 <mastrfu+0x4c6>
xor    %eax,%eax
mov    0x10(%rsp),%rcx
jmp    1728 <mastrfu+0x578>
and    $0xfffffffc,%edx
mov    %rdx,0x28(%rsp)
mov    0x78(%rsp),%rax
mov    %rax,%rsi
shl    $0x4,%rsi
lea    (%rbx,%rsi,1),%rdx
mov    %rdx,0x20(%rsp)
mov    %rbx,%r11
mov    %rax,%rbx
shl    $0x5,%rbx
add    %r10,%rsi
lea    (%r11,%rax,8),%r12
lea    (%r10,%rax,8),%rdx
mov    0x58(%rsp),%rax
lea    (%rax,%rax,2),%rdi
lea    (%r11,%rdi,1),%r8
add    %r10,%rdi
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%r9,1),%rbp
mov    %rbp,(%rcx,%rax,8)
lea    (%r11,%r9,1),%rbp
mov    %rbp,(%r14,%rax,8)
lea    (%rdx,%r9,1),%rbp
mov    %rbp,0x8(%rcx,%rax,8)
lea    (%r12,%r9,1),%rbp
mov    %rbp,0x8(%r14,%rax,8)
lea    (%rsi,%r9,1),%rbp
mov    %rbp,0x10(%rcx,%rax,8)
mov    0x20(%rsp),%rbp
add    %r9,%rbp
mov    %rbp,0x10(%r14,%rax,8)
lea    (%rdi,%r9,1),%rbp
mov    %rbp,0x18(%rcx,%rax,8)
lea    (%r8,%r9,1),%rbp
mov    %rbp,0x18(%r14,%rax,8)
add    $0x4,%rax
add    %rbx,%r9
cmp    %rax,0x28(%rsp)
jne    16d0 <mastrfu+0x520>
mov    0x88(%rsp),%rbx
test   %rbx,%rbx
mov    0x58(%rsp),%rbp
je     1787 <mastrfu+0x5d7>
mov    %rcx,%rdx
lea    (%r14,%rax,8),%rcx
lea    (%rdx,%rax,8),%rdx
mov    0x78(%rsp),%rdi
imul   %rax,%rdi
mov    0x48(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    0x18(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,(%rdx,%rdi,8)
mov    %rax,(%rcx,%rdi,8)
add    $0x1,%rdi
add    %rbp,%rax
add    %rbp,%rsi
cmp    %rdi,%rbx
jne    1770 <mastrfu+0x5c0>
mov    0x30(%rsp),%rax
test   %eax,%eax
mov    0xc(%rsp),%r12d
jle    1810 <mastrfu+0x660>
mov    %r12d,%ecx
shl    $0x3,%rcx
mov    %rcx,0x20(%rsp)
mov    0x38(%rsp),%rdx
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rcx,0x18(%rsp)
cmpq   $0x3,0x80(%rsp)
jae    1be7 <mastrfu+0xa37>
xor    %ebx,%ebx
cmpq   $0x0,0x18(%rsp)
mov    0x20(%rsp),%rbp
je     1810 <mastrfu+0x660>
lea    (%r14,%rbx,8),%rcx
mov    %rcx,0x28(%rsp)
xor    %ebx,%ebx
jmp    17eb <mastrfu+0x63b>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,0x18(%rsp)
je     1810 <mastrfu+0x660>
test   %r12d,%r12d
jle    17e0 <mastrfu+0x630>
mov    0x28(%rsp),%rax
mov    (%rax,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x30(%rsp),%rax
movsd  0x40(%rsp),%xmm3
jmp    17e0 <mastrfu+0x630>
cmpl   $0x0,0x68(%rsp)
je     1911 <mastrfu+0x761>
test   %r12d,%r12d
jle    1b40 <mastrfu+0x990>
mov    %rax,%rcx
add    $0xffffffff,%eax
movslq %eax,%r10
mov    %r12d,%r9d
lea    0x1(%r10),%r8
xor    %esi,%esi
movsd  0x7d2(%rip),%xmm0
jmp    1852 <mastrfu+0x6a2>
add    $0x1,%rsi
cmp    %r9,%rsi
mov    0x30(%rsp),%rcx
je     1b40 <mastrfu+0x990>
test   %ecx,%ecx
jle    1840 <mastrfu+0x690>
mov    0x10(%rsp),%rdi
mov    %r8,%rdx
mov    %r15,%rbx
mov    0x50(%rsp),%r12
jmp    188b <mastrfu+0x6db>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%r12,8),%rax
movsd  %xmm3,(%rax,%rsi,8)
add    $0xfffffffffffffff8,%rbx
add    $0x1,%rdx
add    $0xfffffffffffffff8,%rdi
cmp    $0x1,%r11
jle    1840 <mastrfu+0x690>
mov    %r12,%r11
add    $0xffffffffffffffff,%r12
cmp    %r10,%r11
jg     1879 <mastrfu+0x6c9>
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rax
mov    0x50(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rax,%rsi,8),%xmm1
ucomisd %xmm1,%xmm3
jp     1900 <mastrfu+0x750>
ucomisd %xmm3,%xmm1
je     1870 <mastrfu+0x6c0>
mov    (%rdi,%rbp,8),%rax
addsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mulsd  0x0(%r13,%rsi,8),%xmm1
movsd  -0x8(%rbx,%rbp,8),%xmm2
subsd  (%rbx,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
mov    (%r14,%r12,8),%rcx
addsd  (%rcx,%rsi,8),%xmm2
movsd  %xmm2,(%rcx,%rsi,8)
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    18b0 <mastrfu+0x700>
jmp    1879 <mastrfu+0x6c9>
ucomisd %xmm3,%xmm3
jnp    18c1 <mastrfu+0x711>
ucomisd %xmm1,%xmm1
jnp    18c1 <mastrfu+0x711>
jmp    1870 <mastrfu+0x6c0>
test   %eax,%eax
jle    1b40 <mastrfu+0x990>
mov    %rax,%r9
add    $0xffffffff,%r9d
mov    %r12d,%eax
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
mov    %rcx,0x68(%rsp)
lea    0x10(%r15),%rcx
mov    %rcx,0x58(%rsp)
mov    %r12d,%esi
and    $0xfffffffe,%esi
movsd  0x6c6(%rip),%xmm0
movapd 0x6de(%rip),%xmm1
mov    %r9,0x30(%rsp)
jmp    1971 <mastrfu+0x7c1>
nopl   0x0(%rax)
cmpq   $0x1,0x50(%rsp)
mov    %r10,0x50(%rsp)
jle    1b40 <mastrfu+0x990>
mov    0x50(%rsp),%rcx
lea    -0x1(%rcx),%r10
cmp    %r9,%rcx
mov    0x10(%rsp),%rbp
jg     1960 <mastrfu+0x7b0>
mov    %r10,%rdi
mov    %r10,0x48(%rsp)
jmp    199f <mastrfu+0x7ef>
xchg   %ax,%ax
add    $0x1,%rdi
mov    %rdi,%r11
mov    %r11,%rdi
cmp    %r9,%r11
je     1960 <mastrfu+0x7b0>
test   %r12d,%r12d
jle    1990 <mastrfu+0x7e0>
lea    0x1(%rdi),%r11
mov    0x0(%rbp,%rdi,8),%rcx
mov    0x8(%rbp,%rdi,8),%rdx
mov    (%r14,%r10,8),%r8
cmp    $0x1,%r12d
jne    19d0 <mastrfu+0x820>
xor    %ebx,%ebx
jmp    1b00 <mastrfu+0x950>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r15,%rdi,8),%rbp
mov    %rbp,0x40(%rsp)
lea    (%r8,%rax,8),%r10
lea    (%rcx,%rax,8),%rbp
lea    (%rdx,%rax,8),%r9
mov    0x58(%rsp),%rbx
lea    (%rbx,%rdi,8),%rbx
cmp    %rbp,%r8
setb   0x18(%rsp)
cmp    %r10,%rcx
setb   0x28(%rsp)
cmp    %r9,%r8
setb   %r12b
cmp    %r10,%rdx
setb   0x20(%rsp)
cmp    0x68(%rsp),%r8
setb   %r9b
cmp    %r10,%r13
setb   0x38(%rsp)
cmp    %rbx,%r8
setb   %bpl
cmp    %r10,0x40(%rsp)
setb   %r10b
mov    0x28(%rsp),%bl
test   %bl,0x18(%rsp)
jne    1ad7 <mastrfu+0x927>
and    0x20(%rsp),%r12b
jne    1ad7 <mastrfu+0x927>
mov    %r10d,%r12d
and    0x38(%rsp),%r9b
mov    0x30(%rsp),%r9
mov    0x48(%rsp),%r10
jne    1aef <mastrfu+0x93f>
mov    $0x0,%ebx
and    %r12b,%bpl
mov    0xc(%rsp),%r12d
mov    0x10(%rsp),%rbp
jne    1b00 <mastrfu+0x950>
movsd  (%r15,%rdi,8),%xmm2
subsd  0x8(%r15,%rdi,8),%xmm2
unpcklpd %xmm2,%xmm2
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd (%rcx,%rbx,8),%xmm3
movupd (%rdx,%rbx,8),%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm1,%xmm4
movupd 0x0(%r13,%rbx,8),%xmm3
mulpd  %xmm4,%xmm3
mulpd  %xmm2,%xmm3
movupd (%r8,%rbx,8),%xmm4
addpd  %xmm3,%xmm4
movupd %xmm4,(%r8,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    1a90 <mastrfu+0x8e0>
mov    %rsi,%rbx
cmp    %rax,%rsi
jne    1b00 <mastrfu+0x950>
jmp    1997 <mastrfu+0x7e7>
xor    %ebx,%ebx
mov    0x30(%rsp),%r9
mov    0xc(%rsp),%r12d
mov    0x10(%rsp),%rbp
mov    0x48(%rsp),%r10
jmp    1b00 <mastrfu+0x950>
xor    %ebx,%ebx
mov    0xc(%rsp),%r12d
mov    0x10(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rbx,8),%xmm2
addsd  (%rdx,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x0(%r13,%rbx,8),%xmm2
movsd  (%r15,%rdi,8),%xmm3
subsd  0x8(%r15,%rdi,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%r8,%rbx,8),%xmm3
movsd  %xmm3,(%r8,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1b00 <mastrfu+0x950>
jmp    1997 <mastrfu+0x7e7>
movslq 0x74(%rsp),%r12
lea    0x4f4(%rip),%rbx
lea    0x4f5(%rip),%rbp
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x66,%edx
mov    %r14,%rcx
xor    %eax,%eax
call   1090 <Free@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x67,%edx
mov    0x10(%rsp),%rcx
xor    %eax,%eax
call   1090 <Free@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x68,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1090 <Free@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x69,%edx
mov    %r13,%rcx
xor    %eax,%eax
call   1090 <Free@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x6a,%edx
mov    %r12,%rcx
xor    %eax,%eax
call   1090 <Free@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x6b,%edx
mov    0x60(%rsp),%rcx
xor    %eax,%eax
call   1090 <Free@plt>
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%edx
xor    %ebx,%ebx
mov    %rdx,0x38(%rsp)
mov    0x20(%rsp),%rbp
jmp    1c0d <mastrfu+0xa5d>
nopl   0x0(%rax,%rax,1)
add    $0x4,%rbx
cmp    %rbx,%rdx
je     17c1 <mastrfu+0x611>
test   %r12d,%r12d
jle    1c00 <mastrfu+0xa50>
mov    (%r14,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x8(%r14,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x10(%r14,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x18(%r14,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
mov    0x38(%rsp),%rdx
mov    0x30(%rsp),%rax
movsd  0x40(%rsp),%xmm3
jmp    1c00 <mastrfu+0xa50>
xor    %edx,%edx
test   $0x1,%sil
jne    13d0 <mastrfu+0x220>
jmp    13f8 <mastrfu+0x248>

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

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