int poisson(double **p, double **rhs, char **flag, int imax, int jmax,
            double delx, double dely, double eps, int itermax, double omega,
            double *res, int ifull) {
  int i, j, iter;
  double add, beta_2, beta_mod;
  double p0 = 0.0;
  int rb;
  double rdx2 = 1.0 / (delx * delx);
  double rdy2 = 1.0 / (dely * dely);
  beta_2 = -omega / (2.0 * (rdx2 + rdy2));
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      if (flag[i][j] & 0x0010) {
        p0 += p[i][j] * p[i][j];
      }
    }
  }
  p0 = sqrt(p0 / ifull);
  if (p0 < 0.0001) {
    p0 = 1.0;
  }
  for (iter = 0; iter < itermax; iter++) {
    for (rb = 0; rb <= 1; rb++) {
      for (i = 1; i <= imax; i++) {
        for (j = 1; j <= jmax; j++) {
          if ((i + j) % 2 != rb) {
            continue;
          }
          if (flag[i][j] == (0x0010 | (0x0001 | 0x0002 | 0x0008 | 0x0004))) {
            p[i][j] = (1. - omega) * p[i][j] -
                      beta_2 * ((p[i + 1][j] + p[i - 1][j]) * rdx2 +
                                (p[i][j + 1] + p[i][j - 1]) * rdy2 - rhs[i][j]);
          } else if (flag[i][j] & 0x0010) {
            beta_mod = -omega / ((((flag[i + 1][j] & 0x0010) ? 1 : 0) +
                                  ((flag[i - 1][j] & 0x0010) ? 1 : 0)) *
                                     rdx2 +
                                 (((flag[i][j + 1] & 0x0010) ? 1 : 0) +
                                  ((flag[i][j - 1] & 0x0010) ? 1 : 0)) *
                                     rdy2);
            p[i][j] = (1. - omega) * p[i][j] -
                      beta_mod *
                          ((((flag[i + 1][j] & 0x0010) ? 1 : 0) * p[i + 1][j] +
                            ((flag[i - 1][j] & 0x0010) ? 1 : 0) * p[i - 1][j]) *
                               rdx2 +
                           (((flag[i][j + 1] & 0x0010) ? 1 : 0) * p[i][j + 1] +
                            ((flag[i][j - 1] & 0x0010) ? 1 : 0) * p[i][j - 1]) *
                               rdy2 -
                           rhs[i][j]);
          }
        }
      }
    }
    *res = 0.0;
    for (i = 1; i <= imax; i++) {
      for (j = 1; j <= jmax; j++) {
        if (flag[i][j] & 0x0010) {
          add =
              (((flag[i + 1][j] & 0x0010) ? 1 : 0) * (p[i + 1][j] - p[i][j]) -
               ((flag[i - 1][j] & 0x0010) ? 1 : 0) * (p[i][j] - p[i - 1][j])) *
                  rdx2 +
              (((flag[i][j + 1] & 0x0010) ? 1 : 0) * (p[i][j + 1] - p[i][j]) -
               ((flag[i][j - 1] & 0x0010) ? 1 : 0) * (p[i][j] - p[i][j - 1])) *
                  rdy2 -
              rhs[i][j];
          *res += add * add;
        }
      }
    }
    *res = sqrt((*res) / ifull) / p0;
    if (*res < eps)
      break;
  }
  return iter;
}


