#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 */
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
float sqrt(float);
int reject_cr_psf(float *image, float *image_ivar, int xnpix, int ynpix,
                  float nsig, float *psfvals, float cfudge, float c2fudge,
                  int *rejected, int *ignoremask) {
  float *sigmaback, *back, imcurr, ival, lval, invsigma, goodback[3][3];
  int i, j, ip, jp;
  sigmaback = (float *)malloc(4 * sizeof(float));
  back = (float *)malloc(4 * sizeof(float));
  for (j = 1; j < ynpix - 1; j++) {
    for (i = 1; i < xnpix - 1; i++) {
      rejected[j * xnpix + i] = 0;
      if (image_ivar[j * xnpix + i] > 0. && ignoremask[j * xnpix + i] == 0) {
        invsigma = sqrt(image_ivar[j * xnpix + i]);
        imcurr = image[j * xnpix + i];
        ival = invsigma * imcurr;
        for (ip = -1; ip <= 1; ip++)
          for (jp = -1; jp <= 1; jp++)
            goodback[jp + 1][ip + 1] =
                (float)(image_ivar[(j + jp) * xnpix + (i + ip)] > 0.);
        if ((goodback[1][0] + goodback[1][2]) > 0) {
          back[0] = (image[j * xnpix + (i - 1)] * goodback[1][0] +
                     image[j * xnpix + (i + 1)] * goodback[1][2]) /
                    (goodback[1][0] + goodback[1][2]);
          if (ival < back[0] * invsigma + nsig)
            continue;
        }
        if ((goodback[0][1] + goodback[2][1]) > 0) {
          back[1] = (image[(j - 1) * xnpix + i] * goodback[0][1] +
                     image[(j + 1) * xnpix + i] * goodback[2][1]) /
                    (goodback[0][1] + goodback[2][1]);
          if (ival < back[1] * invsigma + nsig)
            continue;
        }
        if ((goodback[0][0] + goodback[2][2]) > 0) {
          back[2] = (image[(j - 1) * xnpix + (i - 1)] * goodback[0][0] +
                     image[(j + 1) * xnpix + (i + 1)] * goodback[2][2]) /
                    (goodback[0][0] + goodback[2][2]);
          if (ival < back[2] * invsigma + nsig)
            continue;
        }
        if ((goodback[2][0] + goodback[0][2]) > 0) {
          back[3] = (image[(j + 1) * xnpix + (i - 1)] * goodback[2][0] +
                     image[(j - 1) * xnpix + (i + 1)] * goodback[0][2]) /
                    (goodback[2][0] + goodback[0][2]);
          if (ival < back[3] * invsigma + nsig)
            continue;
          ival = invsigma * imcurr;
        }
        sigmaback[0] =
            sqrt((goodback[1][0] /
                      (image_ivar[j * xnpix + (i - 1)] + 1. - goodback[1][0]) +
                  goodback[1][2] /
                      (image_ivar[j * xnpix + (i + 1)] + 1. - goodback[1][2])) /
                 (goodback[1][0] + goodback[1][2]));
        lval = (ival - cfudge) * c2fudge * psfvals[0];
        if (lval > invsigma * (back[0] + cfudge * sigmaback[0])) {
          rejected[j * xnpix + i] = 1;
          image[j * xnpix + i] = back[0];
          continue;
        }
        sigmaback[1] =
            sqrt((goodback[0][1] /
                      (image_ivar[(j - 1) * xnpix + i] + 1. - goodback[0][1]) +
                  goodback[2][1] /
                      (image_ivar[(j + 1) * xnpix + i] + 1. - goodback[2][1])) /
                 (goodback[0][1] + goodback[2][1]));
        if (lval > invsigma * (back[1] + cfudge * sigmaback[1])) {
          rejected[j * xnpix + i] = 1;
          image[j * xnpix + i] = back[1];
          continue;
        }
        sigmaback[2] =
            sqrt((goodback[0][0] / (image_ivar[(j - 1) * xnpix + (i - 1)] + 1. -
                                    goodback[0][0]) +
                  goodback[2][2] / (image_ivar[(j + 1) * xnpix + (i + 1)] + 1. -
                                    goodback[2][2])) /
                 (goodback[0][0] + goodback[2][2]));
        lval = (ival - cfudge) * c2fudge * psfvals[1];
        if (lval > invsigma * (back[2] + cfudge * sigmaback[2])) {
          rejected[j * xnpix + i] = 1;
          image[j * xnpix + i] = back[2];
          continue;
        }
        sigmaback[3] =
            sqrt((goodback[2][0] / (image_ivar[(j + 1) * xnpix + (i - 1)] + 1. -
                                    goodback[2][0]) +
                  goodback[0][2] / (image_ivar[(j - 1) * xnpix + (i + 1)] + 1. -
                                    goodback[0][2])) /
                 (goodback[2][0] + goodback[0][2]));
        if (lval > invsigma * (back[3] + cfudge * sigmaback[3])) {
          rejected[j * xnpix + i] = 1;
          image[j * xnpix + i] = back[3];
          continue;
        }
      }
    }
  }
  {
    if ((sigmaback) != NULL)
      free((char *)(sigmaback));
    (sigmaback) = NULL;
  };
  {
    if ((back) != NULL)
      free((char *)(back));
    (back) = NULL;
  };
  return (0);
}


