#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*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
void do_ffir(const float *buf, int in_samps, float *bufo, int *out_samps,
             int idx, int ncoef, float *fc, int invert, int skip, int init) {
  register float *dp1, *dp2, sum, integral;
  register const float *dp3;
  static float *co = NULL, *mem = NULL;
  static float state[1000];
  static int fsize = 0, resid = 0;
  register int i, j, k, l;
  register float *sp;
  register const float *buf1;
  buf1 = buf;
  if (ncoef > fsize) {
    if (co)
      free(co);
    if (mem)
      free(mem);
    fsize = 0;
    i = (ncoef + 1) * 2;
    if (!((co = (float *)malloc(sizeof(float) * i)) &&
          (mem = (float *)malloc(sizeof(float) * i)))) {
      fprintf(stderr, "allocation problems in do_fir()\n");
      exit(-1);
    }
    fsize = ncoef;
  }
  for (i = ncoef, dp1 = mem + ncoef - 1; i-- > 0;)
    *dp1++ = *buf++;
  if (init & 1) {
    for (i = ncoef - 1, dp3 = fc + ncoef - 1, dp2 = co,
        dp1 = co + ((ncoef - 1) * 2), integral = 0.0;
         i-- > 0;)
      if (!invert)
        *dp1-- = *dp2++ = *dp3--;
      else {
        integral += (sum = *dp3--);
        *dp1-- = *dp2++ = -sum;
      }
    if (!invert)
      *dp1 = *dp3;
    else {
      integral *= 2;
      integral += *dp3;
      *dp1 = integral - *dp3;
    }
    for (i = ncoef - 1, dp1 = mem; i-- > 0;)
      *dp1++ = 0;
  } else
    for (i = ncoef - 1, dp1 = mem, sp = state; i-- > 0;)
      *dp1++ = *sp++;
  i = in_samps;
  resid = 0;
  k = (ncoef << 1) - 1;
  if (skip <= 1) {
  } else {
    for (l = 0; l < *out_samps; l++) {
      for (j = k - skip, dp1 = mem, dp2 = co, dp3 = mem + skip, sum = 0.0;
           j-- > 0; *dp1++ = *dp3++)
        sum += *dp2++ * *dp1;
      for (j = skip; j-- > 0; *dp1++ = *buf++)
        sum += *dp2++ * *dp1;
      *bufo++ = (sum < 0.0) ? sum - 0.5 : sum + 0.5;
    }
    if (init & 2) {
      resid = in_samps - *out_samps * skip;
      for (l = resid / skip; l-- > 0;) {
        for (j = k - skip, dp1 = mem, dp2 = co, dp3 = mem + skip, sum = 0.0;
             j-- > 0; *dp1++ = *dp3++)
          sum += *dp2++ * *dp1;
        for (j = skip; j-- > 0; *dp1++ = 0.0)
          sum += *dp2++ * *dp1;
        *bufo++ = (sum < 0.0) ? sum - 0.5 : sum + 0.5;
        (*out_samps)++;
      }
    } else
      for (dp3 = buf1 + idx - ncoef + 1, l = ncoef - 1, sp = state; l-- > 0;)
        *sp++ = *dp3++;
  }
}


