#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 fabs(float);
int /*<<< orphan*/ minmax(float *, int, float *, float *);
float sqrt(float);
void itrtb(float *y, float *z, float *tab, int npts, float u, float v,
           float sfac, float bfac, int *ier) {
  float sighigh = 1.e6, sigmin = 0.1;
  float ynorm, ysum, sigma0, sigma1, tnorm, sum, absy, sumf, sumff, sumy, sumfy,
      a, a0, yi, ybas, w, fi;
  int i, j, icnt, nsum;
  int mcnt = 100;
  int lstop = 0;
  y--;
  tab--;
  if (z)
    z--;
  minmax(y + 1, npts, &ysum, &ynorm);
  ysum = fabs(ysum);
  ynorm = fabs(ynorm);
  if (ysum > ynorm)
    ynorm = ysum;
  minmax(tab + 1, npts, &ysum, &tnorm);
  ysum = fabs(ysum);
  tnorm = fabs(tnorm);
  if (ysum > tnorm)
    tnorm = ysum;
  if (ynorm == 0 || tnorm == 0)
    return;
  ynorm = 1.0 / ynorm;
  tnorm = 1.0 / tnorm;
  for (j = 1; j <= npts; j++) {
    y[j] *= ynorm;
    tab[j] *= tnorm;
  }
  sigma1 = sighigh;
  icnt = 0;
  while (!lstop) {
    icnt++;
    if (icnt >= mcnt) {
      if (z)
        *ier += 8000;
      else
        *ier += 7000;
      break;
    }
    sigma0 = sigma1;
    sum = 0.0;
    ysum = 0.0;
    for (j = 1; j <= npts; j++) {
      absy = fabs(y[j]);
      if ((u * sigma0) < absy)
        continue;
      sum += 1.0;
      ysum += absy * absy;
    }
    sigma1 = sqrt(ysum / sum);
    if (ysum == 0.0)
      sigma1 = sigmin;
    if ((sigma0 - sigma1) / sigma0 > sfac)
      continue;
    w = v * sigma1;
    nsum = 0;
    sumf = 0.0;
    sumff = 0.0;
    sumy = 0.0;
    sumfy = 0.0;
    a = 0.0;
    a0 = 0.0;
    for (i = 1; i <= npts; i++) {
      yi = y[i];
      if (!z && fabs(yi) > w)
        continue;
      if (z && z[i] == 0.0)
        continue;
      fi = tab[i];
      nsum += 1;
      sumf += fi;
      sumff += fi * fi;
      sumy += yi;
      sumfy += fi * yi;
    }
    if (nsum <= 0) {
      if (z)
        *ier += 8000;
      else
        *ier += 7000;
      break;
    }
    sum = (float)nsum;
    a = (sumf * sumy - sum * sumfy) / (sumf * sumf - sum * sumff);
    a0 = (sumy - a * sumf) / sum;
    lstop = 1;
    for (j = 1; j <= npts; j++) {
      ybas = a0 + a * tab[j];
      y[j] -= ybas;
      if (fabs(ybas) > bfac * sigma1)
        lstop = 0;
    }
  }
  ynorm = 1.0 / ynorm;
  tnorm = 1.0 / tnorm;
  for (j = 1; j <= npts; j++) {
    y[j] *= ynorm;
    tab[j] *= tnorm;
  }
}