x86 assembly (clang, -O0):
<reject_cr_psf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm1,-0x2c(%rbp)
movss  %xmm2,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    $0x10,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    $0x10,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b86 <reject_cr_psf+0xa56>
movl   $0x1,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b6d <reject_cr_psf+0xa3d>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b54 <reject_cr_psf+0xa24>
mov    0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1b54 <reject_cr_psf+0xa24>
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <sqrt@plt>
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x58(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0xffffffff,-0x8c(%rbp)
ff ff ff
cmpl   $0x1,-0x8c(%rbp)
jg     1342 <reject_cr_psf+0x212>
movl   $0xffffffff,-0x90(%rbp)
ff ff ff
cmpl   $0x1,-0x90(%rbp)
jg     1329 <reject_cr_psf+0x1f9>
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x90(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    -0x8c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
cvtsi2ss %eax,%xmm0
mov    -0x90(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x80(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    -0x8c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    129f <reject_cr_psf+0x16f>
jmp    132e <reject_cr_psf+0x1fe>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1288 <reject_cr_psf+0x158>
movss  -0x74(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    13f4 <reject_cr_psf+0x2c4>
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
addss  -0x6c(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x1c(%rbp),%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
ucomiss %xmm1,%xmm0
jbe    13ef <reject_cr_psf+0x2bf>
jmp    1b59 <reject_cr_psf+0xa29>
jmp    13f4 <reject_cr_psf+0x2c4>
movss  -0x7c(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14a4 <reject_cr_psf+0x374>
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x7c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
addss  -0x64(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x1c(%rbp),%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
ucomiss %xmm1,%xmm0
jbe    149f <reject_cr_psf+0x36f>
jmp    1b59 <reject_cr_psf+0xa29>
jmp    14a4 <reject_cr_psf+0x374>
movss  -0x80(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    155e <reject_cr_psf+0x42e>
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x80(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x80(%rbp),%xmm1
addss  -0x60(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x1c(%rbp),%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
ucomiss %xmm1,%xmm0
jbe    1559 <reject_cr_psf+0x429>
jmp    1b59 <reject_cr_psf+0xa29>
jmp    155e <reject_cr_psf+0x42e>
movss  -0x68(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1622 <reject_cr_psf+0x4f2>
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x68(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x68(%rbp),%xmm1
addss  -0x78(%rbp),%xmm1
divss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x58(%rbp),%xmm3
movss  -0x1c(%rbp),%xmm2
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
ucomiss %xmm1,%xmm0
jbe    1613 <reject_cr_psf+0x4e3>
jmp    1b59 <reject_cr_psf+0xa29>
movss  -0x58(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x9a8(%rip),%xmm2
addsd  %xmm2,%xmm1
movss  -0x74(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movss  -0x6c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0x95d(%rip),%xmm3
addsd  %xmm3,%xmm2
movss  -0x6c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
addss  -0x6c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm3
movss  -0x2c(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    1776 <reject_cr_psf+0x646>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1b59 <reject_cr_psf+0xa29>
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x856(%rip),%xmm2
addsd  %xmm2,%xmm1
movss  -0x7c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movss  -0x64(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0x80d(%rip),%xmm3
addsd  %xmm3,%xmm2
movss  -0x64(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movss  -0x7c(%rbp),%xmm1
addss  -0x64(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
mov    -0x40(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm3
movss  -0x2c(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    18ae <reject_cr_psf+0x77e>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1b59 <reject_cr_psf+0xa29>
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x719(%rip),%xmm2
addsd  %xmm2,%xmm1
movss  -0x80(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0x6cb(%rip),%xmm3
addsd  %xmm3,%xmm2
movss  -0x60(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movss  -0x80(%rbp),%xmm1
addss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
mov    -0x40(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x50(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm3
movss  -0x2c(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    1a0d <reject_cr_psf+0x8dd>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1b59 <reject_cr_psf+0xa29>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x5ba(%rip),%xmm2
addsd  %xmm2,%xmm1
movss  -0x68(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movss  -0x78(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x88(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x14(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0x56c(%rip),%xmm3
addsd  %xmm3,%xmm2
movss  -0x78(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movss  -0x68(%rbp),%xmm1
addss  -0x78(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1050 <sqrt@plt>
mov    -0x40(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x58(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm3
movss  -0x2c(%rbp),%xmm2
mov    -0x40(%rbp),%rax
movss  0xc(%rax),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    1b4f <reject_cr_psf+0xa1f>
mov    -0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x88(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x84(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1b59 <reject_cr_psf+0xa29>
jmp    1b54 <reject_cr_psf+0xa24>
jmp    1b59 <reject_cr_psf+0xa29>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    11a8 <reject_cr_psf+0x78>
jmp    1b72 <reject_cr_psf+0xa42>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    118a <reject_cr_psf+0x5a>
cmpq   $0x0,-0x40(%rbp)
je     1b9a <reject_cr_psf+0xa6a>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x40(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     1bb6 <reject_cr_psf+0xa86>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movq   $0x0,-0x48(%rbp)
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reject_cr_psf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9,0x90(%rsp)
movss  %xmm2,0x7c(%rsp)
movss  %xmm1,0x28(%rsp)
mov    %r8,0x98(%rsp)
movss  %xmm0,0x2c(%rsp)
mov    %ecx,%ebx
mov    %edx,%ebp
mov    %rsi,0x88(%rsp)
mov    %rdi,0x80(%rsp)
mov    $0x10,%edi
call   1040 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x10,%edi
call   1040 <malloc@plt>
mov    %rax,%r8
cmp    $0x3,%ebx
mov    %rax,0x40(%rsp)
jl     197d <reject_cr_psf+0x84d>
mov    0x100(%rsp),%rcx
add    $0xffffffff,%ebx
lea    -0x1(%rbp),%eax
movslq %ebp,%rdx
mov    %rdx,0xa0(%rsp)
addq   $0x8,0x80(%rsp)
addq   $0x8,0x88(%rsp)
addq   $0x4,0x90(%rsp)
add    $0x4,%rcx
mov    %rcx,0xa8(%rsp)
lea    -0x4(,%rax,4),%r15
ff
mov    $0x1,%edx
xorps  %xmm5,%xmm5
movss  0xe07(%rip),%xmm6
movsd  0xe06(%rip),%xmm10
mov    %rbx,0xb8(%rsp)
mov    %rbp,0xb0(%rsp)
jmp    1241 <reject_cr_psf+0x111>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xb8(%rsp),%rbx
mov    0xb0(%rsp),%rbp
mov    0xc0(%rsp),%rdx
cmp    %rbx,%rdx
je     197d <reject_cr_psf+0x84d>
cmp    $0x2,%ebp
jle    1970 <reject_cr_psf+0x840>
mov    %rdx,%rax
mov    0xa0(%rsp),%rsi
imul   %rsi,%rax
lea    -0x1(%rdx),%rcx
imul   %rsi,%rcx
add    $0x1,%rdx
mov    %rdx,0xc0(%rsp)
imul   %rsi,%rdx
mov    0x80(%rsp),%rdi
lea    (%rdi,%rcx,4),%rsi
mov    %rsi,0x70(%rsp)
mov    0x88(%rsp),%rsi
lea    (%rsi,%rcx,4),%r13
lea    (%rdi,%rax,4),%r9
lea    (%rsi,%rax,4),%rbp
lea    (%rdi,%rdx,4),%rcx
mov    %rcx,0x68(%rsp)
lea    (%rsi,%rdx,4),%r12
mov    0x90(%rsp),%rcx
lea    (%rcx,%rax,4),%rbx
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
xor    %r14d,%r14d
mov    %r9,0x50(%rsp)
mov    %rcx,0x48(%rsp)
jmp    12ed <reject_cr_psf+0x1bd>
movl   $0x1,(%rbx,%r14,1)
movss  %xmm1,-0x4(%r9,%r14,1)
nopl   0x0(%rax)
add    $0x4,%r14
cmp    %r14,%r15
je     1220 <reject_cr_psf+0xf0>
movl   $0x0,(%rbx,%r14,1)
movss  -0x4(%rbp,%r14,1),%xmm0
ucomiss %xmm5,%xmm0
jbe    12e0 <reject_cr_psf+0x1b0>
cmpl   $0x0,(%rcx,%r14,1)
jne    12e0 <reject_cr_psf+0x1b0>
ucomiss %xmm5,%xmm0
jb     1318 <reject_cr_psf+0x1e8>
xorps  %xmm8,%xmm8
sqrtss %xmm0,%xmm8
jmp    1344 <reject_cr_psf+0x214>
call   1050 <sqrt@plt>
mov    0x48(%rsp),%rcx
mov    0x50(%rsp),%r9
movsd  0xcd8(%rip),%xmm10
movss  0xcc8(%rip),%xmm6
xorps  %xmm5,%xmm5
mov    0x40(%rsp),%r8
movaps %xmm0,%xmm8
movss  -0x8(%r13,%r14,1),%xmm12
movss  -0x4(%r13,%r14,1),%xmm0
movss  %xmm0,0x30(%rsp)
movss  -0x8(%rbp,%r14,1),%xmm2
movss  0x0(%rbp,%r14,1),%xmm1
xorps  %xmm3,%xmm3
cmpltss %xmm2,%xmm3
andps  %xmm6,%xmm3
movss  -0x8(%r12,%r14,1),%xmm11
movss  -0x4(%r12,%r14,1),%xmm0
movss  %xmm0,0x64(%rsp)
movss  0x0(%r13,%r14,1),%xmm0
movss  %xmm0,0x60(%rsp)
xorps  %xmm4,%xmm4
cmpltss %xmm1,%xmm4
andps  %xmm6,%xmm4
movss  (%r12,%r14,1),%xmm13
movss  -0x4(%r9,%r14,1),%xmm9
mulss  %xmm8,%xmm9
movaps %xmm3,%xmm0
addss  %xmm4,%xmm0
ucomiss %xmm5,%xmm0
jbe    13ea <reject_cr_psf+0x2ba>
mulss  (%r9,%r14,1),%xmm4
mulss  -0x8(%r9,%r14,1),%xmm3
addss  %xmm4,%xmm3
divss  %xmm0,%xmm3
movss  %xmm3,(%r8)
mulss  %xmm8,%xmm3
addss  0x2c(%rsp),%xmm3
ucomiss %xmm9,%xmm3
ja     12e0 <reject_cr_psf+0x1b0>
xorps  %xmm3,%xmm3
cmpltss 0x30(%rsp),%xmm3
andps  %xmm6,%xmm3
xorps  %xmm4,%xmm4
cmpltss 0x64(%rsp),%xmm4
andps  %xmm6,%xmm4
movaps %xmm3,%xmm7
addss  %xmm4,%xmm7
movss  %xmm7,0x5c(%rsp)
ucomiss %xmm5,%xmm7
jbe    1453 <reject_cr_psf+0x323>
mov    0x68(%rsp),%rax
mulss  -0x4(%rax,%r14,1),%xmm4
mov    0x70(%rsp),%rax
mulss  -0x4(%rax,%r14,1),%xmm3
addss  %xmm4,%xmm3
divss  0x5c(%rsp),%xmm3
movss  %xmm3,0x4(%r8)
mulss  %xmm8,%xmm3
addss  0x2c(%rsp),%xmm3
ucomiss %xmm9,%xmm3
ja     12e0 <reject_cr_psf+0x1b0>
xorps  %xmm3,%xmm3
cmpltss %xmm12,%xmm3
andps  %xmm6,%xmm3
xorps  %xmm4,%xmm4
cmpltss %xmm13,%xmm4
andps  %xmm6,%xmm4
movaps %xmm3,%xmm15
addss  %xmm4,%xmm15
ucomiss %xmm5,%xmm15
jbe    14b5 <reject_cr_psf+0x385>
mov    0x68(%rsp),%rax
mulss  (%rax,%r14,1),%xmm4
mov    0x70(%rsp),%rax
mulss  -0x8(%rax,%r14,1),%xmm3
addss  %xmm4,%xmm3
divss  %xmm15,%xmm3
movss  %xmm3,0x8(%r8)
mulss  %xmm8,%xmm3
addss  0x2c(%rsp),%xmm3
ucomiss %xmm9,%xmm3
ja     12e0 <reject_cr_psf+0x1b0>
xorps  %xmm3,%xmm3
cmpltss %xmm11,%xmm3
andps  %xmm6,%xmm3
xorps  %xmm4,%xmm4
cmpltss 0x60(%rsp),%xmm4
andps  %xmm6,%xmm4
movaps %xmm3,%xmm14
addss  %xmm4,%xmm14
ucomiss %xmm5,%xmm14
jbe    1518 <reject_cr_psf+0x3e8>
mov    0x70(%rsp),%rax
mulss  (%rax,%r14,1),%xmm4
mov    0x68(%rsp),%rax
mulss  -0x8(%rax,%r14,1),%xmm3
addss  %xmm4,%xmm3
divss  %xmm14,%xmm3
movss  %xmm3,0xc(%r8)
mulss  %xmm8,%xmm3
addss  0x2c(%rsp),%xmm3
ucomiss %xmm9,%xmm3
ja     12e0 <reject_cr_psf+0x1b0>
ucomiss %xmm5,%xmm2
movapd %xmm10,%xmm2
ja     1526 <reject_cr_psf+0x3f6>
xorpd  %xmm2,%xmm2
ucomiss %xmm5,%xmm1
movapd %xmm10,%xmm1
ja     1534 <reject_cr_psf+0x404>
xorpd  %xmm1,%xmm1
movss  -0x8(%rbp,%r14,1),%xmm3
movss  0x0(%rbp,%r14,1),%xmm4
cvtss2sd %xmm3,%xmm3
addsd  %xmm10,%xmm3
subsd  %xmm2,%xmm3
divsd  %xmm3,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
addsd  %xmm10,%xmm3
subsd  %xmm1,%xmm3
divsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
cvtss2sd %xmm0,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
ucomiss %xmm5,%xmm0
movss  %xmm8,0x24(%rsp)
jb     158f <reject_cr_psf+0x45f>
sqrtss %xmm0,%xmm0
jmp    1612 <reject_cr_psf+0x4e2>
movss  %xmm9,0xc(%rsp)
movss  %xmm11,0x14(%rsp)
movss  %xmm12,0x3c(%rsp)
movss  %xmm13,0x38(%rsp)
movss  %xmm14,0x10(%rsp)
movss  %xmm15,0x34(%rsp)
call   1050 <sqrt@plt>
movss  0x34(%rsp),%xmm15
movss  0x10(%rsp),%xmm14
movss  0x38(%rsp),%xmm13
movss  0x3c(%rsp),%xmm12
movss  0x14(%rsp),%xmm11
movss  0xc(%rsp),%xmm9
movss  0x24(%rsp),%xmm8
mov    0x48(%rsp),%rcx
mov    0x50(%rsp),%r9
movsd  0xa06(%rip),%xmm10
movss  0x9f6(%rip),%xmm6
xorps  %xmm5,%xmm5
mov    0x40(%rsp),%r8
mov    0x18(%rsp),%rax
movss  %xmm0,(%rax)
movss  0x28(%rsp),%xmm2
subss  %xmm2,%xmm9
mulss  0x7c(%rsp),%xmm9
mov    0x98(%rsp),%rax
movss  (%rax),%xmm3
mulss  %xmm9,%xmm3
movss  (%r8),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm8,%xmm0
ucomiss %xmm0,%xmm3
ja     12ca <reject_cr_psf+0x19a>
movss  0x30(%rsp),%xmm0
ucomiss %xmm5,%xmm0
movapd %xmm10,%xmm0
ja     166d <reject_cr_psf+0x53d>
xorpd  %xmm0,%xmm0
movss  0x64(%rsp),%xmm1
ucomiss %xmm5,%xmm1
movapd %xmm10,%xmm1
ja     1681 <reject_cr_psf+0x551>
xorpd  %xmm1,%xmm1
movss  -0x4(%r13,%r14,1),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm10,%xmm2
subsd  %xmm0,%xmm2
divsd  %xmm2,%xmm0
movss  -0x4(%r12,%r14,1),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm10,%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movss  0x5c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
ucomiss %xmm5,%xmm0
jb     16d8 <reject_cr_psf+0x5a8>
sqrtss %xmm0,%xmm0
jmp    1767 <reject_cr_psf+0x637>
movss  %xmm9,0xc(%rsp)
movss  %xmm11,0x14(%rsp)
movss  %xmm12,0x3c(%rsp)
movss  %xmm13,0x38(%rsp)
movss  %xmm14,0x10(%rsp)
movss  %xmm15,0x34(%rsp)
movss  %xmm3,0x30(%rsp)
call   1050 <sqrt@plt>
movss  0x30(%rsp),%xmm3
movss  0x34(%rsp),%xmm15
movss  0x10(%rsp),%xmm14
movss  0x38(%rsp),%xmm13
movss  0x3c(%rsp),%xmm12
movss  0x14(%rsp),%xmm11
movss  0xc(%rsp),%xmm9
movss  0x24(%rsp),%xmm8
mov    0x48(%rsp),%rcx
mov    0x50(%rsp),%r9
movsd  0x8b1(%rip),%xmm10
movss  0x8a1(%rip),%xmm6
xorps  %xmm5,%xmm5
mov    0x40(%rsp),%r8
mov    0x18(%rsp),%rax
movss  %xmm0,0x4(%rax)
movss  0x4(%r8),%xmm1
mulss  0x28(%rsp),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm8,%xmm0
ucomiss %xmm0,%xmm3
ja     12ca <reject_cr_psf+0x19a>
ucomiss %xmm5,%xmm12
movapd %xmm10,%xmm0
ja     179e <reject_cr_psf+0x66e>
xorpd  %xmm0,%xmm0
ucomiss %xmm5,%xmm13
movapd %xmm10,%xmm1
ja     17ad <reject_cr_psf+0x67d>
xorpd  %xmm1,%xmm1
movss  -0x8(%r13,%r14,1),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm10,%xmm2
subsd  %xmm0,%xmm2
divsd  %xmm2,%xmm0
movss  (%r12,%r14,1),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm10,%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm15,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
ucomiss %xmm5,%xmm0
jb     17fe <reject_cr_psf+0x6ce>
sqrtss %xmm0,%xmm0
jmp    1857 <reject_cr_psf+0x727>
movss  %xmm9,0xc(%rsp)
movss  %xmm11,0x14(%rsp)
movss  %xmm14,0x10(%rsp)
call   1050 <sqrt@plt>
movss  0x10(%rsp),%xmm14
movss  0x14(%rsp),%xmm11
movss  0xc(%rsp),%xmm9
movss  0x24(%rsp),%xmm8
mov    0x48(%rsp),%rcx
mov    0x50(%rsp),%r9
movsd  0x7c1(%rip),%xmm10
movss  0x7b1(%rip),%xmm6
xorps  %xmm5,%xmm5
mov    0x40(%rsp),%r8
mov    0x18(%rsp),%rax
movss  %xmm0,0x8(%rax)
mov    0x98(%rsp),%rax
mulss  0x4(%rax),%xmm9
movss  0x8(%r8),%xmm1
mulss  0x28(%rsp),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm8,%xmm0
ucomiss %xmm0,%xmm9
ja     12ca <reject_cr_psf+0x19a>
ucomiss %xmm5,%xmm11
movapd %xmm10,%xmm0
ja     189d <reject_cr_psf+0x76d>
xorpd  %xmm0,%xmm0
movss  0x60(%rsp),%xmm1
ucomiss %xmm5,%xmm1
movapd %xmm10,%xmm1
ja     18b1 <reject_cr_psf+0x781>
xorpd  %xmm1,%xmm1
movss  -0x8(%r12,%r14,1),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm10,%xmm2
subsd  %xmm0,%xmm2
divsd  %xmm2,%xmm0
movss  0x0(%r13,%r14,1),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm10,%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm14,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
ucomiss %xmm5,%xmm0
jb     1903 <reject_cr_psf+0x7d3>
sqrtss %xmm0,%xmm0
jmp    1940 <reject_cr_psf+0x810>
movss  %xmm9,0xc(%rsp)
call   1050 <sqrt@plt>
movss  0xc(%rsp),%xmm9
movss  0x24(%rsp),%xmm8
mov    0x48(%rsp),%rcx
mov    0x50(%rsp),%r9
movsd  0x6d8(%rip),%xmm10
movss  0x6c8(%rip),%xmm6
xorps  %xmm5,%xmm5
mov    0x40(%rsp),%r8
mov    0x18(%rsp),%rax
movss  %xmm0,0xc(%rax)
movss  0xc(%r8),%xmm1
mulss  0x28(%rsp),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm0,%xmm8
ucomiss %xmm8,%xmm9
ja     12ca <reject_cr_psf+0x19a>
jmp    12e0 <reject_cr_psf+0x1b0>
xchg   %ax,%ax
add    $0x1,%rdx
cmp    %rbx,%rdx
jne    1241 <reject_cr_psf+0x111>
mov    0x18(%rsp),%rdi
test   %rdi,%rdi
je     1991 <reject_cr_psf+0x861>
call   1030 <free@plt>
mov    0x40(%rsp),%r8
test   %r8,%r8
je     199e <reject_cr_psf+0x86e>
mov    %r8,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @reject_cr_psf(float* nocapture %0, float* nocapture %1, i32 %2, i32 %3, float %4, float* nocapture %5, float %6, float %7, i32* nocapture writeonly %8, i32* nocapture %9) {
%11 = tail call i64 @malloc(i32 16)
%12 = inttoptr i64 %11 to float*
%13 = tail call i64 @malloc(i32 16)
%14 = inttoptr i64 %13 to float*
%15 = icmp sgt i32 %3, 2
br i1 %15, label %16, label %251
16: ; preds = %10
%17 = add nsw i32 %3, -1
%18 = add i32 %2, -1
%19 = icmp sgt i32 %2, 2
%20 = getelementptr inbounds float, float* %14, i64 1
%21 = getelementptr inbounds float, float* %14, i64 2
%22 = getelementptr inbounds float, float* %14, i64 3
%23 = getelementptr inbounds float, float* %12, i64 1
%24 = getelementptr inbounds float, float* %12, i64 2
%25 = getelementptr inbounds float, float* %5, i64 1
%26 = getelementptr inbounds float, float* %12, i64 3
%27 = sext i32 %2 to i64
%28 = zext i32 %17 to i64
%29 = zext i32 %18 to i64
br label %30
30: ; preds = %16, %248
%31 = phi i64 [ 1, %16 ], [ %249, %248 ]
br i1 %19, label %34, label %32
32: ; preds = %30
%33 = add nuw nsw i64 %31, 1
br label %248
34: ; preds = %30
%35 = mul nsw i64 %31, %27
%36 = add nsw i64 %31, -1
%37 = mul nsw i64 %36, %27
%38 = add nuw nsw i64 %31, 1
%39 = mul nsw i64 %38, %27
br label %40
40: ; preds = %34, %245
%41 = phi i64 [ 1, %34 ], [ %246, %245 ]
%42 = add nsw i64 %41, %35
%43 = getelementptr inbounds i32, i32* %8, i64 %42
store i32 0, i32* %43
%44 = getelementptr inbounds float, float* %1, i64 %42
%45 = load float, float* %44
%46 = fcmp ogt float %45, 0.000000e+00
br i1 %46, label %47, label %245
47: ; preds = %40
%48 = getelementptr inbounds i32, i32* %9, i64 %42
%49 = load i32, i32* %48
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %245
51: ; preds = %47
%52 = tail call float @sqrt(float %45)
%53 = getelementptr inbounds float, float* %0, i64 %42
%54 = load float, float* %53
%55 = add nsw i64 %41, -1
%56 = add nsw i64 %55, %37
%57 = getelementptr inbounds float, float* %1, i64 %56
%58 = load float, float* %57
%59 = fcmp ogt float %58, 0.000000e+00
%60 = uitofp i1 %59 to float
%61 = add nsw i64 %55, %35
%62 = getelementptr inbounds float, float* %1, i64 %61
%63 = load float, float* %62
%64 = fcmp ogt float %63, 0.000000e+00
%65 = uitofp i1 %64 to float
%66 = add nsw i64 %55, %39
%67 = getelementptr inbounds float, float* %1, i64 %66
%68 = load float, float* %67
%69 = fcmp ogt float %68, 0.000000e+00
%70 = uitofp i1 %69 to float
%71 = add nsw i64 %41, %37
%72 = getelementptr inbounds float, float* %1, i64 %71
%73 = load float, float* %72
%74 = fcmp ogt float %73, 0.000000e+00
%75 = uitofp i1 %74 to float
%76 = add nsw i64 %41, %39
%77 = getelementptr inbounds float, float* %1, i64 %76
%78 = load float, float* %77
%79 = fcmp ogt float %78, 0.000000e+00
%80 = uitofp i1 %79 to float
%81 = add nuw nsw i64 %41, 1
%82 = add nsw i64 %81, %37
%83 = getelementptr inbounds float, float* %1, i64 %82
%84 = load float, float* %83
%85 = fcmp ogt float %84, 0.000000e+00
%86 = uitofp i1 %85 to float
%87 = add nsw i64 %81, %35
%88 = getelementptr inbounds float, float* %1, i64 %87
%89 = load float, float* %88
%90 = fcmp ogt float %89, 0.000000e+00
%91 = uitofp i1 %90 to float
%92 = add nsw i64 %81, %39
%93 = getelementptr inbounds float, float* %1, i64 %92
%94 = load float, float* %93
%95 = fcmp ogt float %94, 0.000000e+00
%96 = uitofp i1 %95 to float
%97 = fmul float %52, %54
%98 = fadd float %65, %91
%99 = fcmp ogt float %98, 0.000000e+00
br i1 %99, label %100, label %110
100: ; preds = %51
%101 = getelementptr inbounds float, float* %0, i64 %61
%102 = load float, float* %101
%103 = getelementptr inbounds float, float* %0, i64 %87
%104 = load float, float* %103
%105 = fmul float %104, %91
%106 = tail call float @llvm.fmuladd.f32(float %102, float %65, float %105)
%107 = fdiv float %106, %98
store float %107, float* %14
%108 = tail call float @llvm.fmuladd.f32(float %107, float %52, float %4)
%109 = fcmp olt float %97, %108
br i1 %109, label %245, label %110
110: ; preds = %100, %51
%111 = fadd float %75, %80
%112 = fcmp ogt float %111, 0.000000e+00
br i1 %112, label %113, label %123
113: ; preds = %110
%114 = getelementptr inbounds float, float* %0, i64 %71
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %0, i64 %76
%117 = load float, float* %116
%118 = fmul float %117, %80
%119 = tail call float @llvm.fmuladd.f32(float %115, float %75, float %118)
%120 = fdiv float %119, %111
store float %120, float* %20
%121 = tail call float @llvm.fmuladd.f32(float %120, float %52, float %4)
%122 = fcmp olt float %97, %121
br i1 %122, label %245, label %123
123: ; preds = %113, %110
%124 = fadd float %60, %96
%125 = fcmp ogt float %124, 0.000000e+00
br i1 %125, label %126, label %136
126: ; preds = %123
%127 = getelementptr inbounds float, float* %0, i64 %56
%128 = load float, float* %127
%129 = getelementptr inbounds float, float* %0, i64 %92
%130 = load float, float* %129
%131 = fmul float %130, %96
%132 = tail call float @llvm.fmuladd.f32(float %128, float %60, float %131)
%133 = fdiv float %132, %124
store float %133, float* %21
%134 = tail call float @llvm.fmuladd.f32(float %133, float %52, float %4)
%135 = fcmp olt float %97, %134
br i1 %135, label %245, label %136
136: ; preds = %126, %123
%137 = fadd float %70, %86
%138 = fcmp ogt float %137, 0.000000e+00
br i1 %138, label %139, label %149
139: ; preds = %136
%140 = getelementptr inbounds float, float* %0, i64 %66
%141 = load float, float* %140
%142 = getelementptr inbounds float, float* %0, i64 %82
%143 = load float, float* %142
%144 = fmul float %143, %86
%145 = tail call float @llvm.fmuladd.f32(float %141, float %70, float %144)
%146 = fdiv float %145, %137
store float %146, float* %22
%147 = tail call float @llvm.fmuladd.f32(float %146, float %52, float %4)
%148 = fcmp olt float %97, %147
br i1 %148, label %245, label %149
149: ; preds = %139, %136
%150 = uitofp i1 %64 to double
%151 = load float, float* %62
%152 = fpext float %151 to double
%153 = fadd double %152, 1.000000e+00
%154 = fsub double %153, %150
%155 = fdiv double %150, %154
%156 = uitofp i1 %90 to double
%157 = load float, float* %88
%158 = fpext float %157 to double
%159 = fadd double %158, 1.000000e+00
%160 = fsub double %159, %156
%161 = fdiv double %156, %160
%162 = fadd double %155, %161
%163 = fpext float %98 to double
%164 = fdiv double %162, %163
%165 = fptrunc double %164 to float
%166 = tail call float @sqrt(float %165)
store float %166, float* %12
%167 = fsub float %97, %6
%168 = fmul float %167, %7
%169 = load float, float* %5
%170 = fmul float %168, %169
%171 = load float, float* %14
%172 = tail call float @llvm.fmuladd.f32(float %6, float %166, float %171)
%173 = fmul float %52, %172
%174 = fcmp ogt float %170, %173
br i1 %174, label %243, label %175
175: ; preds = %149
%176 = uitofp i1 %74 to double
%177 = load float, float* %72
%178 = fpext float %177 to double
%179 = fadd double %178, 1.000000e+00
%180 = fsub double %179, %176
%181 = fdiv double %176, %180
%182 = uitofp i1 %79 to double
%183 = load float, float* %77
%184 = fpext float %183 to double
%185 = fadd double %184, 1.000000e+00
%186 = fsub double %185, %182
%187 = fdiv double %182, %186
%188 = fadd double %181, %187
%189 = fpext float %111 to double
%190 = fdiv double %188, %189
%191 = fptrunc double %190 to float
%192 = tail call float @sqrt(float %191)
store float %192, float* %23
%193 = load float, float* %20
%194 = tail call float @llvm.fmuladd.f32(float %6, float %192, float %193)
%195 = fmul float %52, %194
%196 = fcmp ogt float %170, %195
br i1 %196, label %243, label %197
197: ; preds = %175
%198 = uitofp i1 %59 to double
%199 = load float, float* %57
%200 = fpext float %199 to double
%201 = fadd double %200, 1.000000e+00
%202 = fsub double %201, %198
%203 = fdiv double %198, %202
%204 = uitofp i1 %95 to double
%205 = load float, float* %93
%206 = fpext float %205 to double
%207 = fadd double %206, 1.000000e+00
%208 = fsub double %207, %204
%209 = fdiv double %204, %208
%210 = fadd double %203, %209
%211 = fpext float %124 to double
%212 = fdiv double %210, %211
%213 = fptrunc double %212 to float
%214 = tail call float @sqrt(float %213)
store float %214, float* %24
%215 = load float, float* %25
%216 = fmul float %168, %215
%217 = load float, float* %21
%218 = tail call float @llvm.fmuladd.f32(float %6, float %214, float %217)
%219 = fmul float %52, %218
%220 = fcmp ogt float %216, %219
br i1 %220, label %243, label %221
221: ; preds = %197
%222 = uitofp i1 %69 to double
%223 = load float, float* %67
%224 = fpext float %223 to double
%225 = fadd double %224, 1.000000e+00
%226 = fsub double %225, %222
%227 = fdiv double %222, %226
%228 = uitofp i1 %85 to double
%229 = load float, float* %83
%230 = fpext float %229 to double
%231 = fadd double %230, 1.000000e+00
%232 = fsub double %231, %228
%233 = fdiv double %228, %232
%234 = fadd double %227, %233
%235 = fpext float %137 to double
%236 = fdiv double %234, %235
%237 = fptrunc double %236 to float
%238 = tail call float @sqrt(float %237)
store float %238, float* %26
%239 = load float, float* %22
%240 = tail call float @llvm.fmuladd.f32(float %6, float %238, float %239)
%241 = fmul float %52, %240
%242 = fcmp ogt float %216, %241
br i1 %242, label %243, label %245
243: ; preds = %221, %197, %175, %149
%244 = phi float [ %171, %149 ], [ %193, %175 ], [ %217, %197 ], [ %239, %221 ]
store i32 1, i32* %43
store float %244, float* %53
br label %245
245: ; preds = %243, %40, %47, %221, %139, %126, %113, %100
%246 = add nuw nsw i64 %41, 1
%247 = icmp eq i64 %246, %29
br i1 %247, label %248, label %40
248: ; preds = %245, %32
%249 = phi i64 [ %33, %32 ], [ %38, %245 ]
%250 = icmp eq i64 %249, %28
br i1 %250, label %251, label %30
251: ; preds = %248, %10
%252 = icmp eq i64 %11, 0
br i1 %252, label %256, label %253
253: ; preds = %251
%254 = inttoptr i64 %11 to i8*
%255 = tail call i32 @free(i8* %254)
br label %256
256: ; preds = %253, %251
%257 = icmp eq i64 %13, 0
br i1 %257, label %261, label %258
258: ; preds = %256
%259 = inttoptr i64 %13 to i8*
%260 = tail call i32 @free(i8* %259)
br label %261
261: ; preds = %258, %256
ret i32 0
}