int dgeom_deflate(floyd, bat, raw, eig, matrix, scratch, n, first,
                  last) float (*floyd)[];
float (*bat)[];
float (*raw)[];
float (*matrix)[];
float (*eig)[];
float (*scratch)[];
int n, first, last;
{
  float(*ls)[];
  float(*values)[];
  float(*guess)[];
  float r, x, y, z;
  float xo, yo, zo;
  float x1, y1, z1;
  int iter, i, j, k, l, istep, changed;
  int iout, jout;
  int initial;
  float dstep, upper, middle, lower;
  float randf();
  float current_error;
  guess = (float(*)[])malloc(n * n * sizeof(float));
  values = (float(*)[])malloc(n * sizeof(float));
  ls = (float(*)[])malloc(n * sizeof(float));
  initial = (1 == 1);
  for (i = 0; i < n * n; i++)
    (*guess)[i] = 0.;
  for (i = 0; i < n * n; i++) {
    if ((*raw)[i] < 10.e7)
      (*scratch)[i] = (*floyd)[i];
    else
      (*scratch)[i] = (*floyd)[i] + (*bat)[i];
  }
  r = 0.;
  x = 0.;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      x1 = (*scratch)[i * n + j];
      {
        r += x1;
        x += 1.;
      }
    }
  r /= (x);
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      xo = 0.;
      yo = 0.;
      x = 0.;
      y = 0.;
      for (k = 0; k < n; k++) {
        x1 = (*scratch)[i * n + k];
        y1 = (*scratch)[k * n + j];
        {
          xo += x1;
          x += 1.;
        }
        {
          yo += y1;
          y += 1.;
        }
      }
      if (x > 0.)
        xo /= x;
      if (y > 0.)
        yo /= y;
      (*matrix)[i * n + j] = -0.5 * ((*scratch)[i * n + j] - xo - yo + r);
    }
  simultaneous_iteration(matrix, scratch, values, ls, initial, n, 3, 10000,
                         0.001);
  initial = (1 == 0);
  z = 0.;
  for (l = 0; l < n; l++) {
    x = 0.;
    for (i = 0; i < n; i++)
      x += (*matrix)[l * n + i] * (*matrix)[l * n + i];
    z += x;
  }
  z -= (*values)[0] * (*values)[0];
  z -= (*values)[1] * (*values)[1];
  z -= (*values)[2] * (*values)[2];
  current_error = z;
  for (iter = 0; iter < 100;) {
    for (i = 0; i < n * n; i++)
      (*guess)[i] = 0.;
    x = randf() * n;
    iout = x;
    x = randf() * n;
    jout = x;
    (*guess)[iout * n + jout] = 2. * randf() - 1.;
    (*guess)[jout * n + iout] = (*guess)[iout * n + jout];
    for (i = 0; i < n * n; i++) {
      if ((*raw)[i] < 10.e7)
        (*scratch)[i] = (*floyd)[i];
      else
        (*scratch)[i] = (*floyd)[i] + (*bat)[i] + (*guess)[i];
    }
    r = 0.;
    x = 0.;
    for (i = 0; i < n; i++)
      for (j = 0; j < n; j++) {
        x1 = (*scratch)[i * n + j];
        {
          r += x1;
          x += 1.;
        }
      }
    r /= (x);
    for (i = 0; i < n; i++)
      for (j = 0; j < n; j++) {
        xo = 0.;
        yo = 0.;
        x = 0.;
        y = 0.;
        for (k = 0; k < n; k++) {
          x1 = (*scratch)[i * n + k];
          y1 = (*scratch)[k * n + j];
          {
            xo += x1;
            x += 1.;
          }
          {
            yo += y1;
            y += 1.;
          }
        }
        if (x > 0.)
          xo /= x;
        if (y > 0.)
          yo /= y;
        (*matrix)[i * n + j] = -0.5 * ((*scratch)[i * n + j] - xo - yo + r);
      }
    simultaneous_iteration(matrix, scratch, values, ls, initial, n, 3, 10000,
                           0.001);
    initial = (1 == 0);
    z = 0.;
    for (l = 0; l < n; l++) {
      x = 0.;
      for (i = 0; i < n; i++)
        x += (*matrix)[l * n + i] * (*matrix)[l * n + i];
      z += x;
    }
    z -= (*values)[0] * (*values)[0];
    z -= (*values)[1] * (*values)[1];
    z -= (*values)[2] * (*values)[2];
    if (z < current_error) {
      iter += 1;
      current_error = z;
      for (i = 0; i < n * n; i++)
        (*bat)[i] += (*guess)[i];
    }
  }
  free(ls);
  free(values);
  free(guess);
}


