#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float sqrt(float);
int poisson(float **p, float **rhs, char **flag, int imax, int jmax, float delx,
            float dely, float eps, int itermax, float omega, float *res,
            int ifull) {
  int i, j, iter;
  float add, beta_2, beta_mod;
  float p0 = 0.0;
  int rb;
  float rdx2 = 1.0 / (delx * delx);
  float 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    $0x60,%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)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
movss  %xmm3,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xea0(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe7d(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x58(%rbp),%xmm1
addss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xe3c(%rip),%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     127d <poisson+0x16d>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     126a <poisson+0x15a>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1257 <poisson+0x147>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    125c <poisson+0x14c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ef <poisson+0xdf>
jmp    126f <poisson+0x15f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11dc <poisson+0xcc>
movss  -0x50(%rbp),%xmm0
cvtsi2ssl 0x18(%rbp),%xmm1
divss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd6a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    12bd <poisson+0x1ad>
movss  0xd60(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    19fc <poisson+0x8ec>
movl   $0x0,-0x54(%rbp)
cmpl   $0x1,-0x54(%rbp)
jg     1748 <poisson+0x638>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1735 <poisson+0x625>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1722 <poisson+0x612>
mov    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    -0x54(%rbp),%edx
je     1323 <poisson+0x213>
jmp    1714 <poisson+0x604>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x1f,%eax
jne    1447 <poisson+0x337>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcb7(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movss  -0x48(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm3
movss  -0x58(%rbp),%xmm5
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  -0x5c(%rbp),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    170f <poisson+0x5ff>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     170a <poisson+0x5fa>
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%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    -0x38(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x3c(%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
cvtsi2ss %eax,%xmm1
movss  -0x58(%rbp),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%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 -0x38(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x3c(%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
cvtsi2ss %eax,%xmm2
mulss  -0x5c(%rbp),%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xab3(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm2
movss  -0x4c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2ss %eax,%xmm3
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2ss %eax,%xmm4
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
movss  -0x58(%rbp),%xmm5
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%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
cvtsi2ss %eax,%xmm4
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm7
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%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
cvtsi2ss %eax,%xmm6
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm6
mulss  %xmm7,%xmm4
addss  %xmm6,%xmm4
mulss  -0x5c(%rbp),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    170f <poisson+0x5ff>
jmp    1714 <poisson+0x604>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12fb <poisson+0x1eb>
jmp    1727 <poisson+0x617>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e8 <poisson+0x1d8>
jmp    173a <poisson+0x62a>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12d7 <poisson+0x1c7>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     19ab <poisson+0x89b>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1998 <poisson+0x888>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1985 <poisson+0x875>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
and    $0x10,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
cvtsi2ss %eax,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x58(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%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
cvtsi2ss %eax,%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm4
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%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
cvtsi2ss %eax,%xmm3
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm3
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
mulss  %xmm4,%xmm1
addss  %xmm3,%xmm1
mulss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mov    0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
jmp    198a <poisson+0x87a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    176d <poisson+0x65d>
jmp    199d <poisson+0x88d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    175a <poisson+0x64a>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtsi2ssl 0x18(%rbp),%xmm1
divss  %xmm1,%xmm0
call   1030 <sqrt@plt>
divss  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    19e9 <poisson+0x8d9>
jmp    19fc <poisson+0x8ec>
jmp    19ee <poisson+0x8de>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12c4 <poisson+0x1b4>
mov    -0x40(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<poisson>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9d,0x4(%rsp)
movss  %xmm2,0x40(%rsp)
movaps %xmm0,%xmm5
mov    %r8,0x8(%rsp)
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%r14
mov    0xb8(%rsp),%r8d
xorps  %xmm4,%xmm4
xorps  %xmm0,%xmm0
mov    %rcx,0x10(%rsp)
test   %ecx,%ecx
jle    1224 <poisson+0x114>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r9d
mov    0x10(%rsp),%rax
lea    0x1(%rax),%edx
lea    -0x1(%r9),%rsi
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xorps  %xmm0,%xmm0
mov    $0x1,%eax
jmp    118d <poisson+0x7d>
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rdx,%rax
je     1224 <poisson+0x114>
cmpl   $0x0,0x8(%rsp)
jle    1180 <poisson+0x70>
mov    (%r12,%rax,8),%rcx
mov    $0x1,%ebp
cmp    $0x2,%r9d
jne    11d0 <poisson+0xc0>
test   $0x1,%sil
je     1180 <poisson+0x70>
testb  $0x10,(%rcx,%rbp,1)
je     1180 <poisson+0x70>
mov    (%r14,%rax,8),%rcx
movss  (%rcx,%rbp,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
jmp    1180 <poisson+0x70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%ebp
jmp    11f2 <poisson+0xe2>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%rbp,1),%rbx
add    $0x2,%rbx
add    $0x2,%rbp
cmp    $0x1,%rbx
je     11a3 <poisson+0x93>
testb  $0x10,(%rcx,%rbp,1)
je     1209 <poisson+0xf9>
mov    (%r14,%rax,8),%rbx
movss  (%rbx,%rbp,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
testb  $0x10,0x1(%rcx,%rbp,1)
je     11e0 <poisson+0xd0>
mov    (%r14,%rax,8),%rbx
movss  0x4(%rbx,%rbp,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
jmp    11e0 <poisson+0xd0>
xorps  %xmm2,%xmm2
cvtsi2ss %r8d,%xmm2
movss  %xmm2,0x3c(%rsp)
divss  %xmm2,%xmm0
ucomiss %xmm4,%xmm0
jb     1241 <poisson+0x131>
sqrtss %xmm0,%xmm0
jmp    1268 <poisson+0x158>
movaps %xmm3,0x50(%rsp)
movss  %xmm1,0x20(%rsp)
movss  %xmm5,0x18(%rsp)
call   1030 <sqrt@plt>
movss  0x18(%rsp),%xmm5
movss  0x20(%rsp),%xmm1
movaps 0x50(%rsp),%xmm3
movss  0xd8f(%rip),%xmm9
xorps  %xmm4,%xmm4
cvtss2sd %xmm0,%xmm4
movsd  0xda0(%rip),%xmm2
ucomisd %xmm4,%xmm2
movaps %xmm9,%xmm8
ja     128e <poisson+0x17e>
movaps %xmm0,%xmm8
cmpl   $0x0,0x4(%rsp)
jle    1745 <poisson+0x635>
mulss  %xmm5,%xmm5
mulss  %xmm1,%xmm1
movaps %xmm9,%xmm7
divss  %xmm5,%xmm7
divss  %xmm1,%xmm9
movaps %xmm7,%xmm0
addss  %xmm9,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
xorps  0xd4c(%rip),%xmm3
cvtss2sd %xmm0,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
addsd  %xmm0,%xmm0
divsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm10
movsd  0xd43(%rip),%xmm11
subsd  %xmm1,%xmm11
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r11d
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
lea    -0x1(%r11),%r15
xor    %eax,%eax
xorps  %xmm12,%xmm12
movaps %xmm3,0x50(%rsp)
movss  %xmm9,0x38(%rsp)
movss  %xmm8,0x34(%rsp)
movss  %xmm7,0x30(%rsp)
movss  %xmm10,0x2c(%rsp)
movsd  %xmm11,0x70(%rsp)
mov    %r11,0x68(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    %rax,0x48(%rsp)
mov    $0x1,%al
xor    %r11d,%r11d
jmp    1366 <poisson+0x256>
nopl   0x0(%rax)
mov    $0x1,%r11d
testb  $0x1,0x44(%rsp)
mov    $0x0,%eax
je     1570 <poisson+0x460>
cmpl   $0x0,0x10(%rsp)
jle    1540 <poisson+0x430>
mov    %eax,0x44(%rsp)
mov    $0x1,%edx
jmp    138f <poisson+0x27f>
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
mov    %rax,%rdx
cmp    0x18(%rsp),%rax
je     1350 <poisson+0x240>
cmpl   $0x0,0x8(%rsp)
jle    1520 <poisson+0x410>
lea    0x1(%rdx),%rax
mov    %rax,0x20(%rsp)
mov    %eax,%r10d
lea    0x1(%rdx),%eax
xor    %esi,%esi
jmp    1423 <poisson+0x313>
nopl   (%rax)
mov    -0x8(%r14,%rdx,8),%rcx
mov    (%r14,%rdx,8),%rbp
mov    (%r14,%r10,8),%rdi
movss  0x4(%rdi,%rsi,4),%xmm0
addss  0x4(%rcx,%rsi,4),%xmm0
movss  0x8(%rbp,%rsi,4),%xmm1
addss  0x0(%rbp,%rsi,4),%xmm1
mulss  %xmm9,%xmm1
mulss  %xmm7,%xmm0
addss  %xmm1,%xmm0
mov    0x0(%r13,%rdx,8),%rcx
subss  0x4(%rcx,%rsi,4),%xmm0
movaps %xmm10,%xmm1
mulss  %xmm0,%xmm1
movss  0x4(%rbp,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm11,%xmm0
cvtss2sd %xmm1,%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rbp,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r15
je     1380 <poisson+0x270>
lea    (%rax,%rsi,1),%ecx
and    $0x1,%ecx
cmp    %r11d,%ecx
jne    1416 <poisson+0x306>
mov    (%r12,%rdx,8),%rbp
movzbl 0x1(%rbp,%rsi,1),%ecx
cmp    $0x1f,%cl
je     13b0 <poisson+0x2a0>
test   $0x10,%cl
je     1416 <poisson+0x306>
mov    (%r12,%r10,8),%rcx
movzbl 0x1(%rcx,%rsi,1),%ebx
shr    $0x4,%bl
and    $0x1,%bl
mov    -0x8(%r12,%rdx,8),%rcx
movzbl 0x1(%rcx,%rsi,1),%edi
shr    $0x4,%dil
and    $0x1,%dil
lea    (%rdi,%rbx,1),%ecx
movzbl %cl,%ecx
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
movzbl 0x0(%rbp,%rsi,1),%ecx
movzbl 0x2(%rbp,%rsi,1),%r8d
shr    $0x4,%r8b
and    $0x1,%r8b
shr    $0x4,%cl
and    $0x1,%cl
lea    (%rcx,%r8,1),%ebp
movzbl %bpl,%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  %xmm9,%xmm0
mulss  %xmm7,%xmm1
addss  %xmm0,%xmm1
movaps %xmm3,%xmm0
divss  %xmm1,%xmm0
mov    %r13,%r9
mov    -0x8(%r14,%rdx,8),%r13
mov    (%r14,%rdx,8),%rbp
movzbl %bl,%ebx
xorps  %xmm1,%xmm1
cvtsi2ss %ebx,%xmm1
mov    (%r14,%r10,8),%rbx
movzbl %dil,%edi
cvtsi2ss %edi,%xmm2
mulss  0x4(%r13,%rsi,4),%xmm2
mov    %r9,%r13
mulss  0x4(%rbx,%rsi,4),%xmm1
movzbl %r8b,%edi
cvtsi2ss %edi,%xmm5
movzbl %cl,%ecx
cvtsi2ss %ecx,%xmm4
mulss  0x0(%rbp,%rsi,4),%xmm4
mulss  0x8(%rbp,%rsi,4),%xmm5
addss  %xmm2,%xmm1
addss  %xmm4,%xmm5
mulss  %xmm9,%xmm5
mulss  %xmm7,%xmm1
addss  %xmm5,%xmm1
mov    (%r9,%rdx,8),%rcx
subss  0x4(%rcx,%rsi,4),%xmm1
jmp    13f1 <poisson+0x2e1>
add    $0x1,%rdx
mov    %rdx,%rax
cmp    0x18(%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    0xb0(%rsp),%r10
jmp    16c4 <poisson+0x5b4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xb0(%rsp),%r10
movl   $0x0,(%r10)
cmpl   $0x0,0x10(%rsp)
jle    16c0 <poisson+0x5b0>
mov    $0x1,%eax
xorpd  %xmm0,%xmm0
mov    0x68(%rsp),%r11
jmp    15b2 <poisson+0x4a2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %rax,%r8
cmp    0x18(%rsp),%r8
je     16c4 <poisson+0x5b4>
cmpl   $0x0,0x8(%rsp)
jle    15a0 <poisson+0x490>
mov    (%r12,%rax,8),%rdx
lea    0x1(%rax),%r8
mov    %r8d,%r9d
mov    $0x1,%edi
jmp    169d <poisson+0x58d>
xchg   %ax,%ax
mov    (%r12,%r9,8),%rbp
movzbl 0x0(%rbp,%rdi,1),%ebp
shr    $0x4,%ebp
and    $0x1,%ebp
xorps  %xmm5,%xmm5
cvtsi2ss %ebp,%xmm5
mov    (%r14,%r9,8),%rbp
movss  0x0(%rbp,%rdi,4),%xmm1
mov    -0x8(%r14,%rax,8),%rbp
mov    (%r14,%rax,8),%rbx
movss  (%rbx,%rdi,4),%xmm2
subss  %xmm2,%xmm1
mov    -0x8(%r12,%rax,8),%rcx
movzbl (%rcx,%rdi,1),%ecx
shr    $0x4,%ecx
and    $0x1,%ecx
xorps  %xmm4,%xmm4
cvtsi2ss %ecx,%xmm4
mulss  %xmm5,%xmm1
movaps %xmm2,%xmm5
subss  0x0(%rbp,%rdi,4),%xmm5
mulss  %xmm4,%xmm5
lea    0x1(%rdi),%rbp
mov    %ebp,%ecx
movzbl (%rdx,%rcx,1),%esi
shr    $0x4,%esi
and    $0x1,%esi
xorps  %xmm4,%xmm4
cvtsi2ss %esi,%xmm4
subss  %xmm5,%xmm1
movss  (%rbx,%rcx,4),%xmm6
movzbl -0x1(%rdx,%rdi,1),%ecx
shr    $0x4,%ecx
and    $0x1,%ecx
xorps  %xmm5,%xmm5
cvtsi2ss %ecx,%xmm5
subss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
subss  -0x4(%rbx,%rdi,4),%xmm2
mulss  %xmm5,%xmm2
subss  %xmm2,%xmm6
mulss  %xmm9,%xmm6
mulss  %xmm7,%xmm1
addss  %xmm6,%xmm1
mov    0x0(%r13,%rax,8),%rcx
subss  (%rcx,%rdi,4),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,(%r10)
mov    %rbp,%rdi
cmp    %r11,%rdi
je     16b0 <poisson+0x5a0>
testb  $0x10,(%rdx,%rdi,1)
jne    15d0 <poisson+0x4c0>
add    $0x1,%rdi
cmp    %r11,%rdi
jne    169d <poisson+0x58d>
mov    %r8,%rax
cmp    0x18(%rsp),%r8
jne    15b2 <poisson+0x4a2>
jmp    16c4 <poisson+0x5b4>
xorpd  %xmm0,%xmm0
divss  0x3c(%rsp),%xmm0
ucomiss %xmm12,%xmm0
jb     16e0 <poisson+0x5d0>
sqrtss %xmm0,%xmm0
jmp    1718 <poisson+0x608>
cs nopw 0x0(%rax,%rax,1)
call   1030 <sqrt@plt>
xorps  %xmm12,%xmm12
movsd  0x70(%rsp),%xmm11
mov    0xb0(%rsp),%r10
movss  0x2c(%rsp),%xmm10
movss  0x30(%rsp),%xmm7
movss  0x34(%rsp),%xmm8
movss  0x38(%rsp),%xmm9
movaps 0x50(%rsp),%xmm3
mov    0x48(%rsp),%rax
divss  %xmm8,%xmm0
movss  %xmm0,(%r10)
movss  0x40(%rsp),%xmm1
ucomiss %xmm0,%xmm1
ja     1747 <poisson+0x637>
add    $0x1,%eax
cmp    0x4(%rsp),%eax
jne    1340 <poisson+0x230>
mov    0x4(%rsp),%eax
jmp    1747 <poisson+0x637>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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