x86 assembly (clang, -O0):
<itrtb>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movss  %xmm0,-0x20(%rbp)
movss  %xmm1,-0x24(%rbp)
movss  %xmm2,-0x28(%rbp)
movss  %xmm3,-0x2c(%rbp)
mov    %r8,-0x38(%rbp)
movss  0xe9a(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xe89(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x64,-0x98(%rbp)
movl   $0x0,-0x9c(%rbp)
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     11bf <itrtb+0x8f>
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
add    $0x4,%rdi
mov    -0x1c(%rbp),%esi
lea    -0x48(%rbp),%rdx
lea    -0x44(%rbp),%rcx
call   1050 <minmax@plt>
movss  -0x48(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x44(%rbp),%xmm0
jbe    120e <itrtb+0xde>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rdi
add    $0x4,%rdi
mov    -0x1c(%rbp),%esi
lea    -0x48(%rbp),%rdx
lea    -0x54(%rbp),%rcx
call   1050 <minmax@plt>
movss  -0x48(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x54(%rbp),%xmm0
jbe    125d <itrtb+0x12d>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x44(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1279 <itrtb+0x149>
jp     1279 <itrtb+0x149>
jmp    1290 <itrtb+0x160>
movss  -0x54(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1295 <itrtb+0x165>
jp     1295 <itrtb+0x165>
jmp    184e <itrtb+0x71e>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd62(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd44(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1332 <itrtb+0x202>
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    12db <itrtb+0x1ab>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x90(%rbp)
cmpl   $0x0,-0x9c(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    135f <itrtb+0x22f>
jmp    17b1 <itrtb+0x681>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x98(%rbp),%eax
jl     13b1 <itrtb+0x281>
cmpq   $0x0,-0x10(%rbp)
je     139e <itrtb+0x26e>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1f40,%ecx
mov    %ecx,(%rax)
jmp    13ac <itrtb+0x27c>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1b58,%ecx
mov    %ecx,(%rax)
jmp    17b1 <itrtb+0x681>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1469 <itrtb+0x339>
mov    -0x8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x5c(%rbp)
movss  -0x20(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    141b <itrtb+0x2eb>
jmp    1455 <itrtb+0x325>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbdc(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    13d5 <itrtb+0x2a5>
movss  -0x48(%rbp),%xmm0
divss  -0x58(%rbp),%xmm0
call   1040 <sqrt@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14a3 <itrtb+0x373>
jp     14a3 <itrtb+0x373>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
divss  -0x4c(%rbp),%xmm0
ucomiss -0x28(%rbp),%xmm0
jbe    14c1 <itrtb+0x391>
jmp    1346 <itrtb+0x216>
movss  -0x24(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movl   $0x0,-0x94(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1630 <itrtb+0x500>
mov    -0x8(%rbp),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    155c <itrtb+0x42c>
movss  -0x78(%rbp),%xmm0
call   1030 <fabs@plt>
ucomiss -0x80(%rbp),%xmm0
jbe    155c <itrtb+0x42c>
jmp    161c <itrtb+0x4ec>
cmpq   $0x0,-0x10(%rbp)
je     1593 <itrtb+0x463>
mov    -0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1593 <itrtb+0x463>
jp     1593 <itrtb+0x463>
jmp    161c <itrtb+0x4ec>
mov    -0x18(%rbp),%rax
movslq -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
movss  -0x84(%rbp),%xmm0
ff
addss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x78(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1514 <itrtb+0x3e4>
cmpl   $0x0,-0x94(%rbp)
jg     166e <itrtb+0x53e>
cmpq   $0x0,-0x10(%rbp)
je     165b <itrtb+0x52b>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1f40,%ecx
mov    %ecx,(%rax)
jmp    1669 <itrtb+0x539>
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
add    $0x1b58,%ecx
mov    %ecx,(%rax)
jmp    17b1 <itrtb+0x681>
cvtsi2ssl -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x58(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x6c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
movss  -0x60(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x64(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x68(%rbp),%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movl   $0x1,-0x9c(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     17ac <itrtb+0x67c>
movss  -0x74(%rbp),%xmm1
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
call   1030 <fabs@plt>
movss  -0x2c(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1793 <itrtb+0x663>
movl   $0x0,-0x9c(%rbp)
jmp    1798 <itrtb+0x668>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1718 <itrtb+0x5e8>
jmp    1346 <itrtb+0x216>
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x846(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x828(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     184e <itrtb+0x71e>
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    17f7 <itrtb+0x6c7>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<itrtb>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,0x40(%rsp)
movss  %xmm3,0x18(%rsp)
movss  %xmm2,0x2c(%rsp)
movss  %xmm1,0x1c(%rsp)
movss  %xmm0,0x24(%rsp)
mov    %ecx,%ebp
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbx
lea    -0x4(%rsi),%rax
test   %rsi,%rsi
cmove  %rsi,%rax
mov    %rax,0x68(%rsp)
mov    %rsp,%r15
lea    0x8(%rsp),%rcx
mov    %ebp,%esi
mov    %r15,%rdx
call   1040 <minmax@plt>
movss  (%rsp),%xmm0
movaps 0xe7c(%rip),%xmm2
andps  %xmm2,%xmm0
movss  %xmm0,(%rsp)
movss  0x8(%rsp),%xmm1
andps  %xmm2,%xmm1
maxss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
lea    0xc(%rsp),%rcx
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r15,%rdx
call   1040 <minmax@plt>
movaps 0xe47(%rip),%xmm14
movss  0x8(%rsp),%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    11cd <itrtb+0xad>
jnp    191b <itrtb+0x7fb>
movss  (%rsp),%xmm2
andps  %xmm14,%xmm2
movss  0xc(%rsp),%xmm3
andps  %xmm14,%xmm3
maxss  %xmm3,%xmm2
ucomiss %xmm0,%xmm2
jne    11ef <itrtb+0xcf>
jnp    191b <itrtb+0x7fb>
movss  0xe28(%rip),%xmm13
movaps %xmm13,%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
movaps %xmm13,%xmm1
divss  %xmm2,%xmm1
movss  %xmm1,0xc(%rsp)
lea    0x1(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    %eax,%r9d
test   %ebp,%ebp
jle    1339 <itrtb+0x219>
lea    -0x1(%r9),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     12b6 <itrtb+0x196>
lea    (%r12,%r9,4),%rdx
add    $0xfffffffffffffffc,%rdx
cmp    %rbx,%rdx
jbe    1253 <itrtb+0x133>
lea    (%rbx,%r9,4),%rdx
add    $0xfffffffffffffffc,%rdx
cmp    %r12,%rdx
ja     12b6 <itrtb+0x196>
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
lea    0x1(%rdx),%rax
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
xor    %esi,%esi
xchg   %ax,%ax
movups (%rbx,%rsi,4),%xmm4
movups 0x10(%rbx,%rsi,4),%xmm5
mulps  %xmm2,%xmm4
mulps  %xmm2,%xmm5
movups %xmm4,(%rbx,%rsi,4)
movups %xmm5,0x10(%rbx,%rsi,4)
movups (%r12,%rsi,4),%xmm4
movups 0x10(%r12,%rsi,4),%xmm5
mulps  %xmm3,%xmm4
mulps  %xmm3,%xmm5
movups %xmm4,(%r12,%rsi,4)
movups %xmm5,0x10(%r12,%rsi,4)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1270 <itrtb+0x150>
cmp    %rdx,%rcx
je     1339 <itrtb+0x219>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r9b
jne    12e8 <itrtb+0x1c8>
movss  -0x4(%rbx,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbx,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,-0x4(%r12,%rax,4)
add    $0x1,%rax
add    %r9,%rcx
je     1339 <itrtb+0x219>
nopl   (%rax)
movss  -0x4(%rbx,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbx,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,-0x4(%r12,%rax,4)
movss  (%rbx,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  %xmm2,(%rbx,%rax,4)
movss  (%r12,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,(%r12,%rax,4)
add    $0x2,%rax
cmp    %rax,%r9
jne    12f0 <itrtb+0x1d0>
lea    -0x1(%r9),%r10
lea    (%rbx,%r9,4),%rcx
add    $0xfffffffffffffffc,%rcx
lea    (%r12,%r9,4),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
cmp    %rbx,%rax
seta   %al
mov    %rcx,0x48(%rsp)
cmp    %r12,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %r10,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rsp)
add    $0x1,%rax
mov    %rax,0x58(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x60(%rsp)
mov    %r10,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
movss  0xc89(%rip),%xmm1
xor    %r8d,%r8d
movss  0xc81(%rip),%xmm15
xorps  %xmm11,%xmm11
movss  0xc78(%rip),%xmm12
xor    %r15d,%r15d
mov    %r9,0x10(%rsp)
mov    %r13,0x38(%rsp)
mov    %rbx,0x70(%rsp)
cmp    $0x64,%r15d
mov    $0x63,%edx
cmovge %r15d,%edx
movaps %xmm1,%xmm5
jmp    1467 <itrtb+0x347>
nopl   0x0(%rax,%rax,1)
mov    %r10,%r13
mov    %edx,%r14d
mov    %rsi,%rbx
movss  %xmm5,0x28(%rsp)
call   1030 <sqrt@plt>
movss  0x28(%rsp),%xmm5
mov    %rbx,%rsi
mov    0x70(%rsp),%rbx
mov    %r14d,%edx
movss  0xc1e(%rip),%xmm12
xorps  %xmm11,%xmm11
movss  0xc0d(%rip),%xmm15
xor    %r8d,%r8d
mov    %r13,%r10
movaps 0xbd7(%rip),%xmm14
movss  0xbee(%rip),%xmm13
add    $0x1,%r15d
movss  (%rsp),%xmm1
cmpeqss %xmm11,%xmm1
movaps %xmm1,%xmm2
andps  %xmm12,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
movaps %xmm5,%xmm0
subss  %xmm1,%xmm0
divss  %xmm5,%xmm0
ucomiss 0x2c(%rsp),%xmm0
movaps %xmm1,%xmm5
jbe    1550 <itrtb+0x430>
cmp    %edx,%r15d
je     17da <itrtb+0x6ba>
movl   $0x0,(%rsp)
movaps %xmm15,%xmm0
test   %ebp,%ebp
jle    14c8 <itrtb+0x3a8>
movaps %xmm5,%xmm2
mulss  0x24(%rsp),%xmm2
cmpl   $0x2,0x20(%rsp)
jne    14e0 <itrtb+0x3c0>
xorps  %xmm1,%xmm1
mov    $0x1,%eax
xorps  %xmm0,%xmm0
test   $0x1,%r10b
je     14c4 <itrtb+0x3a4>
movss  -0x4(%rbx,%rax,4),%xmm3
movaps %xmm3,%xmm4
andps  %xmm14,%xmm4
ucomiss %xmm2,%xmm4
ja     14c4 <itrtb+0x3a4>
addss  %xmm13,%xmm1
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,(%rsp)
divss  %xmm1,%xmm0
ucomiss %xmm11,%xmm0
jb     13e0 <itrtb+0x2c0>
sqrtss %xmm0,%xmm0
jmp    1432 <itrtb+0x312>
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
mov    $0x1,%eax
xorps  %xmm0,%xmm0
jmp    1502 <itrtb+0x3e2>
nopl   (%rax)
lea    (%rsi,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
je     149a <itrtb+0x37a>
movss  -0x4(%rbx,%rax,4),%xmm3
movaps %xmm3,%xmm4
andps  %xmm14,%xmm4
ucomiss %xmm2,%xmm4
ja     1526 <itrtb+0x406>
addss  %xmm13,%xmm1
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,(%rsp)
movss  (%rbx,%rax,4),%xmm3
movaps %xmm3,%xmm4
andps  %xmm14,%xmm4
ucomiss %xmm2,%xmm4
ja     14f0 <itrtb+0x3d0>
addss  %xmm13,%xmm1
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,(%rsp)
jmp    14f0 <itrtb+0x3d0>
nopl   0x0(%rax,%rax,1)
test   %ebp,%ebp
mov    0x10(%rsp),%r9
mov    0x38(%rsp),%r13
jle    192a <itrtb+0x80a>
movaps %xmm1,%xmm2
mulss  0x1c(%rsp),%xmm2
xorps  %xmm3,%xmm3
xorps  %xmm10,%xmm10
xor    %ecx,%ecx
xor    %eax,%eax
xorps  %xmm4,%xmm4
jmp    15ab <itrtb+0x48b>
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rcx,4),%xmm6
add    $0x1,%eax
addss  %xmm6,%xmm4
addss  %xmm5,%xmm10
movaps %xmm6,%xmm7
shufps $0x0,%xmm6,%xmm7
unpcklps %xmm5,%xmm6
mulps  %xmm7,%xmm6
addps  %xmm6,%xmm3
add    $0x1,%rcx
cmp    %rcx,%r10
je     15e0 <itrtb+0x4c0>
movss  (%rbx,%rcx,4),%xmm5
test   %r13,%r13
jne    15c1 <itrtb+0x4a1>
movaps %xmm5,%xmm6
andps  %xmm14,%xmm6
ucomiss %xmm2,%xmm6
ja     15a2 <itrtb+0x482>
test   %r13,%r13
je     1580 <itrtb+0x460>
mov    0x68(%rsp),%rdx
movss  0x4(%rdx,%rcx,4),%xmm6
ucomiss %xmm11,%xmm6
jne    1580 <itrtb+0x460>
jnp    15a2 <itrtb+0x482>
jmp    1580 <itrtb+0x460>
nopl   0x0(%rax,%rax,1)
test   %eax,%eax
jle    192a <itrtb+0x80a>
test   %ebp,%ebp
jle    191b <itrtb+0x7fb>
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
movaps %xmm3,%xmm6
shufps $0x55,%xmm3,%xmm6
mulss  %xmm5,%xmm6
movaps %xmm4,%xmm9
mulss  %xmm10,%xmm9
subss  %xmm6,%xmm9
mulss  %xmm5,%xmm3
movaps %xmm4,%xmm6
mulss  %xmm4,%xmm6
subss  %xmm3,%xmm6
divss  %xmm6,%xmm9
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm10
divss  %xmm5,%xmm10
cmp    $0x8,%r10
setb   %al
movaps %xmm1,%xmm8
mulss  0x18(%rsp),%xmm8
or     0x7(%rsp),%al
je     165a <itrtb+0x53a>
mov    $0x1,%eax
mov    $0x1,%edx
jmp    172a <itrtb+0x60a>
movaps %xmm9,%xmm11
shufps $0x0,%xmm9,%xmm11
movaps %xmm10,%xmm12
shufps $0x0,%xmm10,%xmm12
movaps %xmm8,%xmm3
shufps $0x0,%xmm8,%xmm3
xor    %eax,%eax
movaps 0x992(%rip),%xmm5
movaps %xmm5,%xmm6
mov    0x30(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movups (%r12,%rax,4),%xmm2
movups 0x10(%r12,%rax,4),%xmm0
mulps  %xmm11,%xmm2
addps  %xmm12,%xmm2
mulps  %xmm11,%xmm0
addps  %xmm12,%xmm0
movups (%rbx,%rax,4),%xmm4
movups 0x10(%rbx,%rax,4),%xmm7
subps  %xmm2,%xmm4
subps  %xmm0,%xmm7
movups %xmm4,(%rbx,%rax,4)
movups %xmm7,0x10(%rbx,%rax,4)
andps  %xmm14,%xmm2
andps  %xmm14,%xmm0
movaps %xmm3,%xmm4
cmpnltps %xmm2,%xmm4
andps  %xmm4,%xmm6
movaps %xmm3,%xmm2
cmpnltps %xmm0,%xmm2
andps  %xmm2,%xmm5
add    $0x8,%rax
cmp    %rax,%rcx
jne    1690 <itrtb+0x570>
movaps %xmm6,%xmm0
movdqa 0x91d(%rip),%xmm2
pcmpeqd %xmm2,%xmm0
andps  %xmm0,%xmm5
andnps %xmm6,%xmm0
orps   %xmm5,%xmm0
pcmpeqd %xmm2,%xmm0
movmskps %xmm0,%edx
xor    %eax,%eax
cmp    $0xf,%edx
sete   %al
mov    0x58(%rsp),%rdx
cmp    %rcx,%r10
xorps  %xmm11,%xmm11
movss  0x908(%rip),%xmm12
je     17d0 <itrtb+0x6b0>
test   $0x1,%r9b
jne    1763 <itrtb+0x643>
movss  -0x4(%r12,%rdx,4),%xmm0
mulss  %xmm9,%xmm0
addss  %xmm10,%xmm0
movss  -0x4(%rbx,%rdx,4),%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbx,%rdx,4)
andps  %xmm14,%xmm0
ucomiss %xmm8,%xmm0
cmova  %r8d,%eax
lea    0x1(%rdx),%rcx
jmp    1766 <itrtb+0x646>
mov    %rdx,%rcx
not    %rdx
cmp    0x60(%rsp),%rdx
je     17d0 <itrtb+0x6b0>
movss  -0x4(%r12,%rcx,4),%xmm0
mulss  %xmm9,%xmm0
addss  %xmm10,%xmm0
movss  -0x4(%rbx,%rcx,4),%xmm2
movss  (%rbx,%rcx,4),%xmm3
subss  %xmm0,%xmm2
movss  %xmm2,-0x4(%rbx,%rcx,4)
andps  %xmm14,%xmm0
ucomiss %xmm8,%xmm0
movss  (%r12,%rcx,4),%xmm0
mulss  %xmm9,%xmm0
addss  %xmm10,%xmm0
cmova  %r8d,%eax
subss  %xmm0,%xmm3
andps  %xmm14,%xmm0
ucomiss %xmm8,%xmm0
cmova  %r8d,%eax
movss  %xmm3,(%rbx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1770 <itrtb+0x650>
test   %eax,%eax
je     13c6 <itrtb+0x2a6>
jmp    17fc <itrtb+0x6dc>
mov    0x40(%rsp),%rcx
mov    (%rcx),%eax
cmpq   $0x0,0x38(%rsp)
je     17f0 <itrtb+0x6d0>
add    $0x1f40,%eax
jmp    17f5 <itrtb+0x6d5>
add    $0x1b58,%eax
mov    0x10(%rsp),%r9
mov    %eax,(%rcx)
test   %ebp,%ebp
jle    191b <itrtb+0x7fb>
movaps %xmm13,%xmm0
divss  0x8(%rsp),%xmm0
divss  0xc(%rsp),%xmm13
mov    $0x1,%eax
cmp    $0x8,%r10
jb     1896 <itrtb+0x776>
cmp    %rbx,0x50(%rsp)
jbe    182e <itrtb+0x70e>
cmp    %r12,0x48(%rsp)
ja     1896 <itrtb+0x776>
mov    0x30(%rsp),%rdx
lea    0x1(%rdx),%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
movaps %xmm13,%xmm2
shufps $0x0,%xmm13,%xmm2
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rbx,%rcx,4),%xmm3
movups 0x10(%rbx,%rcx,4),%xmm4
mulps  %xmm1,%xmm3
mulps  %xmm1,%xmm4
movups %xmm3,(%rbx,%rcx,4)
movups %xmm4,0x10(%rbx,%rcx,4)
movups (%r12,%rcx,4),%xmm3
movups 0x10(%r12,%rcx,4),%xmm4
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm4
movups %xmm3,(%r12,%rcx,4)
movups %xmm4,0x10(%r12,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1850 <itrtb+0x730>
cmp    %rdx,%r10
je     191b <itrtb+0x7fb>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r9b
jne    18c9 <itrtb+0x7a9>
movss  -0x4(%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rbx,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm1
mulss  %xmm13,%xmm1
movss  %xmm1,-0x4(%r12,%rax,4)
add    $0x1,%rax
add    %r9,%rcx
je     191b <itrtb+0x7fb>
xchg   %ax,%ax
movss  -0x4(%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rbx,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm1
mulss  %xmm13,%xmm1
movss  %xmm1,-0x4(%r12,%rax,4)
movss  (%rbx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  (%r12,%rax,4),%xmm1
mulss  %xmm13,%xmm1
movss  %xmm1,(%r12,%rax,4)
add    $0x2,%rax
cmp    %rax,%r9
jne    18d0 <itrtb+0x7b0>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x40(%rsp),%rcx
mov    (%rcx),%eax
test   %r13,%r13
je     1940 <itrtb+0x820>
add    $0x1f40,%eax
jmp    17fa <itrtb+0x6da>
add    $0x1b58,%eax
jmp    17fa <itrtb+0x6da>

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

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