x86 assembly (clang, -O0):
<do_ffir>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x28(%rbp),%eax
cmp    0x3e80(%rip),%eax
jle    1238 <do_ffir+0xf8>
cmpq   $0x0,0x2ec2(%rip)
je     11a0 <do_ffir+0x60>
mov    0x2eb5(%rip),%rdi
call   1030 <free@plt>
cmpq   $0x0,0x2eb0(%rip)
je     11ba <do_ffir+0x7a>
mov    0x2ea3(%rip),%rdi
call   1030 <free@plt>
movl   $0x0,0x3e3c(%rip)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movslq -0x4c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2e6a(%rip)
cmp    $0x0,%rax
je     1210 <do_ffir+0xd0>
movslq -0x4c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2e52(%rip)
cmp    $0x0,%rax
jne    122f <do_ffir+0xef>
mov    0x2dc9(%rip),%rax
mov    (%rax),%edi
lea    0xdf0(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>
mov    -0x28(%rbp),%eax
mov    %eax,0x3dc8(%rip)
mov    -0x28(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    0x2e13(%rip),%rax
movslq -0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x4c(%rbp)
cmp    $0x0,%eax
jle    1297 <do_ffir+0x157>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    1258 <do_ffir+0x118>
mov    0x28(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1452 <do_ffir+0x312>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x48(%rbp)
mov    0x2d83(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0x2d78(%rip),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x4c(%rbp)
cmp    $0x0,%eax
jle    13b2 <do_ffir+0x272>
cmpl   $0x0,0x18(%rbp)
jne    1353 <do_ffir+0x213>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    13ad <do_ffir+0x26d>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    12f7 <do_ffir+0x1b7>
cmpl   $0x0,0x18(%rbp)
jne    13d1 <do_ffir+0x291>
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
jmp    140a <do_ffir+0x2ca>
movss  0xc27(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
mov    -0x48(%rbp),%rax
subss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x2c3e(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x4c(%rbp)
cmp    $0x0,%eax
jle    144d <do_ffir+0x30d>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    141e <do_ffir+0x2de>
jmp    14b5 <do_ffir+0x375>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    0x2bf6(%rip),%rax
mov    %rax,-0x30(%rbp)
lea    0x2bf3(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x4c(%rbp)
cmp    $0x0,%eax
jle    14b0 <do_ffir+0x370>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    1471 <do_ffir+0x331>
jmp    14b5 <do_ffir+0x375>
mov    -0xc(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,0x3b3f(%rip)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x1,0x20(%rbp)
jg     14e0 <do_ffir+0x3a0>
jmp    18de <do_ffir+0x79e>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    168a <do_ffir+0x54a>
mov    -0x54(%rbp),%eax
sub    0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    0x2b52(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0x2b3f(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0x2b3c(%rip),%rax
movslq 0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp)
cmp    $0x0,%eax
jle    159f <do_ffir+0x45f>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    1533 <do_ffir+0x3f3>
mov    0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp)
cmp    $0x0,%eax
jle    1611 <do_ffir+0x4d1>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    15a5 <do_ffir+0x465>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1646 <do_ffir+0x506>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9d0(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1660 <do_ffir+0x520>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9b1(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14e7 <do_ffir+0x3a7>
mov    0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     185a <do_ffir+0x71a>
mov    -0xc(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
imul   0x20(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,0x3956(%rip)
mov    0x3950(%rip),%eax
cltd
idivl  0x20(%rbp)
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x58(%rbp)
cmp    $0x0,%eax
jle    1855 <do_ffir+0x715>
mov    -0x54(%rbp),%eax
sub    0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    0x2979(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0x2966(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0x2963(%rip),%rax
movslq 0x20(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp)
cmp    $0x0,%eax
jle    1778 <do_ffir+0x638>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movss  %xmm0,(%rax)
jmp    170c <do_ffir+0x5cc>
mov    0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp)
cmp    $0x0,%eax
jle    17da <do_ffir+0x69a>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    177e <do_ffir+0x63e>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    180f <do_ffir+0x6cf>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x807(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1829 <do_ffir+0x6e9>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x7e8(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    16bb <do_ffir+0x57b>
jmp    18d9 <do_ffir+0x799>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
lea    0x27cf(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x58(%rbp)
cmp    $0x0,%eax
jle    18d4 <do_ffir+0x794>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
movss  %xmm0,(%rax)
jmp    1895 <do_ffir+0x755>
jmp    18d9 <do_ffir+0x799>
jmp    18de <do_ffir+0x79e>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_ffir>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9d,%r14d
mov    %r8d,%r13d
mov    %rcx,0x38(%rsp)
mov    %rdx,%rbx
mov    %esi,0x8(%rsp)
mov    %rdi,%r15
cmp    %r9d,0x3e96(%rip)
mov    %r8d,0x34(%rsp)
jge    11ef <do_ffir+0x9f>
mov    0x2ed8(%rip),%rdi
test   %rdi,%rdi
je     1192 <do_ffir+0x42>
call   1030 <free@plt>
mov    0x2ecf(%rip),%rdi
test   %rdi,%rdi
je     11a3 <do_ffir+0x53>
call   1030 <free@plt>
movl   $0x0,0x3e63(%rip)
lea    0x8(,%r14,8),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x2e9d(%rip)
test   %rax,%rax
je     1ca6 <do_ffir+0xb56>
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x2e8e(%rip)
test   %rax,%rax
je     1ca6 <do_ffir+0xb56>
mov    %rax,%r12
mov    %r14d,0x3e23(%rip)
jmp    11f6 <do_ffir+0xa6>
mov    0x2e72(%rip),%r12
mov    0xb8(%rsp),%r9d
movslq %r14d,%r10
mov    %r15,%r13
test   %r14d,%r14d
jle    126a <do_ffir+0x11a>
lea    (%r12,%r10,4),%rax
add    $0xfffffffffffffffc,%rax
lea    -0x1(%r14),%ecx
cmp    $0x7,%ecx
jb     123c <do_ffir+0xec>
lea    (%r15,%rcx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    1333 <do_ffir+0x1e3>
lea    (%r10,%rcx,1),%rdx
lea    (%r12,%rdx,4),%rdx
cmp    %r15,%rdx
jbe    1333 <do_ffir+0x1e3>
mov    %r15,%r13
mov    %r14d,%ecx
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%r13),%xmm0
add    $0x4,%r13
movss  %xmm0,(%rax)
add    $0x4,%rax
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
ja     1250 <do_ffir+0x100>
mov    0xb0(%rsp),%r11d
test   $0x1,%r9b
jne    12a8 <do_ffir+0x158>
cmp    $0x2,%r14d
jl     1666 <do_ffir+0x516>
xor    %ecx,%ecx
mov    %r14d,%eax
sub    $0x2,%eax
cmovb  %ecx,%eax
cmp    $0x7,%eax
jae    1363 <do_ffir+0x213>
lea    0x2dd3(%rip),%rdx
mov    %r14d,%esi
mov    %r12,%rcx
jmp    163f <do_ffir+0x4ef>
mov    0xa8(%rsp),%r8d
mov    0xa0(%rsp),%rcx
mov    0x2da1(%rip),%rsi
lea    (%r14,%r14,1),%eax
add    $0xfffffffe,%eax
cltq
lea    (%rsi,%rax,4),%rax
lea    (%rcx,%r10,4),%rcx
add    $0xfffffffffffffffc,%rcx
xorps  %xmm0,%xmm0
cmp    $0x2,%r14d
jl     1466 <do_ffir+0x316>
lea    -0x2(%r14),%ebp
test   $0x1,%r14b
jne    13d5 <do_ffir+0x285>
movss  (%rcx),%xmm2
movaps %xmm2,%xmm1
test   %r8d,%r8d
je     1305 <do_ffir+0x1b5>
movaps 0xcfe(%rip),%xmm1
xorps  %xmm2,%xmm1
xorps  %xmm0,%xmm0
je     130e <do_ffir+0x1be>
addss  %xmm2,%xmm0
movss  %xmm1,(%rsi)
add    $0x4,%rsi
movss  %xmm1,(%rax)
add    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rcx
lea    -0x3(%r14),%r9d
test   %ebp,%ebp
jne    13e3 <do_ffir+0x293>
jmp    1466 <do_ffir+0x316>
add    $0x1,%rcx
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rdx
jae    14b6 <do_ffir+0x366>
xor    %ebp,%ebp
jmp    1530 <do_ffir+0x3e0>
mov    %r14d,%esi
sub    $0x2,%esi
cmovb  %ecx,%esi
lea    0x2cfd(%rip),%rdx
lea    (%rdx,%rsi,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%r12
jae    139e <do_ffir+0x24e>
lea    (%r12,%rsi,4),%rdi
add    $0x4,%rdi
lea    0x2ce1(%rip),%rbp
mov    %r14d,%esi
mov    %r12,%rcx
cmp    %rbp,%rdi
ja     163f <do_ffir+0x4ef>
add    $0x1,%rax
mov    %rax,%r8
and    $0xfffffffffffffff8,%r8
lea    0x2cc0(%rip),%rdx
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rcx
jae    1587 <do_ffir+0x437>
xor    %ebp,%ebp
jmp    15f0 <do_ffir+0x4a0>
xorps  %xmm0,%xmm0
mov    %ebp,%r9d
test   %ebp,%ebp
je     1466 <do_ffir+0x316>
add    $0x2,%r9d
xor    %ebp,%ebp
movss  0xc2f(%rip),%xmm1
xor    %edx,%edx
jmp    142b <do_ffir+0x2db>
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm3,%xmm4
xorps  %xmm1,%xmm4
addss  %xmm2,%xmm0
addss  %xmm3,%xmm0
movss  %xmm4,0x4(%rsi,%rbp,1)
movss  %xmm4,-0x4(%rax,%rdx,4)
add    $0xfffffffffffffffe,%rdx
lea    (%r9,%rdx,1),%edi
add    $0x8,%rbp
cmp    $0x1,%edi
jle    1460 <do_ffir+0x310>
movss  (%rcx,%rdx,4),%xmm2
test   %r8d,%r8d
je     1440 <do_ffir+0x2f0>
movaps %xmm2,%xmm3
xorps  %xmm1,%xmm3
jmp    1446 <do_ffir+0x2f6>
nopl   (%rax)
movaps %xmm2,%xmm3
movaps %xmm1,%xmm2
movss  %xmm3,(%rsi,%rbp,1)
movss  %xmm3,(%rax,%rdx,4)
movss  -0x4(%rcx,%rdx,4),%xmm3
jne    1400 <do_ffir+0x2b0>
movaps %xmm3,%xmm4
movaps %xmm1,%xmm3
jmp    1406 <do_ffir+0x2b6>
sub    %rbp,%rcx
sub    %rbp,%rax
test   %r8d,%r8d
je     147d <do_ffir+0x32d>
addss  %xmm0,%xmm0
movss  (%rcx),%xmm1
addss  %xmm1,%xmm0
subss  %xmm1,%xmm0
jmp    1481 <do_ffir+0x331>
movss  (%rcx),%xmm0
movss  %xmm0,(%rax)
cmp    $0x2,%r14d
jl     1666 <do_ffir+0x516>
lea    -0x1(%r14),%eax
mov    %eax,%edx
shl    $0x2,%rdx
mov    %r12,%rdi
xor    %esi,%esi
mov    %r10,%rbp
call   1040 <memset@plt>
mov    %rbp,%r10
mov    0xb0(%rsp),%r11d
jmp    1666 <do_ffir+0x516>
and    $0xfffffffffffffffc,%rdi
lea    (%r12,%r10,4),%rdx
add    $0x6c,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r15,%rbp,4),%xmm0
movups 0x10(%r15,%rbp,4),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,4)
movups %xmm1,-0x60(%rdx,%rbp,4)
movups 0x20(%r15,%rbp,4),%xmm0
movups 0x30(%r15,%rbp,4),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,4)
movups %xmm1,-0x40(%rdx,%rbp,4)
movups 0x40(%r15,%rbp,4),%xmm0
movups 0x50(%r15,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,4)
movups %xmm1,-0x20(%rdx,%rbp,4)
movups 0x60(%r15,%rbp,4),%xmm0
movups 0x70(%r15,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,4)
movups %xmm1,(%rdx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    14d0 <do_ffir+0x380>
test   %rsi,%rsi
je     156b <do_ffir+0x41b>
lea    (%r10,%rbp,1),%rdx
lea    (%r12,%rdx,4),%rdx
add    $0xc,%rdx
lea    (%r15,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nop
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1550 <do_ffir+0x400>
lea    (%r15,%r8,4),%r13
cmp    %r8,%rcx
je     126a <do_ffir+0x11a>
mov    %r14d,%ecx
sub    %r8d,%ecx
lea    (%rax,%r8,4),%rax
jmp    1242 <do_ffir+0xf2>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopl   (%rax)
movaps (%rdx,%rbp,4),%xmm0
movaps 0x10(%rdx,%rbp,4),%xmm1
movups %xmm0,(%r12,%rbp,4)
movups %xmm1,0x10(%r12,%rbp,4)
movaps 0x20(%rdx,%rbp,4),%xmm0
movaps 0x30(%rdx,%rbp,4),%xmm1
movups %xmm0,0x20(%r12,%rbp,4)
movups %xmm1,0x30(%r12,%rbp,4)
movaps 0x40(%rdx,%rbp,4),%xmm0
movaps 0x50(%rdx,%rbp,4),%xmm1
movups %xmm0,0x40(%r12,%rbp,4)
movups %xmm1,0x50(%r12,%rbp,4)
movaps 0x60(%rdx,%rbp,4),%xmm0
movaps 0x70(%rdx,%rbp,4),%xmm1
movups %xmm0,0x60(%r12,%rbp,4)
movups %xmm1,0x70(%r12,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1590 <do_ffir+0x440>
test   %rsi,%rsi
je     162c <do_ffir+0x4dc>
lea    (%r12,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rdx,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movaps -0x10(%rbp,%rcx,1),%xmm0
movaps 0x0(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    1610 <do_ffir+0x4c0>
cmp    %r8,%rax
je     1666 <do_ffir+0x516>
lea    (%rdx,%r8,4),%rdx
mov    %r14d,%esi
sub    %r8d,%esi
lea    (%r12,%r8,4),%rcx
add    $0x1,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rax,1),%xmm0
movss  %xmm0,(%rcx,%rax,1)
add    $0x4,%rax
add    $0xffffffff,%esi
cmp    $0x2,%esi
ja     1650 <do_ffir+0x500>
cmp    $0x2,%r11d
jl     1c97 <do_ffir+0xb47>
mov    %r15,0x50(%rsp)
lea    (%r14,%r14,1),%ecx
mov    %r14,0x58(%rsp)
lea    (%r14,%r14,1),%edx
add    $0xffffffff,%edx
mov    0x38(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x14(%rsp)
test   %eax,%eax
mov    %r10,0x60(%rsp)
mov    %rcx,0x48(%rsp)
mov    %rdx,0x40(%rsp)
jle    188c <do_ffir+0x73c>
mov    %edx,%eax
sub    %r11d,%eax
mov    0x29ad(%rip),%r10
mov    %r11d,%edx
lea    (%r12,%rdx,4),%rsi
mov    %rsi,0x18(%rsp)
add    $0xfffffffe,%ecx
mov    %ecx,0x20(%rsp)
lea    -0x1(%rax),%ecx
mov    %ecx,0xc(%rsp)
lea    0x4(%r10),%rdi
lea    0x4(%r12,%rdx,4),%rcx
mov    %rcx,0x28(%rsp)
lea    0x4(%r12),%r9
lea    -0x1(%r11),%ecx
mov    %ecx,0x10(%rsp)
xor    %r8d,%r8d
xorps  %xmm0,%xmm0
jmp    1723 <do_ffir+0x5d3>
xor    %edx,%edx
ucomiss %xmm1,%xmm0
seta   %dl
cvtss2sd %xmm1,%xmm1
lea    0x90d(%rip),%rcx
addsd  (%rcx,%rdx,8),%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx)
add    $0x4,%rbx
add    $0x1,%r8d
cmp    0x14(%rsp),%r8d
je     188c <do_ffir+0x73c>
xorps  %xmm1,%xmm1
mov    %r10,%rdx
mov    %r12,%r15
test   %eax,%eax
jle    17d9 <do_ffir+0x689>
xorps  %xmm1,%xmm1
mov    %eax,%ebp
mov    0x18(%rsp),%rsi
mov    %r10,%r11
mov    %r12,%r14
test   $0x1,%al
je     1775 <do_ffir+0x625>
movss  (%r10),%xmm1
mulss  (%r12),%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rsp),%rcx
movss  (%rcx),%xmm2
movss  %xmm2,(%r12)
mov    0xc(%rsp),%ebp
mov    0x28(%rsp),%rsi
mov    %rdi,%r11
mov    %r9,%r14
mov    %rdi,%rdx
mov    %r9,%r15
mov    0xb0(%rsp),%ecx
cmp    %ecx,0x20(%rsp)
je     17d9 <do_ffir+0x689>
add    $0xffffffff,%ebp
nopl   0x0(%rax,%rax,1)
movss  (%r11),%xmm2
mulss  (%r14),%xmm2
addss  %xmm1,%xmm2
movss  (%rsi),%xmm1
movss  %xmm1,(%r14)
movss  0x4(%r11),%xmm1
add    $0x8,%r11
mulss  0x4(%r14),%xmm1
addss  %xmm2,%xmm1
movss  0x4(%rsi),%xmm2
movss  %xmm2,0x4(%r14)
add    $0x8,%r14
add    $0x8,%rsi
add    $0xfffffffe,%ebp
jb     1790 <do_ffir+0x640>
mov    %r11,%rdx
mov    %r14,%r15
mov    0xb0(%rsp),%r11d
test   $0x1,%r11b
jne    1800 <do_ffir+0x6b0>
mov    %r11d,%esi
cmp    $0x1,%r11d
je     16f0 <do_ffir+0x5a0>
jmp    1832 <do_ffir+0x6e2>
cs nopw 0x0(%rax,%rax,1)
movss  (%rdx),%xmm2
add    $0x4,%rdx
mulss  (%r15),%xmm2
addss  %xmm2,%xmm1
movss  0x0(%r13),%xmm2
add    $0x4,%r13
movss  %xmm2,(%r15)
add    $0x4,%r15
mov    0x10(%rsp),%esi
cmp    $0x1,%r11d
je     16f0 <do_ffir+0x5a0>
add    $0xffffffff,%esi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rbp,1),%xmm2
mulss  (%r15,%rbp,1),%xmm2
addss  %xmm1,%xmm2
movss  0x0(%r13,%rbp,1),%xmm1
movss  %xmm1,(%r15,%rbp,1)
movss  0x4(%rdx,%rbp,1),%xmm1
mulss  0x4(%r15,%rbp,1),%xmm1
addss  %xmm2,%xmm1
movss  0x4(%r13,%rbp,1),%xmm2
movss  %xmm2,0x4(%r15,%rbp,1)
add    $0x8,%rbp
add    $0xfffffffe,%esi
jb     1840 <do_ffir+0x6f0>
add    %rbp,%r13
jmp    16f0 <do_ffir+0x5a0>
mov    0xb8(%rsp),%eax
test   $0x2,%al
mov    0x60(%rsp),%rdi
jne    18e6 <do_ffir+0x796>
mov    0x58(%rsp),%rsi
cmp    $0x2,%esi
mov    0x50(%rsp),%r11
jl     1c97 <do_ffir+0xb47>
movslq 0x34(%rsp),%r9
lea    (%r11,%r9,4),%rax
lea    0x0(,%rdi,4),%rcx
sub    %rcx,%rax
xor    %edx,%edx
mov    %esi,%r10d
sub    $0x2,%r10d
cmovb  %edx,%r10d
cmp    $0x7,%r10d
jae    1b32 <do_ffir+0x9e2>
lea    0x278f(%rip),%rdi
jmp    1c6c <do_ffir+0xb1c>
mov    0x14(%rsp),%ecx
imul   %r11d,%ecx
mov    0x8(%rsp),%eax
sub    %ecx,%eax
cltd
idiv   %r11d
test   %eax,%eax
jle    1c97 <do_ffir+0xb47>
mov    0x40(%rsp),%r10
sub    %r11d,%r10d
mov    0x2751(%rip),%r14
movslq %r11d,%rcx
lea    (%r12,%rcx,4),%rdx
mov    %rdx,0x18(%rsp)
mov    0x48(%rsp),%r9
add    $0xfffffffe,%r9d
lea    -0x1(%r11),%edx
mov    %edx,0x10(%rsp)
lea    -0x1(%r10),%edx
mov    %edx,0xc(%rsp)
lea    0x4(%r14),%rdx
mov    %rdx,0x20(%rsp)
lea    0x4(%r12,%rcx,4),%rcx
mov    %rcx,0x28(%rsp)
lea    0x4(%r12),%r13
mov    %r11d,%esi
and    $0x3,%esi
xorps  %xmm0,%xmm0
mov    %eax,0x8(%rsp)
jmp    1992 <do_ffir+0x842>
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
ucomiss %xmm1,%xmm0
seta   %cl
cvtss2sd %xmm1,%xmm1
lea    0x69d(%rip),%rdx
addsd  (%rdx,%rcx,8),%xmm1
cvtsd2ss %xmm1,%xmm1
lea    -0x1(%rax),%ecx
movss  %xmm1,(%rbx)
add    $0x4,%rbx
cmp    $0x1,%eax
mov    %ecx,%eax
jle    1b1e <do_ffir+0x9ce>
mov    %r12,%rdi
mov    %r14,%rdx
xorps  %xmm1,%xmm1
test   %r10d,%r10d
jle    1a57 <do_ffir+0x907>
mov    %r10,%rdx
mov    %r9,%r8
xorps  %xmm1,%xmm1
mov    %edx,%r15d
mov    0x18(%rsp),%r11
mov    %r14,%rbp
mov    %r12,%rcx
test   $0x1,%dl
je     19f0 <do_ffir+0x8a0>
movss  (%r14),%xmm1
mulss  (%r12),%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rsp),%rcx
movss  (%rcx),%xmm2
movss  %xmm2,(%r12)
mov    0xc(%rsp),%r15d
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rbp
mov    %r13,%rcx
mov    %r13,%rdi
mov    0x20(%rsp),%rdx
mov    0xb0(%rsp),%r9d
cmp    %r9d,%r8d
mov    %r8,%r9
je     1a57 <do_ffir+0x907>
add    $0xffffffff,%r15d
nopl   0x0(%rax)
movss  0x0(%rbp),%xmm2
mulss  (%rcx),%xmm2
addss  %xmm1,%xmm2
movss  (%r11),%xmm1
movss  %xmm1,(%rcx)
movss  0x4(%rbp),%xmm1
add    $0x8,%rbp
mulss  0x4(%rcx),%xmm1
addss  %xmm2,%xmm1
movss  0x4(%r11),%xmm2
movss  %xmm2,0x4(%rcx)
add    $0x8,%rcx
add    $0x8,%r11
add    $0xfffffffe,%r15d
jb     1a10 <do_ffir+0x8c0>
mov    %rcx,%rdi
mov    %rbp,%rdx
mov    0xb0(%rsp),%ebp
test   %ebp,%ebp
jle    1960 <do_ffir+0x810>
test   %esi,%esi
je     1aa0 <do_ffir+0x950>
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx),%xmm2
add    $0x4,%rdx
mulss  (%rdi),%xmm2
addss  %xmm2,%xmm1
movl   $0x0,(%rdi)
add    $0x4,%rdi
add    $0x1,%ecx
cmp    %ecx,%esi
jne    1a70 <do_ffir+0x920>
sub    %ecx,%ebp
cmpl   $0x3,0x10(%rsp)
jb     1960 <do_ffir+0x810>
jmp    1aab <do_ffir+0x95b>
cmpl   $0x3,0x10(%rsp)
jb     1960 <do_ffir+0x810>
add    $0xffffffff,%ebp
xor    %ecx,%ecx
movss  (%rdx,%rcx,1),%xmm2
mulss  (%rdi,%rcx,1),%xmm2
movl   $0x0,(%rdi,%rcx,1)
movss  0x4(%rdx,%rcx,1),%xmm3
mulss  0x4(%rdi,%rcx,1),%xmm3
addss  %xmm1,%xmm2
addss  %xmm2,%xmm3
movl   $0x0,0x4(%rdi,%rcx,1)
movss  0x8(%rdx,%rcx,1),%xmm2
mulss  0x8(%rdi,%rcx,1),%xmm2
addss  %xmm3,%xmm2
movl   $0x0,0x8(%rdi,%rcx,1)
movss  0xc(%rdx,%rcx,1),%xmm1
mulss  0xc(%rdi,%rcx,1),%xmm1
addss  %xmm2,%xmm1
movl   $0x0,0xc(%rdi,%rcx,1)
add    $0xfffffffc,%ebp
add    $0x10,%rcx
cmp    $0xfffffffe,%ebp
jb     1ab0 <do_ffir+0x960>
jmp    1960 <do_ffir+0x810>
mov    0x14(%rsp),%ecx
add    0x8(%rsp),%ecx
mov    0x38(%rsp),%rax
mov    %ecx,(%rax)
jmp    1c97 <do_ffir+0xb47>
mov    %rdi,%rbx
mov    %esi,%ecx
sub    $0x2,%ecx
cmovb  %edx,%ecx
lea    0x252c(%rip),%rdi
mov    %r9,%rdx
sub    %rbx,%rdx
lea    (%r9,%rcx,1),%rbp
mov    %rbx,%r14
sub    %rbx,%rbp
lea    (%r11,%rbp,4),%rbp
add    $0x8,%rbp
cmp    %rdi,%rbp
jbe    1b7a <do_ffir+0xa2a>
lea    (%rdi,%rcx,4),%rcx
add    $0x4,%rcx
lea    (%r11,%rdx,4),%rbp
add    $0x4,%rbp
cmp    %rcx,%rbp
jb     1c6c <do_ffir+0xb1c>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    0x24e4(%rip),%rdi
lea    -0x8(%r8),%rbx
mov    %rbx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%ecx
and    $0x3,%ecx
cmp    $0x18,%rbx
jae    1baa <do_ffir+0xa5a>
xor    %ebx,%ebx
jmp    1c18 <do_ffir+0xac8>
and    $0xfffffffffffffffc,%rbp
lea    (%r11,%rdx,4),%rdx
add    $0x74,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rdx,%rbx,4),%xmm0
movups -0x60(%rdx,%rbx,4),%xmm1
movaps %xmm0,(%rdi,%rbx,4)
movaps %xmm1,0x10(%rdi,%rbx,4)
movups -0x50(%rdx,%rbx,4),%xmm0
movups -0x40(%rdx,%rbx,4),%xmm1
movaps %xmm0,0x20(%rdi,%rbx,4)
movaps %xmm1,0x30(%rdi,%rbx,4)
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movaps %xmm0,0x40(%rdi,%rbx,4)
movaps %xmm1,0x50(%rdi,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movaps %xmm0,0x60(%rdi,%rbx,4)
movaps %xmm1,0x70(%rdi,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rbp
jne    1bc0 <do_ffir+0xa70>
test   %rcx,%rcx
je     1c5c <do_ffir+0xb0c>
add    %rbx,%r9
sub    %r14,%r9
lea    (%r11,%r9,4),%rdx
add    $0x14,%rdx
lea    (%rdi,%rbx,4),%rbp
add    $0x10,%rbp
shl    $0x5,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movaps %xmm0,-0x10(%rbp,%rbx,1)
movaps %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rcx
jne    1c40 <do_ffir+0xaf0>
cmp    %r8,%r10
je     1c97 <do_ffir+0xb47>
lea    (%rax,%r8,4),%rax
lea    (%rdi,%r8,4),%rdi
sub    %r8d,%esi
add    $0x1,%esi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x4(%rax,%rcx,1),%xmm0
movss  %xmm0,(%rdi,%rcx,1)
add    $0x4,%rcx
add    $0xffffffff,%esi
cmp    $0x2,%esi
ja     1c80 <do_ffir+0xb30>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2333(%rip),%rax
mov    (%rax),%edi
lea    0x36e(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>

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

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