x86 assembly (clang, -O0):
<poisson>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  %xmm2,-0x38(%rbp)
mov    %r9d,-0x3c(%rbp)
movsd  %xmm3,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x28(%rbp),%xmm1
mulsd  -0x28(%rbp),%xmm1
movsd  0xea1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
movsd  0xe83(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x88(%rbp),%xmm2
ff
addsd  -0x90(%rbp),%xmm2
ff
movsd  0xe3b(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     127a <poisson+0x16a>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1267 <poisson+0x157>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1254 <poisson+0x144>
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1259 <poisson+0x149>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11ec <poisson+0xdc>
jmp    126c <poisson+0x15c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11d9 <poisson+0xc9>
movsd  -0x78(%rbp),%xmm0
cvtsi2sdl 0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  0xd76(%rip),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    12b2 <poisson+0x1a2>
movsd  0xd5b(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1a00 <poisson+0x8f0>
movl   $0x0,-0x7c(%rbp)
cmpl   $0x1,-0x7c(%rbp)
jg     1731 <poisson+0x621>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     171e <poisson+0x60e>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     170b <poisson+0x5fb>
mov    -0x4c(%rbp),%eax
add    -0x50(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    -0x7c(%rbp),%edx
je     1318 <poisson+0x208>
jmp    16fd <poisson+0x5ed>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x1f,%eax
jne    142e <poisson+0x31e>
movsd  0xccb(%rip),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
movsd  -0x88(%rbp),%xmm5
ff
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm4
mulsd  -0x90(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16f8 <poisson+0x5e8>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     16f3 <poisson+0x5e3>
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    -0x18(%rbp),%rcx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x50(%rbp),%rdx
movsbl (%rcx,%rdx,1),%esi
and    $0x10,%esi
xor    %ecx,%ecx
mov    $0x1,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm1
movsd  -0x88(%rbp),%xmm3
ff
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    -0x18(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x50(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%esi
and    $0x10,%esi
xor    %ecx,%ecx
mov    $0x1,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
add    %ecx,%eax
cvtsi2sd %eax,%xmm2
mulsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xac5(%rip),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm3
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm4
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
movsd  -0x88(%rbp),%xmm5
ff
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm4
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm7
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm6
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm6
mulsd  %xmm7,%xmm4
addsd  %xmm6,%xmm4
mulsd  -0x90(%rbp),%xmm4
ff
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16f8 <poisson+0x5e8>
jmp    16fd <poisson+0x5ed>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12f0 <poisson+0x1e0>
jmp    1710 <poisson+0x600>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12dd <poisson+0x1cd>
jmp    1723 <poisson+0x613>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    12cc <poisson+0x1bc>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     19ae <poisson+0x89e>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     199b <poisson+0x88b>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1988 <poisson+0x878>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm4
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2sd %eax,%xmm3
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm5
mulsd  %xmm5,%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
jmp    198d <poisson+0x87d>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1756 <poisson+0x646>
jmp    19a0 <poisson+0x890>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1743 <poisson+0x633>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
cvtsi2sdl 0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
divsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    19ed <poisson+0x8dd>
jmp    1a00 <poisson+0x8f0>
jmp    19f2 <poisson+0x8e2>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12b9 <poisson+0x1a9>
mov    -0x54(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<poisson>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9d,0xc(%rsp)
movsd  %xmm2,0x78(%rsp)
movapd %xmm0,%xmm5
mov    %r8,0x10(%rsp)
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%r14
mov    0xd8(%rsp),%r8d
xorpd  %xmm4,%xmm4
xorpd  %xmm0,%xmm0
mov    %rcx,0x18(%rsp)
test   %ecx,%ecx
jle    1235 <poisson+0x125>
mov    0x10(%rsp),%rax
lea    0x1(%rax),%r9d
mov    0x18(%rsp),%rax
lea    0x1(%rax),%edx
lea    -0x1(%r9),%r10
mov    %r10,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
jmp    119d <poisson+0x8d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
cmp    %rdx,%rax
je     1235 <poisson+0x125>
cmpl   $0x0,0x10(%rsp)
jle    1190 <poisson+0x80>
mov    (%r12,%rax,8),%rsi
mov    $0x1,%ecx
cmp    $0x2,%r9d
jne    11e0 <poisson+0xd0>
test   $0x1,%r10b
je     1190 <poisson+0x80>
testb  $0x10,(%rsi,%rcx,1)
je     1190 <poisson+0x80>
mov    (%r14,%rax,8),%rsi
movsd  (%rsi,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
jmp    1190 <poisson+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%ecx
jmp    1202 <poisson+0xf2>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
cmp    $0x1,%rbp
je     11b3 <poisson+0xa3>
testb  $0x10,(%rsi,%rcx,1)
je     121a <poisson+0x10a>
mov    (%r14,%rax,8),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
testb  $0x10,0x1(%rsi,%rcx,1)
je     11f0 <poisson+0xe0>
mov    (%r14,%rax,8),%rbp
movsd  0x8(%rbp,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
jmp    11f0 <poisson+0xe0>
xorps  %xmm2,%xmm2
cvtsi2sd %r8d,%xmm2
movsd  %xmm2,0x70(%rsp)
divsd  %xmm2,%xmm0
ucomisd %xmm4,%xmm0
movsd  %xmm3,0x38(%rsp)
jb     1265 <poisson+0x155>
sqrtsd %xmm0,%xmm0
cmpl   $0x0,0xc(%rsp)
jg     128f <poisson+0x17f>
xor    %eax,%eax
jmp    1768 <poisson+0x658>
movsd  %xmm1,0x28(%rsp)
movsd  %xmm5,0x20(%rsp)
call   1030 <sqrt@plt>
movsd  0x20(%rsp),%xmm5
movsd  0x28(%rsp),%xmm1
movsd  0x38(%rsp),%xmm3
cmpl   $0x0,0xc(%rsp)
jle    125e <poisson+0x14e>
mulsd  %xmm5,%xmm5
movsd  0xd64(%rip),%xmm9
mulsd  %xmm1,%xmm1
movapd %xmm9,%xmm7
divsd  %xmm5,%xmm7
movapd %xmm9,%xmm6
divsd  %xmm1,%xmm6
movapd %xmm7,%xmm1
addsd  %xmm6,%xmm1
movapd %xmm0,%xmm10
cmpltsd 0xd3f(%rip),%xmm10
addsd  %xmm1,%xmm1
movsd  0xd2b(%rip),%xmm2
andpd  %xmm10,%xmm2
andnpd %xmm0,%xmm10
orpd   %xmm2,%xmm10
subsd  %xmm3,%xmm9
movapd %xmm3,%xmm11
divsd  %xmm1,%xmm11
mov    0x10(%rsp),%rax
lea    0x1(%rax),%r11d
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
lea    -0x1(%r11),%r15
xor    %eax,%eax
xorpd  %xmm12,%xmm12
movsd  %xmm9,0x68(%rsp)
movsd  %xmm7,0x60(%rsp)
movsd  %xmm6,0x58(%rsp)
movapd %xmm10,0x80(%rsp)
movsd  %xmm11,0x50(%rsp)
mov    %r11,0x48(%rsp)
nopl   (%rax)
mov    %rax,0x40(%rsp)
mov    $0x1,%al
xor    %r11d,%r11d
jmp    1366 <poisson+0x256>
nopl   0x0(%rax)
mov    $0x1,%r11d
testb  $0x1,0x34(%rsp)
mov    $0x0,%eax
je     1580 <poisson+0x470>
cmpl   $0x0,0x18(%rsp)
jle    1550 <poisson+0x440>
mov    %eax,0x34(%rsp)
mov    $0x1,%edx
jmp    138f <poisson+0x27f>
nopl   0x0(%rax)
mov    0x28(%rsp),%rax
mov    %rax,%rdx
cmp    0x20(%rsp),%rax
je     1350 <poisson+0x240>
cmpl   $0x0,0x10(%rsp)
jle    1530 <poisson+0x420>
lea    0x1(%rdx),%rax
mov    %rax,0x28(%rsp)
mov    %eax,%r10d
lea    0x1(%rdx),%eax
xor    %esi,%esi
jmp    1412 <poisson+0x302>
nopl   (%rax)
mov    -0x8(%r14,%rdx,8),%rcx
mov    (%r14,%r10,8),%rdi
movsd  0x8(%rdi,%rsi,8),%xmm0
addsd  0x8(%rcx,%rsi,8),%xmm0
mov    (%r14,%rdx,8),%rcx
movsd  0x10(%rcx,%rsi,8),%xmm1
addsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
mov    0x0(%r13,%rdx,8),%rdi
subsd  0x8(%rdi,%rsi,8),%xmm0
mulsd  %xmm11,%xmm0
movsd  0x8(%rcx,%rsi,8),%xmm1
mulsd  %xmm9,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rcx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r15
je     1380 <poisson+0x270>
lea    (%rax,%rsi,1),%ecx
and    $0x1,%ecx
cmp    %r11d,%ecx
jne    1405 <poisson+0x2f5>
mov    (%r12,%rdx,8),%rdi
movzbl 0x1(%rdi,%rsi,1),%ecx
cmp    $0x1f,%cl
je     13b0 <poisson+0x2a0>
test   $0x10,%cl
je     1405 <poisson+0x2f5>
mov    (%r12,%r10,8),%rcx
movzbl 0x1(%rcx,%rsi,1),%ebp
shr    $0x4,%bpl
and    $0x1,%bpl
mov    -0x8(%r12,%rdx,8),%rcx
movzbl 0x1(%rcx,%rsi,1),%ebx
shr    $0x4,%bl
and    $0x1,%bl
lea    (%rbx,%rbp,1),%ecx
movzbl %cl,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movzbl (%rdi,%rsi,1),%ecx
movzbl 0x2(%rdi,%rsi,1),%r8d
shr    $0x4,%r8b
and    $0x1,%r8b
shr    $0x4,%cl
and    $0x1,%cl
lea    (%rcx,%r8,1),%edi
movzbl %dil,%edi
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
mulsd  %xmm6,%xmm1
mulsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
mov    %r13,%r9
mov    -0x8(%r14,%rdx,8),%r13
mov    (%r14,%rdx,8),%rdi
movzbl %bpl,%ebp
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mov    (%r14,%r10,8),%rbp
movzbl %bl,%ebx
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
mulsd  0x8(%r13,%rsi,8),%xmm2
mov    %r9,%r13
mulsd  0x8(%rbp,%rsi,8),%xmm1
movzbl %r8b,%ebp
xorps  %xmm5,%xmm5
cvtsi2sd %ebp,%xmm5
movzbl %cl,%ecx
cvtsi2sd %ecx,%xmm4
mulsd  (%rdi,%rsi,8),%xmm4
addsd  %xmm2,%xmm1
mulsd  0x10(%rdi,%rsi,8),%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm6,%xmm5
mulsd  %xmm7,%xmm1
addsd  %xmm5,%xmm1
mov    (%r9,%rdx,8),%rcx
subsd  0x8(%rcx,%rsi,8),%xmm1
movapd %xmm3,%xmm2
divsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movsd  0x8(%rdi,%rsi,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rdi,%rsi,8)
jmp    1405 <poisson+0x2f5>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%rax
cmp    0x20(%rsp),%rax
jne    138f <poisson+0x27f>
jmp    1350 <poisson+0x240>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%r11d
test   $0x1,%al
mov    $0x0,%eax
jne    1366 <poisson+0x256>
xorpd  %xmm0,%xmm0
mov    0xd0(%rsp),%r10
jmp    16e4 <poisson+0x5d4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xd0(%rsp),%r10
movq   $0x0,(%r10)
cmpl   $0x0,0x18(%rsp)
jle    16e0 <poisson+0x5d0>
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
mov    0x48(%rsp),%r11
jmp    15c2 <poisson+0x4b2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %rax,%r8
cmp    0x20(%rsp),%r8
je     16e4 <poisson+0x5d4>
cmpl   $0x0,0x10(%rsp)
jle    15b0 <poisson+0x4a0>
mov    (%r12,%rax,8),%rdx
lea    0x1(%rax),%r8
mov    %r8d,%r9d
mov    $0x1,%edi
jmp    16b0 <poisson+0x5a0>
xchg   %ax,%ax
mov    (%r12,%r9,8),%rbp
movzbl 0x0(%rbp,%rdi,1),%ebp
shr    $0x4,%ebp
and    $0x1,%ebp
xorps  %xmm8,%xmm8
cvtsi2sd %ebp,%xmm8
mov    (%r14,%r9,8),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mov    -0x8(%r14,%rax,8),%rbp
mov    (%r14,%rax,8),%rbx
movsd  (%rbx,%rdi,8),%xmm2
subsd  %xmm2,%xmm1
mov    -0x8(%r12,%rax,8),%rcx
movzbl (%rcx,%rdi,1),%ecx
shr    $0x4,%ecx
and    $0x1,%ecx
xorps  %xmm4,%xmm4
cvtsi2sd %ecx,%xmm4
movapd %xmm2,%xmm5
subsd  0x0(%rbp,%rdi,8),%xmm5
mulsd  %xmm8,%xmm1
mulsd  %xmm4,%xmm5
subsd  %xmm5,%xmm1
lea    0x1(%rdi),%rbp
mov    %ebp,%ecx
movzbl (%rdx,%rcx,1),%esi
shr    $0x4,%esi
and    $0x1,%esi
xorps  %xmm5,%xmm5
cvtsi2sd %esi,%xmm5
movsd  (%rbx,%rcx,8),%xmm4
subsd  %xmm2,%xmm4
mulsd  %xmm5,%xmm4
movzbl -0x1(%rdx,%rdi,1),%ecx
shr    $0x4,%ecx
and    $0x1,%ecx
xorps  %xmm5,%xmm5
cvtsi2sd %ecx,%xmm5
subsd  -0x8(%rbx,%rdi,8),%xmm2
mulsd  %xmm5,%xmm2
subsd  %xmm2,%xmm4
mulsd  %xmm6,%xmm4
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
mov    0x0(%r13,%rax,8),%rcx
subsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10)
mov    %rbp,%rdi
cmp    %r11,%rdi
je     16c3 <poisson+0x5b3>
testb  $0x10,(%rdx,%rdi,1)
jne    15e0 <poisson+0x4d0>
add    $0x1,%rdi
cmp    %r11,%rdi
jne    16b0 <poisson+0x5a0>
mov    %r8,%rax
cmp    0x20(%rsp),%r8
jne    15c2 <poisson+0x4b2>
jmp    16e4 <poisson+0x5d4>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm0,%xmm0
divsd  0x70(%rsp),%xmm0
ucomisd %xmm12,%xmm0
jb     1700 <poisson+0x5f0>
sqrtsd %xmm0,%xmm0
jmp    173c <poisson+0x62c>
nopw   0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
xorpd  %xmm12,%xmm12
movsd  0x50(%rsp),%xmm11
movapd 0x80(%rsp),%xmm10
mov    0xd0(%rsp),%r10
movsd  0x58(%rsp),%xmm6
movsd  0x60(%rsp),%xmm7
movsd  0x68(%rsp),%xmm9
movsd  0x38(%rsp),%xmm3
mov    0x40(%rsp),%rax
divsd  %xmm10,%xmm0
movsd  %xmm0,(%r10)
movsd  0x78(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     1768 <poisson+0x658>
add    $0x1,%eax
cmp    0xc(%rsp),%eax
jne    1340 <poisson+0x230>
mov    0xc(%rsp),%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @poisson(double** nocapture %0, double** nocapture %1, i8** nocapture %2, i32 %3, i32 %4, double %5, double %6, double %7, i32 %8, double %9, double* nocapture %10, i32 %11) {
%13 = fmul double %5, %5
%14 = fdiv double 1.000000e+00, %13
%15 = fmul double %6, %6
%16 = fdiv double 1.000000e+00, %15
%17 = fadd double %14, %16
%18 = fmul double %17, 2.000000e+00
%19 = icmp slt i32 %3, 1
br i1 %19, label %86, label %20
20: ; preds = %12
%21 = icmp slt i32 %4, 1
%22 = add i32 %4, 1
%23 = add nuw i32 %3, 1
%24 = zext i32 %23 to i64
%25 = zext i32 %22 to i64
%26 = add nsw i64 %25, -1
%27 = and i64 %26, 1
%28 = icmp eq i32 %22, 2
%29 = and i64 %26, -2
%30 = icmp eq i64 %27, 0
br label %31
31: ; preds = %20, %82
%32 = phi i64 [ 1, %20 ], [ %84, %82 ]
%33 = phi double [ 0.000000e+00, %20 ], [ %83, %82 ]
br i1 %21, label %82, label %34
34: ; preds = %31
%35 = getelementptr inbounds i8*, i8** %2, i64 %32
%36 = load i8*, i8** %35
%37 = getelementptr inbounds double*, double** %0, i64 %32
br i1 %28, label %68, label %38
38: ; preds = %34, %63
%39 = phi i64 [ %65, %63 ], [ 1, %34 ]
%40 = phi double [ %64, %63 ], [ %33, %34 ]
%41 = phi i64 [ %66, %63 ], [ 0, %34 ]
%42 = getelementptr inbounds i8, i8* %36, i64 %39
%43 = load i8, i8* %42
%44 = and i8 %43, 16
%45 = icmp eq i8 %44, 0
br i1 %45, label %51, label %46
46: ; preds = %38
%47 = load double*, double** %37
%48 = getelementptr inbounds double, double* %47, i64 %39
%49 = load double, double* %48
%50 = tail call double @llvm.fmuladd.f64(double %49, double %49, double %40)
br label %51
51: ; preds = %38, %46
%52 = phi double [ %50, %46 ], [ %40, %38 ]
%53 = add nuw nsw i64 %39, 1
%54 = getelementptr inbounds i8, i8* %36, i64 %53
%55 = load i8, i8* %54
%56 = and i8 %55, 16
%57 = icmp eq i8 %56, 0
br i1 %57, label %63, label %58
58: ; preds = %51
%59 = load double*, double** %37
%60 = getelementptr inbounds double, double* %59, i64 %53
%61 = load double, double* %60
%62 = tail call double @llvm.fmuladd.f64(double %61, double %61, double %52)
br label %63
63: ; preds = %58, %51
%64 = phi double [ %62, %58 ], [ %52, %51 ]
%65 = add nuw nsw i64 %39, 2
%66 = add i64 %41, 2
%67 = icmp eq i64 %66, %29
br i1 %67, label %68, label %38
68: ; preds = %63, %34
%69 = phi double [ undef, %34 ], [ %64, %63 ]
%70 = phi i64 [ 1, %34 ], [ %65, %63 ]
%71 = phi double [ %33, %34 ], [ %64, %63 ]
br i1 %30, label %82, label %72
72: ; preds = %68
%73 = getelementptr inbounds i8, i8* %36, i64 %70
%74 = load i8, i8* %73
%75 = and i8 %74, 16
%76 = icmp eq i8 %75, 0
br i1 %76, label %82, label %77
77: ; preds = %72
%78 = load double*, double** %37
%79 = getelementptr inbounds double, double* %78, i64 %70
%80 = load double, double* %79
%81 = tail call double @llvm.fmuladd.f64(double %80, double %80, double %71)
br label %82
82: ; preds = %68, %77, %72, %31
%83 = phi double [ %33, %31 ], [ %69, %68 ], [ %81, %77 ], [ %71, %72 ]
%84 = add nuw nsw i64 %32, 1
%85 = icmp eq i64 %84, %24
br i1 %85, label %86, label %31
86: ; preds = %82, %12
%87 = phi double [ 0.000000e+00, %12 ], [ %83, %82 ]
%88 = sitofp i32 %11 to double
%89 = fdiv double %87, %88
%90 = tail call double @sqrt(double %89)
%91 = fcmp olt double %90, 1.000000e-04
%92 = select i1 %91, double 1.000000e+00, double %90
%93 = icmp sgt i32 %8, 0
br i1 %93, label %94, label %332
94: ; preds = %86
%95 = icmp slt i32 %4, 1
%96 = fsub double 1.000000e+00, %9
%97 = fdiv double %9, %18
%98 = add i32 %4, 1
%99 = add i32 %3, 1
%100 = zext i32 %99 to i64
%101 = zext i32 %98 to i64
%102 = zext i32 %99 to i64
%103 = zext i32 %98 to i64
br label %104
104: ; preds = %94, %329
%105 = phi i32 [ 0, %94 ], [ %330, %329 ]
br label %106
106: ; preds = %230, %104
%107 = phi i1 [ true, %104 ], [ false, %230 ]
%108 = phi i32 [ 0, %104 ], [ 1, %230 ]
br i1 %19, label %231, label %109
109: ; preds = %106, %226
%110 = phi i64 [ %227, %226 ], [ 1, %106 ]
br i1 %95, label %111, label %113
111: ; preds = %109
%112 = add nuw nsw i64 %110, 1
br label %226
113: ; preds = %109
%114 = getelementptr inbounds i8*, i8** %2, i64 %110
%115 = add nuw nsw i64 %110, 1
%116 = and i64 %115, 4294967295
%117 = getelementptr inbounds i8*, i8** %2, i64 %116
%118 = add nsw i64 %110, -1
%119 = getelementptr inbounds i8*, i8** %2, i64 %118
%120 = getelementptr inbounds double*, double** %0, i64 %110
%121 = getelementptr inbounds double*, double** %0, i64 %116
%122 = getelementptr inbounds double*, double** %0, i64 %118
%123 = getelementptr inbounds double*, double** %1, i64 %110
br label %124
124: ; preds = %113, %223
%125 = phi i64 [ 1, %113 ], [ %224, %223 ]
%126 = add nuw nsw i64 %125, %110
%127 = trunc i64 %126 to i32
%128 = and i32 %127, 1
%129 = icmp eq i32 %128, %108
br i1 %129, label %130, label %223
130: ; preds = %124
%131 = load i8*, i8** %114
%132 = getelementptr inbounds i8, i8* %131, i64 %125
%133 = load i8, i8* %132
%134 = icmp eq i8 %133, 31
br i1 %134, label %135, label %162
135: ; preds = %130
%136 = load double*, double** %120
%137 = getelementptr inbounds double, double* %136, i64 %125
%138 = load double, double* %137
%139 = load double*, double** %121
%140 = getelementptr inbounds double, double* %139, i64 %125
%141 = load double, double* %140
%142 = load double*, double** %122
%143 = getelementptr inbounds double, double* %142, i64 %125
%144 = load double, double* %143
%145 = fadd double %141, %144
%146 = add nuw i64 %125, 1
%147 = and i64 %146, 4294967295
%148 = getelementptr inbounds double, double* %136, i64 %147
%149 = load double, double* %148
%150 = add nsw i64 %125, -1
%151 = getelementptr inbounds double, double* %136, i64 %150
%152 = load double, double* %151
%153 = fadd double %149, %152
%154 = fmul double %16, %153
%155 = tail call double @llvm.fmuladd.f64(double %145, double %14, double %154)
%156 = load double*, double** %123
%157 = getelementptr inbounds double, double* %156, i64 %125
%158 = load double, double* %157
%159 = fsub double %155, %158
%160 = fmul double %97, %159
%161 = tail call double @llvm.fmuladd.f64(double %96, double %138, double %160)
store double %161, double* %137
br label %223
162: ; preds = %130
%163 = and i8 %133, 16
%164 = icmp eq i8 %163, 0
br i1 %164, label %223, label %165
165: ; preds = %162
%166 = load i8*, i8** %117
%167 = getelementptr inbounds i8, i8* %166, i64 %125
%168 = load i8, i8* %167
%169 = lshr i8 %168, 4
%170 = and i8 %169, 1
%171 = load i8*, i8** %119
%172 = getelementptr inbounds i8, i8* %171, i64 %125
%173 = load i8, i8* %172
%174 = lshr i8 %173, 4
%175 = and i8 %174, 1
%176 = add nuw nsw i8 %175, %170
%177 = uitofp i8 %176 to double
%178 = add nuw i64 %125, 1
%179 = and i64 %178, 4294967295
%180 = getelementptr inbounds i8, i8* %131, i64 %179
%181 = load i8, i8* %180
%182 = lshr i8 %181, 4
%183 = and i8 %182, 1
%184 = add nsw i64 %125, -1
%185 = getelementptr inbounds i8, i8* %131, i64 %184
%186 = load i8, i8* %185
%187 = lshr i8 %186, 4
%188 = and i8 %187, 1
%189 = add nuw nsw i8 %188, %183
%190 = uitofp i8 %189 to double
%191 = fmul double %16, %190
%192 = tail call double @llvm.fmuladd.f64(double %177, double %14, double %191)
%193 = load double*, double** %120
%194 = getelementptr inbounds double, double* %193, i64 %125
%195 = load double, double* %194
%196 = uitofp i8 %170 to double
%197 = load double*, double** %121
%198 = getelementptr inbounds double, double* %197, i64 %125
%199 = load double, double* %198
%200 = uitofp i8 %175 to double
%201 = load double*, double** %122
%202 = getelementptr inbounds double, double* %201, i64 %125
%203 = load double, double* %202
%204 = fmul double %203, %200
%205 = tail call double @llvm.fmuladd.f64(double %196, double %199, double %204)
%206 = uitofp i8 %183 to double
%207 = getelementptr inbounds double, double* %193, i64 %179
%208 = load double, double* %207
%209 = uitofp i8 %188 to double
%210 = getelementptr inbounds double, double* %193, i64 %184
%211 = load double, double* %210
%212 = fmul double %211, %209
%213 = tail call double @llvm.fmuladd.f64(double %206, double %208, double %212)
%214 = fmul double %16, %213
%215 = tail call double @llvm.fmuladd.f64(double %205, double %14, double %214)
%216 = load double*, double** %123
%217 = getelementptr inbounds double, double* %216, i64 %125
%218 = load double, double* %217
%219 = fsub double %215, %218
%220 = fdiv double %9, %192
%221 = fmul double %220, %219
%222 = tail call double @llvm.fmuladd.f64(double %96, double %195, double %221)
store double %222, double* %194
br label %223
223: ; preds = %135, %165, %162, %124
%224 = add nuw nsw i64 %125, 1
%225 = icmp eq i64 %224, %101
br i1 %225, label %226, label %124
226: ; preds = %223, %111
%227 = phi i64 [ %112, %111 ], [ %115, %223 ]
%228 = icmp eq i64 %227, %100
br i1 %228, label %229, label %109
229: ; preds = %226
br i1 %107, label %230, label %232
230: ; preds = %229, %231
br label %106
231: ; preds = %106
br i1 %107, label %230, label %323
232: ; preds = %229
store double 0.000000e+00, double* %10
br i1 %19, label %323, label %233
233: ; preds = %232, %319
%234 = phi double [ %321, %319 ], [ 0.000000e+00, %232 ]
%235 = phi i64 [ %320, %319 ], [ 1, %232 ]
br i1 %95, label %236, label %238
236: ; preds = %233
%237 = add nuw nsw i64 %235, 1
br label %319
238: ; preds = %233
%239 = getelementptr inbounds i8*, i8** %2, i64 %235
%240 = load i8*, i8** %239
%241 = add nuw nsw i64 %235, 1
%242 = and i64 %241, 4294967295
%243 = getelementptr inbounds i8*, i8** %2, i64 %242
%244 = getelementptr inbounds double*, double** %0, i64 %242
%245 = getelementptr inbounds double*, double** %0, i64 %235
%246 = add nsw i64 %235, -1
%247 = getelementptr inbounds i8*, i8** %2, i64 %246
%248 = getelementptr inbounds double*, double** %0, i64 %246
%249 = getelementptr inbounds double*, double** %1, i64 %235
br label %250
250: ; preds = %238, %315
%251 = phi double [ %234, %238 ], [ %317, %315 ]
%252 = phi i64 [ 1, %238 ], [ %316, %315 ]
%253 = getelementptr inbounds i8, i8* %240, i64 %252
%254 = load i8, i8* %253
%255 = and i8 %254, 16
%256 = icmp eq i8 %255, 0
br i1 %256, label %257, label %259
257: ; preds = %250
%258 = add nuw nsw i64 %252, 1
br label %315
259: ; preds = %250
%260 = load i8*, i8** %243
%261 = getelementptr inbounds i8, i8* %260, i64 %252
%262 = load i8, i8* %261
%263 = lshr i8 %262, 4
%264 = and i8 %263, 1
%265 = uitofp i8 %264 to double
%266 = load double*, double** %244
%267 = getelementptr inbounds double, double* %266, i64 %252
%268 = load double, double* %267
%269 = load double*, double** %245
%270 = getelementptr inbounds double, double* %269, i64 %252
%271 = load double, double* %270
%272 = fsub double %268, %271
%273 = load i8*, i8** %247
%274 = getelementptr inbounds i8, i8* %273, i64 %252
%275 = load i8, i8* %274
%276 = lshr i8 %275, 4
%277 = and i8 %276, 1
%278 = uitofp i8 %277 to double
%279 = load double*, double** %248
%280 = getelementptr inbounds double, double* %279, i64 %252
%281 = load double, double* %280
%282 = fsub double %271, %281
%283 = fneg double %282
%284 = fmul double %283, %278
%285 = tail call double @llvm.fmuladd.f64(double %265, double %272, double %284)
%286 = add nuw nsw i64 %252, 1
%287 = and i64 %286, 4294967295
%288 = getelementptr inbounds i8, i8* %240, i64 %287
%289 = load i8, i8* %288
%290 = lshr i8 %289, 4
%291 = and i8 %290, 1
%292 = uitofp i8 %291 to double
%293 = getelementptr inbounds double, double* %269, i64 %287
%294 = load double, double* %293
%295 = fsub double %294, %271
%296 = add nsw i64 %252, -1
%297 = getelementptr inbounds i8, i8* %240, i64 %296
%298 = load i8, i8* %297
%299 = lshr i8 %298, 4
%300 = and i8 %299, 1
%301 = uitofp i8 %300 to double
%302 = getelementptr inbounds double, double* %269, i64 %296
%303 = load double, double* %302
%304 = fsub double %271, %303
%305 = fneg double %304
%306 = fmul double %305, %301
%307 = tail call double @llvm.fmuladd.f64(double %292, double %295, double %306)
%308 = fmul double %16, %307
%309 = tail call double @llvm.fmuladd.f64(double %285, double %14, double %308)
%310 = load double*, double** %249
%311 = getelementptr inbounds double, double* %310, i64 %252
%312 = load double, double* %311
%313 = fsub double %309, %312
%314 = tail call double @llvm.fmuladd.f64(double %313, double %313, double %251)
store double %314, double* %10
br label %315
315: ; preds = %257, %259
%316 = phi i64 [ %258, %257 ], [ %286, %259 ]
%317 = phi double [ %251, %257 ], [ %314, %259 ]
%318 = icmp eq i64 %316, %103
br i1 %318, label %319, label %250
319: ; preds = %315, %236
%320 = phi i64 [ %237, %236 ], [ %241, %315 ]
%321 = phi double [ %234, %236 ], [ %317, %315 ]
%322 = icmp eq i64 %320, %102
br i1 %322, label %323, label %233
323: ; preds = %231, %319, %232
%324 = phi double [ 0.000000e+00, %232 ], [ %321, %319 ], [ 0.000000e+00, %231 ]
%325 = fdiv double %324, %88
%326 = tail call double @sqrt(double %325)
%327 = fdiv double %326, %92
store double %327, double* %10
%328 = fcmp olt double %327, %7
br i1 %328, label %332, label %329
329: ; preds = %323
%330 = add nuw nsw i32 %105, 1
%331 = icmp eq i32 %330, %8
br i1 %331, label %332, label %104
332: ; preds = %329, %323, %86
%333 = phi i32 [ 0, %86 ], [ %105, %323 ], [ %8, %329 ]
ret i32 %333
}