x86 assembly (clang, -O0):
<dgeom_deflate>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    0x10(%rbp),%eax
imul   0x10(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0xa0(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    11e6 <dgeom_deflate+0xa6>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    11b6 <dgeom_deflate+0x76>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    127b <dgeom_deflate+0x13b>
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe08(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1241 <dgeom_deflate+0x101>
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1268 <dgeom_deflate+0x128>
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    126d <dgeom_deflate+0x12d>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    11ed <dgeom_deflate+0xad>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1329 <dgeom_deflate+0x1e9>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1316 <dgeom_deflate+0x1d6>
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd23(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12a8 <dgeom_deflate+0x168>
jmp    131b <dgeom_deflate+0x1db>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1292 <dgeom_deflate+0x152>
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    151c <dgeom_deflate+0x3dc>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1509 <dgeom_deflate+0x3c9>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    144e <dgeom_deflate+0x30e>
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x70(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc18(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbeb(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1392 <dgeom_deflate+0x252>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1477 <dgeom_deflate+0x337>
movss  -0x58(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    14a0 <dgeom_deflate+0x360>
movss  -0x5c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb3c(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1359 <dgeom_deflate+0x219>
jmp    150e <dgeom_deflate+0x3ce>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1343 <dgeom_deflate+0x203>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0xa0(%rbp),%r8d
mov    0x10(%rbp),%r9d
movsd  0xac1(%rip),%xmm0
movl   $0x3,(%rsp)
movl   $0x2710,0x8(%rsp)
mov    $0x1,%al
call   1060 <simultaneous_iteration@plt>
movl   $0x0,-0xa0(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1610 <dgeom_deflate+0x4d0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    15ed <dgeom_deflate+0x4ad>
mov    -0x30(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    158f <dgeom_deflate+0x44f>
movss  -0x58(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1571 <dgeom_deflate+0x431>
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movl   $0x0,-0x7c(%rbp)
cmpl   $0x64,-0x7c(%rbp)
jge    1ced <dgeom_deflate+0xbad>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    16f6 <dgeom_deflate+0x5b6>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    16c6 <dgeom_deflate+0x586>
mov    $0x0,%al
call   1050 <randf@plt>
cvtsi2ssl 0x10(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cvttss2si -0x58(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    $0x0,%al
call   1050 <randf@plt>
cvtsi2ssl 0x10(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
cvttss2si -0x58(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    $0x0,%al
call   1050 <randf@plt>
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
movsd  0x8bb(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x50(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x98(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x9c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    184b <dgeom_deflate+0x70b>
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x845(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1804 <dgeom_deflate+0x6c4>
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1838 <dgeom_deflate+0x6f8>
mov    -0x10(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    183d <dgeom_deflate+0x6fd>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    17b0 <dgeom_deflate+0x670>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18f9 <dgeom_deflate+0x7b9>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18e6 <dgeom_deflate+0x7a6>
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x753(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1878 <dgeom_deflate+0x738>
jmp    18eb <dgeom_deflate+0x7ab>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1862 <dgeom_deflate+0x722>
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1aec <dgeom_deflate+0x9ac>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1ad9 <dgeom_deflate+0x999>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1a1e <dgeom_deflate+0x8de>
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x88(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x70(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x648(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x61b(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1962 <dgeom_deflate+0x822>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a47 <dgeom_deflate+0x907>
movss  -0x58(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a70 <dgeom_deflate+0x930>
movss  -0x5c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x64(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
addss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x56c(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1929 <dgeom_deflate+0x7e9>
jmp    1ade <dgeom_deflate+0x99e>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1913 <dgeom_deflate+0x7d3>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0xa0(%rbp),%r8d
mov    0x10(%rbp),%r9d
movsd  0x4f1(%rip),%xmm0
movl   $0x3,(%rsp)
movl   $0x2710,0x8(%rsp)
mov    $0x1,%al
call   1060 <simultaneous_iteration@plt>
movl   $0x0,-0xa0(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1be0 <dgeom_deflate+0xaa0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1bbd <dgeom_deflate+0xa7d>
mov    -0x30(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1b5f <dgeom_deflate+0xa1f>
movss  -0x58(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1b41 <dgeom_deflate+0xa01>
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x60(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm1
movss  -0xb4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1ce8 <dgeom_deflate+0xba8>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1ce3 <dgeom_deflate+0xba3>
mov    -0x50(%rbp),%rax
movslq -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x80(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1ca4 <dgeom_deflate+0xb64>
jmp    1ce8 <dgeom_deflate+0xba8>
jmp    16b5 <dgeom_deflate+0x575>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dgeom_deflate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9,%r14
mov    %r8,0x70(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdi,0x68(%rsp)
mov    0x110(%rsp),%ebp
mov    %ebp,%ebx
imul   %ebx,%ebx
lea    0x0(,%rbx,4),%rdi
mov    %rdi,0x88(%rsp)
call   1050 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebp,0xc(%rsp)
movslq %ebp,%rax
mov    %rax,0x50(%rsp)
lea    0x0(,%rax,4),%r15
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rbx,0x10(%rsp)
mov    %r14,%rsi
mov    %rax,0x48(%rsp)
test   %ebx,%ebx
mov    %r14,0x38(%rsp)
je     1237 <dgeom_deflate+0xe7>
xor    %ebp,%ebp
mov    0x40(%rsp),%rdi
xor    %esi,%esi
mov    0x88(%rsp),%rdx
call   1040 <memset@plt>
mov    0x10(%rsp),%rbx
cmp    $0x1,%ebx
jne    15cc <dgeom_deflate+0x47c>
mov    0x38(%rsp),%rsi
test   $0x1,%bl
je     1237 <dgeom_deflate+0xe7>
movss  0xded(%rip),%xmm0
mov    0x60(%rsp),%rax
ucomiss (%rax,%rbp,4),%xmm0
mov    0x68(%rsp),%rax
movss  (%rax,%rbp,4),%xmm0
ja     1232 <dgeom_deflate+0xe2>
mov    0x18(%rsp),%rax
addss  (%rax,%rbp,4),%xmm0
movss  %xmm0,(%rsi,%rbp,4)
mov    0xc(%rsp),%r9d
mov    %r9d,%r11d
test   %r9d,%r9d
mov    0x70(%rsp),%rdi
mov    0x50(%rsp),%r10
mov    %r11,0x28(%rsp)
jle    1469 <dgeom_deflate+0x319>
lea    -0x1(%r11),%r12
mov    %r11d,%eax
and    $0x3,%eax
mov    %r11d,%ecx
and    $0xfffffffc,%ecx
lea    0xc(%rsi),%rdx
xorps  %xmm0,%xmm0
xor    %r9d,%r9d
movss  0xd8b(%rip),%xmm1
mov    %rsi,%r8
xorps  %xmm2,%xmm2
jmp    129f <dgeom_deflate+0x14f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r15,%rdx
add    %r15,%r8
cmp    %r11,%r9
je     1305 <dgeom_deflate+0x1b5>
xor    %ebp,%ebp
cmp    $0x3,%r12
jb     12e0 <dgeom_deflate+0x190>
nopw   0x0(%rax,%rax,1)
addss  -0xc(%rdx,%rbp,4),%xmm0
addss  %xmm1,%xmm2
addss  -0x8(%rdx,%rbp,4),%xmm0
addss  %xmm1,%xmm2
addss  -0x4(%rdx,%rbp,4),%xmm0
addss  (%rdx,%rbp,4),%xmm0
addss  %xmm1,%xmm2
addss  %xmm1,%xmm2
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    12b0 <dgeom_deflate+0x160>
test   %rax,%rax
je     1290 <dgeom_deflate+0x140>
lea    (%r8,%rbp,4),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
addss  0x0(%rbp,%rbx,4),%xmm0
addss  %xmm1,%xmm2
add    $0x1,%rbx
cmp    %rbx,%rax
jne    12f0 <dgeom_deflate+0x1a0>
jmp    1290 <dgeom_deflate+0x140>
mov    0xc(%rsp),%r9d
test   %r9d,%r9d
jle    1469 <dgeom_deflate+0x319>
divss  %xmm2,%xmm0
mov    %r11d,%eax
and    $0xfffffffe,%eax
lea    0x4(%rsi),%rcx
lea    0x0(,%r10,8),%rdx
xor    %r8d,%r8d
movss  0xcd0(%rip),%xmm2
movss  0xccb(%rip),%xmm8
mov    0x28(%rsp),%r14
jmp    1362 <dgeom_deflate+0x212>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8
add    %r15,%rcx
cmp    0x28(%rsp),%r8
je     14b2 <dgeom_deflate+0x362>
mov    %r8,%r9
imul   0x50(%rsp),%r9
mov    %rsi,%r10
xor    %r11d,%r11d
jmp    13da <dgeom_deflate+0x28a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm3,%xmm3
cmpltss %xmm6,%xmm3
andps  %xmm3,%xmm6
andnps %xmm2,%xmm3
orps   %xmm6,%xmm3
divss  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cmpltss %xmm7,%xmm3
andps  %xmm3,%xmm7
andnps %xmm2,%xmm3
orps   %xmm7,%xmm3
divss  %xmm3,%xmm5
lea    (%r11,%r9,1),%rbx
movss  (%rsi,%rbx,4),%xmm3
subss  %xmm4,%xmm3
subss  %xmm5,%xmm3
addss  %xmm0,%xmm3
mulss  %xmm8,%xmm3
movss  %xmm3,(%rdi,%rbx,4)
add    $0x1,%r11
add    $0x4,%r10
cmp    %r14,%r11
je     1350 <dgeom_deflate+0x200>
xorps  %xmm6,%xmm6
test   %r12,%r12
je     1430 <dgeom_deflate+0x2e0>
mov    %r10,%rbx
xor    %ebp,%ebp
xorps  %xmm7,%xmm7
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
addss  -0x4(%rcx,%rbp,4),%xmm4
addss  %xmm1,%xmm6
addss  (%rbx),%xmm5
addss  (%rcx,%rbp,4),%xmm4
addss  %xmm1,%xmm7
addss  %xmm1,%xmm6
addss  (%rbx,%r15,1),%xmm5
addss  %xmm1,%xmm7
add    $0x2,%rbp
add    %rdx,%rbx
cmp    %rbp,%rax
jne    13f0 <dgeom_deflate+0x2a0>
test   $0x1,%r14b
je     1380 <dgeom_deflate+0x230>
jmp    1445 <dgeom_deflate+0x2f5>
nopl   (%rax)
xor    %ebp,%ebp
xorps  %xmm7,%xmm7
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
test   $0x1,%r14b
je     1380 <dgeom_deflate+0x230>
lea    (%r9,%rbp,1),%rbx
imul   0x50(%rsp),%rbp
add    %r11,%rbp
addss  (%rsi,%rbx,4),%xmm4
addss  %xmm1,%xmm6
addss  (%rsi,%rbp,4),%xmm5
addss  %xmm1,%xmm7
jmp    1380 <dgeom_deflate+0x230>
movsd  0xb9f(%rip),%xmm0
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rcx
mov    $0x1,%r8d
mov    $0x1,%al
push   $0x2710
push   $0x3
call   1070 <simultaneous_iteration@plt>
mov    0x38(%rsp),%r13
mov    0x20(%rsp),%r10
mov    0x80(%rsp),%r9
mov    0x48(%rsp),%r8
add    $0x10,%rsp
xorps  %xmm4,%xmm4
jmp    164c <dgeom_deflate+0x4fc>
movsd  0xb56(%rip),%xmm0
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rcx
mov    $0x1,%r8d
mov    0xc(%rsp),%ebp
mov    %ebp,%r9d
mov    $0x1,%al
push   $0x2710
push   $0x3
mov    %rdi,%rbx
call   1070 <simultaneous_iteration@plt>
add    $0x10,%rsp
test   %ebp,%ebp
jle    1637 <dgeom_deflate+0x4e7>
mov    0x28(%rsp),%r13
mov    %r13d,%eax
and    $0x3,%eax
mov    %r13d,%ecx
and    $0xfffffffc,%ecx
lea    0xc(%rbx),%rdx
xorps  %xmm4,%xmm4
xor    %esi,%esi
mov    %rbx,%rdi
mov    0x38(%rsp),%r8
mov    %rbx,%r9
mov    0x10(%rsp),%r10
jmp    1537 <dgeom_deflate+0x3e7>
nopw   0x0(%rax,%rax,1)
addss  %xmm0,%xmm4
add    $0x1,%rsi
add    %r15,%rdx
add    %r15,%rdi
cmp    %r13,%rsi
je     164c <dgeom_deflate+0x4fc>
cmp    $0x3,%r12
jae    1550 <dgeom_deflate+0x400>
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
jmp    15a0 <dgeom_deflate+0x450>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0xc(%rdx,%rbp,4),%xmm1
movss  -0x8(%rdx,%rbp,4),%xmm2
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
movss  -0x4(%rdx,%rbp,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movss  (%rdx,%rbp,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    1560 <dgeom_deflate+0x410>
test   %rax,%rax
je     1520 <dgeom_deflate+0x3d0>
lea    (%rdi,%rbp,4),%rbp
xor    %ebx,%ebx
nop
movss  0x0(%rbp,%rbx,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%rax
jne    15b0 <dgeom_deflate+0x460>
jmp    1520 <dgeom_deflate+0x3d0>
mov    %ebx,%eax
and    $0x7ffffffe,%eax
xor    %ebp,%ebp
movss  0xa23(%rip),%xmm0
mov    0x38(%rsp),%rsi
mov    0x60(%rsp),%rcx
mov    0x68(%rsp),%rdi
jmp    1603 <dgeom_deflate+0x4b3>
xchg   %ax,%ax
movss  %xmm1,0x4(%rsi,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%rax
je     1206 <dgeom_deflate+0xb6>
ucomiss (%rcx,%rbp,4),%xmm0
movss  (%rdi,%rbp,4),%xmm1
ja     1618 <dgeom_deflate+0x4c8>
mov    0x18(%rsp),%rdx
addss  (%rdx,%rbp,4),%xmm1
movss  %xmm1,(%rsi,%rbp,4)
ucomiss 0x4(%rcx,%rbp,4),%xmm0
movss  0x4(%rdi,%rbp,4),%xmm1
ja     15f0 <dgeom_deflate+0x4a0>
mov    0x18(%rsp),%rdx
addss  0x4(%rdx,%rbp,4),%xmm1
jmp    15f0 <dgeom_deflate+0x4a0>
xorps  %xmm4,%xmm4
mov    0x38(%rsp),%r8
mov    %rbx,%r9
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%r13
mov    0x20(%rsp),%rax
movss  (%rax),%xmm0
movss  0x4(%rax),%xmm1
mulss  %xmm0,%xmm0
subss  %xmm0,%xmm4
mulss  %xmm1,%xmm1
subss  %xmm1,%xmm4
movss  0x8(%rax),%xmm0
mulss  %xmm0,%xmm0
subss  %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtsi2ssl 0xc(%rsp),%xmm0
movss  %xmm0,0x5c(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0x78(%rsp)
mov    %r10d,%eax
and    $0x7ffffff8,%eax
mov    %rax,0xb0(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0xa8(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r10d,%r11d
and    $0x7ffffffe,%r11d
mov    %r13d,%r14d
and    $0x3,%r14d
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x90(%rsp)
and    $0xfffffffe,%r13d
mov    %rcx,%rax
mov    %rcx,0xa0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x98(%rsp)
lea    0xc(%r8),%rax
mov    %rax,0xd0(%rsp)
lea    0x4(%r8),%rax
mov    %rax,0xc8(%rsp)
mov    0x50(%rsp),%rax
lea    0x0(,%rax,8),%r12
lea    0xc(%r9),%rax
mov    %rax,0xb8(%rsp)
xor    %r9d,%r9d
mov    0x18(%rsp),%rbp
mov    0x40(%rsp),%r8
mov    %r11,0xc0(%rsp)
jmp    174d <dgeom_deflate+0x5fd>
nopl   0x0(%rax,%rax,1)
movaps %xmm0,%xmm4
cmp    $0x64,%r9d
jge    1d86 <dgeom_deflate+0xc36>
mov    %r9d,0x30(%rsp)
movss  %xmm4,0x34(%rsp)
test   %r10,%r10
je     1772 <dgeom_deflate+0x622>
mov    %r8,%rbx
mov    %r8,%rdi
xor    %esi,%esi
mov    0x88(%rsp),%rdx
call   1040 <memset@plt>
xor    %eax,%eax
call   1060 <randf@plt>
mulss  0x5c(%rsp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,0x84(%rsp)
xor    %eax,%eax
call   1060 <randf@plt>
mulss  0x5c(%rsp),%xmm0
cvttss2si %xmm0,%ebx
xor    %eax,%eax
call   1060 <randf@plt>
mov    0x84(%rsp),%ecx
mov    %ecx,%eax
mov    0xc(%rsp),%r9d
imul   %r9d,%eax
add    %ebx,%eax
imul   %r9d,%ebx
add    %ecx,%ebx
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  0x84c(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
cltq
mov    0x40(%rsp),%r11
movss  %xmm0,(%r11,%rax,4)
movslq %ebx,%rax
movss  %xmm0,(%r11,%rax,4)
mov    0x10(%rsp),%r8
test   %r8,%r8
mov    0x38(%rsp),%rsi
mov    0x70(%rsp),%rdi
mov    0x68(%rsp),%rdx
mov    0x50(%rsp),%r10
je     183f <dgeom_deflate+0x6ef>
xor    %eax,%eax
cmp    $0x1,%r8d
jne    1c10 <dgeom_deflate+0xac0>
test   $0x1,%r8b
je     183f <dgeom_deflate+0x6ef>
mov    0x60(%rsp),%rcx
movss  0x7dd(%rip),%xmm0
ucomiss (%rcx,%rax,4),%xmm0
movss  (%rdx,%rax,4),%xmm0
ja     183a <dgeom_deflate+0x6ea>
addss  0x0(%rbp,%rax,4),%xmm0
addss  (%r11,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
test   %r9d,%r9d
mov    0x28(%rsp),%r11
movss  0x7b5(%rip),%xmm6
movss  0x7b0(%rip),%xmm8
movss  0x7a4(%rip),%xmm7
jle    1a50 <dgeom_deflate+0x900>
xorps  %xmm0,%xmm0
mov    %rsi,%r8
mov    0xd0(%rsp),%rcx
xor    %edx,%edx
xorps  %xmm1,%xmm1
mov    0x90(%rsp),%rax
jmp    18a3 <dgeom_deflate+0x753>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    %r15,%rcx
add    %r15,%r8
cmp    %r11,%rdx
je     1920 <dgeom_deflate+0x7d0>
cmpq   $0x3,0x78(%rsp)
jae    18b0 <dgeom_deflate+0x760>
xor    %ebp,%ebp
jmp    18f0 <dgeom_deflate+0x7a0>
nop
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addss  -0xc(%rcx,%rbp,4),%xmm0
addss  %xmm7,%xmm1
addss  -0x8(%rcx,%rbp,4),%xmm0
addss  %xmm7,%xmm1
addss  -0x4(%rcx,%rbp,4),%xmm0
addss  (%rcx,%rbp,4),%xmm0
addss  %xmm7,%xmm1
addss  %xmm7,%xmm1
add    $0x4,%rbp
cmp    %rbp,%rax
jne    18c0 <dgeom_deflate+0x770>
test   %r14,%r14
je     1890 <dgeom_deflate+0x740>
lea    (%r8,%rbp,4),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
addss  0x0(%rbp,%rbx,4),%xmm0
addss  %xmm7,%xmm1
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1900 <dgeom_deflate+0x7b0>
jmp    1890 <dgeom_deflate+0x740>
nopl   0x0(%rax,%rax,1)
test   %r9d,%r9d
jle    1a50 <dgeom_deflate+0x900>
divss  %xmm1,%xmm0
mov    0xc8(%rsp),%rax
xor    %r8d,%r8d
jmp    1950 <dgeom_deflate+0x800>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
add    %r15,%rax
cmp    %r11,%r8
je     1af0 <dgeom_deflate+0x9a0>
mov    %r8,%r9
imul   %r10,%r9
mov    %rsi,%rbp
xor    %edx,%edx
jmp    19b6 <dgeom_deflate+0x866>
xchg   %ax,%ax
xorps  %xmm5,%xmm5
cmpltss %xmm3,%xmm5
andps  %xmm5,%xmm3
andnps %xmm6,%xmm5
orps   %xmm3,%xmm5
divss  %xmm5,%xmm1
xorps  %xmm3,%xmm3
cmpltss %xmm4,%xmm3
andps  %xmm3,%xmm4
andnps %xmm6,%xmm3
orps   %xmm4,%xmm3
divss  %xmm3,%xmm2
lea    (%rdx,%r9,1),%rcx
movss  (%rsi,%rcx,4),%xmm3
subss  %xmm1,%xmm3
subss  %xmm2,%xmm3
addss  %xmm0,%xmm3
mulss  %xmm8,%xmm3
movss  %xmm3,(%rdi,%rcx,4)
add    $0x1,%rdx
add    $0x4,%rbp
cmp    %r11,%rdx
je     1940 <dgeom_deflate+0x7f0>
cmpq   $0x0,0x78(%rsp)
je     1a10 <dgeom_deflate+0x8c0>
xorps  %xmm3,%xmm3
mov    %rbp,%rbx
xor    %ecx,%ecx
xorps  %xmm4,%xmm4
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
nop
addss  -0x4(%rax,%rcx,4),%xmm1
addss  %xmm7,%xmm3
addss  (%rbx),%xmm2
addss  (%rax,%rcx,4),%xmm1
addss  %xmm7,%xmm4
addss  %xmm7,%xmm3
addss  (%rbx,%r15,1),%xmm2
addss  %xmm7,%xmm4
add    $0x2,%rcx
add    %r12,%rbx
cmp    %rcx,%r13
jne    19d0 <dgeom_deflate+0x880>
test   $0x1,%r11b
je     1960 <dgeom_deflate+0x810>
jmp    1a28 <dgeom_deflate+0x8d8>
nopl   (%rax)
xorps  %xmm3,%xmm3
xor    %ecx,%ecx
xorps  %xmm4,%xmm4
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
test   $0x1,%r11b
je     1960 <dgeom_deflate+0x810>
lea    (%rcx,%r9,1),%rbx
imul   %r10,%rcx
add    %rdx,%rcx
addss  (%rsi,%rbx,4),%xmm1
addss  %xmm7,%xmm3
addss  (%rsi,%rcx,4),%xmm2
addss  %xmm7,%xmm4
jmp    1960 <dgeom_deflate+0x810>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rcx
xor    %r8d,%r8d
movsd  0x5ab(%rip),%xmm0
mov    $0x1,%al
push   $0x2710
push   $0x3
call   1070 <simultaneous_iteration@plt>
mov    0x20(%rsp),%r10
mov    0x50(%rsp),%r8
add    $0x10,%rsp
xorps  %xmm0,%xmm0
mov    0x18(%rsp),%rbp
movss  0x34(%rsp),%xmm4
mov    0x30(%rsp),%r9d
mov    0x20(%rsp),%rax
movss  (%rax),%xmm1
movss  0x4(%rax),%xmm2
mulss  %xmm1,%xmm1
subss  %xmm1,%xmm0
mulss  %xmm2,%xmm2
subss  %xmm2,%xmm0
movss  0x8(%rax),%xmm1
mulss  %xmm1,%xmm1
subss  %xmm1,%xmm0
ucomiss %xmm0,%xmm4
jbe    1743 <dgeom_deflate+0x5f3>
add    $0x1,%r9d
test   %r10,%r10
je     1740 <dgeom_deflate+0x5f0>
cmp    $0x8,%r10d
jae    1c7b <dgeom_deflate+0xb2b>
xor    %eax,%eax
jmp    1d40 <dgeom_deflate+0xbf0>
cs nopw 0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rcx
xor    %r8d,%r8d
mov    0xc(%rsp),%ebp
mov    %ebp,%r9d
movsd  0x504(%rip),%xmm0
mov    $0x1,%al
push   $0x2710
push   $0x3
mov    %rdi,%rbx
call   1070 <simultaneous_iteration@plt>
add    $0x10,%rsp
xorps  %xmm0,%xmm0
test   %ebp,%ebp
jle    1d60 <dgeom_deflate+0xc10>
mov    %rbx,%rax
mov    0xb8(%rsp),%rcx
xor    %edx,%edx
mov    0x18(%rsp),%rbp
mov    0x40(%rsp),%r8
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%rbx
movss  0x34(%rsp),%xmm4
mov    0x30(%rsp),%r9d
jmp    1b77 <dgeom_deflate+0xa27>
nopw   0x0(%rax,%rax,1)
addss  %xmm1,%xmm0
add    $0x1,%rdx
add    %r15,%rcx
add    %r15,%rax
cmp    %rbx,%rdx
je     1a94 <dgeom_deflate+0x944>
cmpq   $0x3,0x78(%rsp)
jae    1b90 <dgeom_deflate+0xa40>
xor    %esi,%esi
xorps  %xmm1,%xmm1
jmp    1be0 <dgeom_deflate+0xa90>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
xor    %esi,%esi
mov    0x90(%rsp),%rdi
nopl   (%rax)
movss  -0xc(%rcx,%rsi,4),%xmm2
movss  -0x8(%rcx,%rsi,4),%xmm3
mulss  %xmm2,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm3,%xmm3
addss  %xmm2,%xmm3
movss  -0x4(%rcx,%rsi,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm3,%xmm2
movss  (%rcx,%rsi,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1ba0 <dgeom_deflate+0xa50>
test   $0x3,%bl
je     1b60 <dgeom_deflate+0xa10>
lea    (%rax,%rsi,4),%rsi
xor    %edi,%edi
nop
movss  (%rsi,%rdi,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rdi
cmp    %rdi,%r14
jne    1bf0 <dgeom_deflate+0xaa0>
jmp    1b60 <dgeom_deflate+0xa10>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rcx
mov    0xc0(%rsp),%rbx
movss  0x3db(%rip),%xmm1
jmp    1c43 <dgeom_deflate+0xaf3>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,0x4(%rsi,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbx
je     1810 <dgeom_deflate+0x6c0>
ucomiss (%rcx,%rax,4),%xmm1
movss  (%rdx,%rax,4),%xmm0
ja     1c5a <dgeom_deflate+0xb0a>
addss  0x0(%rbp,%rax,4),%xmm0
addss  (%r11,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
ucomiss 0x4(%rcx,%rax,4),%xmm1
movss  0x4(%rdx,%rax,4),%xmm0
ja     1c30 <dgeom_deflate+0xae0>
addss  0x4(%rbp,%rax,4),%xmm0
addss  0x4(%r11,%rax,4),%xmm0
jmp    1c30 <dgeom_deflate+0xae0>
cmpq   $0x0,0xa8(%rsp)
je     1d74 <dgeom_deflate+0xc24>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r8,%rax,4),%xmm1
movups 0x10(%r8,%rax,4),%xmm2
movups 0x0(%rbp,%rax,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%rbp,%rax,4),%xmm1
addps  %xmm2,%xmm1
movups 0x20(%rbp,%rax,4),%xmm2
movups 0x30(%rbp,%rax,4),%xmm4
movups %xmm3,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
movups 0x20(%r8,%rax,4),%xmm1
addps  %xmm2,%xmm1
movups 0x30(%r8,%rax,4),%xmm2
addps  %xmm4,%xmm2
movups %xmm1,0x20(%rbp,%rax,4)
movups %xmm2,0x30(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1ca0 <dgeom_deflate+0xb50>
testb  $0x1,0xa0(%rsp)
01
je     1d24 <dgeom_deflate+0xbd4>
movups (%r8,%rax,4),%xmm1
movups 0x10(%r8,%rax,4),%xmm2
movups 0x0(%rbp,%rax,4),%xmm3
addps  %xmm1,%xmm3
movups 0x10(%rbp,%rax,4),%xmm1
addps  %xmm2,%xmm1
movups %xmm3,0x0(%rbp,%rax,4)
movups %xmm1,0x10(%rbp,%rax,4)
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
cmp    %r10,%rcx
je     1740 <dgeom_deflate+0x5f0>
nopl   0x0(%rax,%rax,1)
movss  (%r8,%rax,4),%xmm1
addss  0x0(%rbp,%rax,4),%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    1d40 <dgeom_deflate+0xbf0>
jmp    1740 <dgeom_deflate+0x5f0>
mov    0x18(%rsp),%rbp
mov    0x40(%rsp),%r8
mov    0x10(%rsp),%r10
jmp    1a89 <dgeom_deflate+0x939>
xor    %eax,%eax
testb  $0x1,0xa0(%rsp)
01
jne    1cff <dgeom_deflate+0xbaf>
jmp    1d24 <dgeom_deflate+0xbd4>
mov    0x48(%rsp),%rdi
mov    %r8,%rbx
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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