#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 */
typedef int int32_t;

/* Variables and functions */
scalar_t__ fabsf(float);
int lfastrintf(float);
float r_sign(float, float);
void vparms(int32_t vwin[], float *inbuf, float *lpbuf, const int32_t buflim[],
            int32_t half, float *dither, int32_t *mintau, int32_t *zc,
            int32_t *lbe, int32_t *fbe, float *qs, float *rc1, float *ar_b,
            float *ar_f) {
  int32_t inbuf_offset;
  int32_t lpbuf_offset;
  int32_t vlen;
  int32_t stop;
  int32_t i;
  int32_t start;
  float r1;
  float r2;
  float e_pre;
  float ap_rms;
  float e_0;
  float oldsgn;
  float lp_rms;
  float e_b;
  float e_f;
  float r_b;
  float r_f;
  float e0ap;
  lpbuf_offset = buflim[2];
  lpbuf -= lpbuf_offset;
  inbuf_offset = buflim[0];
  inbuf -= inbuf_offset;
  lp_rms = 0.0f;
  ap_rms = 0.0f;
  e_pre = 0.0f;
  e0ap = 0.0f;
  *rc1 = 0.0f;
  e_0 = 0.0f;
  e_b = 0.0f;
  e_f = 0.0f;
  r_f = 0.0f;
  r_b = 0.0f;
  *zc = 0;
  vlen = vwin[1] - vwin[0] + 1;
  start = vwin[0] + half * vlen / 2 + 1;
  stop = start + vlen / 2 - 1;
  oldsgn = r_sign(1.0f, inbuf[start - 1] - *dither);
  for (i = start; i <= stop; i++) {
    lp_rms += fabsf(lpbuf[i]);
    ap_rms += fabsf(inbuf[i]);
    e_pre += fabsf(inbuf[i] - inbuf[i - 1]);
    r1 = inbuf[i];
    e0ap += r1 * r1;
    *rc1 += inbuf[i] * inbuf[i - 1];
    r1 = lpbuf[i];
    e_0 += r1 * r1;
    r1 = lpbuf[i - *mintau];
    e_b += r1 * r1;
    r1 = lpbuf[i + *mintau];
    e_f += r1 * r1;
    r_f += lpbuf[i] * lpbuf[i + *mintau];
    r_b += lpbuf[i] * lpbuf[i - *mintau];
    r1 = inbuf[i] + *dither;
    if (r_sign(1.0f, r1) != oldsgn) {
      ++(*zc);
      oldsgn = -oldsgn;
    }
    *dither = -(*dither);
  }
  *rc1 /= ((e0ap) >= (1.0f) ? (e0ap) : (1.0f));
  r1 = ap_rms * 2.0f;
  *qs = e_pre / ((r1) >= (1.0f) ? (r1) : (1.0f));
  *ar_b = r_b / ((e_b) >= (1.0f) ? (e_b) : (1.0f)) *
          (r_b / ((e_0) >= (1.0f) ? (e_0) : (1.0f)));
  *ar_f = r_f / ((e_f) >= (1.0f) ? (e_f) : (1.0f)) *
          (r_f / ((e_0) >= (1.0f) ? (e_0) : (1.0f)));
  r2 = (float)(*zc << 1);
  *zc = lfastrintf(r2 * (90.0f / vlen));
  r1 = lp_rms / 4 * (90.0f / vlen);
  *lbe = ((lfastrintf(r1)) <= (32767) ? (lfastrintf(r1)) : (32767));
  r1 = ap_rms / 4 * (90.0f / vlen);
  *fbe = ((lfastrintf(r1)) <= (32767) ? (lfastrintf(r1)) : (32767));
}


x86 assembly (clang, -O0):
<vparms>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%eax
add    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
add    %ecx,%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm1
movss  0xd71(%rip),%xmm0
call   1050 <r_sign@plt>
movss  %xmm0,-0x60(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1511 <vparms+0x3e1>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabsf@plt>
cvtsi2ss %rax,%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1030 <fabsf@plt>
cvtsi2ss %rax,%xmm0
addss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabsf@plt>
cvtsi2ss %rax,%xmm0
addss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x38(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%rdx
sub    (%rdx),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%rdx
add    (%rdx),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    0x10(%rbp),%rdx
sub    (%rdx),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm1
movss  0xb56(%rip),%xmm0
call   1050 <r_sign@plt>
ucomiss -0x60(%rbp),%xmm0
jne    14c4 <vparms+0x394>
jp     14c4 <vparms+0x394>
jmp    14e6 <vparms+0x3b6>
mov    0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    129f <vparms+0x16f>
movss  -0x78(%rbp),%xmm0
movss  0xae2(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     1539 <vparms+0x409>
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    154e <vparms+0x41e>
movss  0xabf(%rip),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
jmp    154e <vparms+0x41e>
movss  -0x84(%rbp),%xmm1
ff
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  0xa96(%rip),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x4c(%rbp),%xmm0
movss  0xa6e(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     15ad <vparms+0x47d>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    15c2 <vparms+0x492>
movss  0xa4b(%rip),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
jmp    15c2 <vparms+0x492>
movss  -0x88(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x68(%rbp),%xmm0
movss  0xa08(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     1613 <vparms+0x4e3>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1628 <vparms+0x4f8>
movss  0x9e5(%rip),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
jmp    1628 <vparms+0x4f8>
movss  -0x90(%rbp),%xmm0
ff
movss  -0x94(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  0x9a2(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     1679 <vparms+0x549>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    168e <vparms+0x55e>
movss  0x97f(%rip),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    168e <vparms+0x55e>
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa0(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  0x930(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     16eb <vparms+0x5bb>
movss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
jmp    1700 <vparms+0x5d0>
movss  0x90d(%rip),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
jmp    1700 <vparms+0x5d0>
movss  -0xa4(%rbp),%xmm0
ff
movss  -0xa8(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  0x8ca(%rip),%xmm1
ucomiss %xmm1,%xmm0
jb     1751 <vparms+0x621>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
jmp    1766 <vparms+0x636>
movss  0x8a7(%rip),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
jmp    1766 <vparms+0x636>
movss  -0xb0(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm2
movss  0x856(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
call   1040 <lfastrintf@plt>
mov    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
movss  -0x64(%rbp),%xmm0
movss  0x838(%rip),%xmm1
divss  %xmm1,%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm2
movss  0x823(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1040 <lfastrintf@plt>
cmp    $0x7fff,%eax
jg     181c <vparms+0x6ec>
movss  -0x4c(%rbp),%xmm0
call   1040 <lfastrintf@plt>
mov    %eax,-0xb8(%rbp)
jmp    182c <vparms+0x6fc>
mov    $0x7fff,%eax
mov    %eax,-0xb8(%rbp)
jmp    182c <vparms+0x6fc>
mov    -0xb8(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
movss  -0x58(%rbp),%xmm0
movss  0x7c7(%rip),%xmm1
divss  %xmm1,%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm2
movss  0x7b2(%rip),%xmm1
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1040 <lfastrintf@plt>
cmp    $0x7fff,%eax
jg     188d <vparms+0x75d>
movss  -0x4c(%rbp),%xmm0
call   1040 <lfastrintf@plt>
mov    %eax,-0xbc(%rbp)
jmp    189d <vparms+0x76d>
mov    $0x7fff,%eax
mov    %eax,-0xbc(%rbp)
jmp    189d <vparms+0x76d>
mov    -0xbc(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vparms>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,%r15
mov    %rsi,%rbx
mov    0x118(%rsp),%rsi
mov    0xf8(%rsp),%rdx
movslq 0x8(%rcx),%rax
mov    %rax,0x8(%rsp)
movslq (%rcx),%rax
shl    $0x2,%rax
sub    %rax,%rbx
movl   $0x0,(%rsi)
movl   $0x0,(%rdx)
mov    0x4(%rdi),%eax
movslq (%rdi),%r12
sub    %r12d,%eax
lea    0x1(%rax),%edx
imul   %edx,%r8d
mov    %r8d,%ebp
shr    $0x1f,%ebp
add    %r8d,%ebp
sar    %ebp
lea    (%r12,%rbp,1),%ecx
mov    %edx,0x24(%rsp)
shr    $0x1f,%edx
lea    (%rax,%rdx,1),%r13d
add    $0x1,%r13d
sar    %r13d
add    %ecx,%r13d
movslq %ecx,%r14
movss  (%rbx,%r14,4),%xmm1
mov    %r9,0x18(%rsp)
subss  (%r9),%xmm1
movss  0xe3b(%rip),%xmm0
call   1050 <r_sign@plt>
cmp    %r13d,%r14d
jge    1411 <vparms+0x2e1>
movaps %xmm0,0x40(%rsp)
mov    0x8(%rsp),%rax
shl    $0x2,%rax
sub    %rax,%r15
mov    %r15,0x38(%rsp)
movslq %ebp,%rax
movslq %r13d,%rcx
lea    (%r12,%rax,1),%r14
add    $0x1,%r14
neg    %rcx
mov    %rcx,0x30(%rsp)
xorps  %xmm1,%xmm1
xorps  %xmm4,%xmm4
xorps  %xmm11,%xmm11
xorps  %xmm10,%xmm10
xorps  %xmm7,%xmm7
mov    0x18(%rsp),%r15
mov    0x38(%rsp),%r12
jmp    12fb <vparms+0x1cb>
nop
movaps %xmm1,%xmm0
mov    0xf8(%rsp),%rax
addl   $0x1,(%rax)
movaps 0xddb(%rip),%xmm5
xorps  %xmm5,%xmm0
movaps %xmm0,0x40(%rsp)
movss  0x14(%rsp),%xmm11
movss  0x8(%rsp),%xmm4
mov    0x18(%rsp),%r15
movss  0x4(%rsp),%xmm10
movaps 0xa0(%rsp),%xmm7
movaps 0x90(%rsp),%xmm8
movaps 0x80(%rsp),%xmm0
mov    0x28(%rsp),%rax
movaps 0x70(%rsp),%xmm6
movaps 0x60(%rsp),%xmm3
movaps 0x50(%rsp),%xmm2
cvtsi2ss %rax,%xmm9
cvtsi2ss %r13,%xmm12
xorps  %xmm1,%xmm1
cvtsi2ss %rbp,%xmm1
addss  %xmm9,%xmm4
addss  %xmm12,%xmm11
addss  %xmm1,%xmm10
movaps %xmm0,%xmm1
unpcklps %xmm2,%xmm1
unpcklps %xmm3,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm0,%xmm7
movaps %xmm2,%xmm0
unpcklps %xmm6,%xmm0
movlhps %xmm3,%xmm2
movaps %xmm0,%xmm1
shufps $0x24,%xmm2,%xmm1
movlhps %xmm3,%xmm6
shufps $0x24,%xmm6,%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,%xmm1
addps  %xmm8,%xmm1
movss  (%r15),%xmm2
xorps  %xmm5,%xmm2
movss  %xmm2,(%r15)
mov    0x30(%rsp),%rax
add    %r14,%rax
add    $0x1,%rax
add    $0x1,%r14
cmp    $0x1,%rax
je     142d <vparms+0x2fd>
movaps %xmm7,0xa0(%rsp)
movss  %xmm10,0x4(%rsp)
movss  %xmm4,0x8(%rsp)
movss  %xmm11,0x14(%rsp)
movaps %xmm1,0x90(%rsp)
movss  (%r12,%r14,4),%xmm0
call   1030 <fabsf@plt>
mov    %rax,0x28(%rsp)
movss  (%rbx,%r14,4),%xmm0
call   1030 <fabsf@plt>
mov    %rax,%r13
movss  (%rbx,%r14,4),%xmm0
subss  -0x4(%rbx,%r14,4),%xmm0
call   1030 <fabsf@plt>
movss  (%rbx,%r14,4),%xmm1
movss  -0x4(%rbx,%r14,4),%xmm0
movaps %xmm1,0x80(%rsp)
mulss  %xmm1,%xmm0
mov    0x118(%rsp),%rcx
addss  (%rcx),%xmm0
mov    %rax,%rbp
movss  %xmm0,(%rcx)
mov    0xf0(%rsp),%rax
movslq (%rax),%rax
lea    0x0(,%rax,4),%rcx
mov    %r12,%rdx
sub    %rcx,%rdx
add    %r14,%rax
movss  (%r12,%r14,4),%xmm0
movaps %xmm0,0x50(%rsp)
movss  (%r12,%rax,4),%xmm0
movaps %xmm0,0x60(%rsp)
movss  (%rdx,%r14,4),%xmm0
movaps %xmm0,0x70(%rsp)
movss  (%rbx,%r14,4),%xmm1
addss  (%r15),%xmm1
movss  0xc35(%rip),%xmm0
call   1050 <r_sign@plt>
movaps 0x40(%rsp),%xmm1
ucomiss %xmm1,%xmm0
jne    1220 <vparms+0xf0>
jp     1220 <vparms+0xf0>
movss  0x14(%rsp),%xmm11
movss  0x8(%rsp),%xmm4
mov    0x18(%rsp),%r15
movss  0x4(%rsp),%xmm10
movaps 0xa0(%rsp),%xmm7
movaps 0xc04(%rip),%xmm5
jmp    125e <vparms+0x12e>
xorps  %xmm0,%xmm0
xorps  %xmm10,%xmm10
xorps  %xmm11,%xmm11
xorps  %xmm1,%xmm1
movss  %xmm1,0x8(%rsp)
xorps  %xmm1,%xmm1
xorps  %xmm7,%xmm7
jmp    1446 <vparms+0x316>
addps  %xmm8,%xmm0
mulss  0xbcb(%rip),%xmm4
movss  %xmm4,0x8(%rsp)
movaps %xmm7,%xmm1
shufps $0x55,%xmm7,%xmm1
movss  0xbb2(%rip),%xmm5
maxss  %xmm5,%xmm7
mov    0x118(%rsp),%rax
movss  (%rax),%xmm2
divss  %xmm7,%xmm2
movss  %xmm2,(%rax)
movss  %xmm11,0x14(%rsp)
movaps %xmm11,%xmm2
addss  %xmm11,%xmm2
maxss  %xmm5,%xmm2
divss  %xmm2,%xmm10
mov    0x110(%rsp),%rax
movss  %xmm10,(%rax)
movaps %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
maxss  %xmm5,%xmm2
movaps %xmm0,%xmm3
shufps $0xff,%xmm0,%xmm3
movaps %xmm3,%xmm4
divss  %xmm2,%xmm4
movaps %xmm0,%xmm2
maxss  %xmm5,%xmm2
divss  %xmm2,%xmm3
mulss  %xmm4,%xmm3
mov    0x120(%rsp),%rax
movss  %xmm3,(%rax)
movhlps %xmm0,%xmm0
maxss  %xmm5,%xmm0
movaps %xmm1,%xmm3
divss  %xmm0,%xmm3
divss  %xmm2,%xmm1
mulss  %xmm3,%xmm1
mov    0x128(%rsp),%rax
movss  %xmm1,(%rax)
mov    0xf8(%rsp),%rbx
mov    (%rbx),%eax
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ssl 0x24(%rsp),%xmm1
mov    0x100(%rsp),%r14
movss  0xafa(%rip),%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x4(%rsp)
mulss  %xmm2,%xmm0
call   1040 <lfastrintf@plt>
mov    %eax,(%rbx)
movss  0x8(%rsp),%xmm0
mulss  0x4(%rsp),%xmm0
movss  %xmm0,0x8(%rsp)
call   1040 <lfastrintf@plt>
mov    %eax,%ecx
mov    $0x7fff,%ebx
mov    $0x7fff,%eax
cmp    $0x7fff,%ecx
jg     1559 <vparms+0x429>
movss  0x8(%rsp),%xmm0
call   1040 <lfastrintf@plt>
mov    0x108(%rsp),%rbp
mov    %eax,(%r14)
movss  0x14(%rsp),%xmm1
mulss  0xa92(%rip),%xmm1
movss  0x4(%rsp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x4(%rsp)
call   1040 <lfastrintf@plt>
cmp    $0x7fff,%eax
jg     159b <vparms+0x46b>
movss  0x4(%rsp),%xmm0
call   1040 <lfastrintf@plt>
mov    %eax,%ebx
mov    %ebx,0x0(%rbp)
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @vparms(i32* nocapture %0, float* nocapture %1, float* nocapture %2, i32* nocapture %3, i32 %4, float* nocapture %5, i32* nocapture %6, i32* nocapture %7, i32* nocapture writeonly %8, i32* nocapture writeonly %9, float* nocapture writeonly %10, float* nocapture %11, float* nocapture writeonly %12, float* nocapture writeonly %13) {
%15 = getelementptr inbounds i32, i32* %3, i64 2
%16 = load i32, i32* %15
%17 = sext i32 %16 to i64
%18 = sub nsw i64 0, %17
%19 = getelementptr inbounds float, float* %2, i64 %18
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = sub nsw i64 0, %21
%23 = getelementptr inbounds float, float* %1, i64 %22
store float 0.000000e+00, float* %11
store i32 0, i32* %7
%24 = getelementptr inbounds i32, i32* %0, i64 1
%25 = load i32, i32* %24
%26 = load i32, i32* %0
%27 = sub nsw i32 %25, %26
%28 = add nsw i32 %27, 1
%29 = mul nsw i32 %28, %4
%30 = sdiv i32 %29, 2
%31 = add nsw i32 %30, %26
%32 = sdiv i32 %28, 2
%33 = add i32 %31, %32
%34 = sext i32 %31 to i64
%35 = getelementptr inbounds float, float* %23, i64 %34
%36 = load float, float* %35
%37 = load float, float* %5
%38 = fsub float %36, %37
%39 = tail call float @r_sign(float 1.000000e+00, float %38)
%40 = icmp slt i32 %31, %33
br i1 %40, label %41, label %114
41: ; preds = %14
%42 = sext i32 %26 to i64
%43 = sext i32 %30 to i64
%44 = add nsw i64 %42, %43
%45 = sext i32 %33 to i64
br label %46
46: ; preds = %41, %104
%47 = phi i64 [ %44, %41 ], [ %54, %104 ]
%48 = phi float [ 0.000000e+00, %41 ], [ %59, %104 ]
%49 = phi float [ %39, %41 ], [ %105, %104 ]
%50 = phi float [ 0.000000e+00, %41 ], [ %64, %104 ]
%51 = phi float [ 0.000000e+00, %41 ], [ %71, %104 ]
%52 = phi <4 x float> [ zeroinitializer, %41 ], [ %94, %104 ]
%53 = phi <2 x float> [ zeroinitializer, %41 ], [ %88, %104 ]
%54 = add nsw i64 %47, 1
%55 = getelementptr inbounds float, float* %19, i64 %54
%56 = load float, float* %55
%57 = tail call i64 @fabsf(float %56)
%58 = sitofp i64 %57 to float
%59 = fadd float %48, %58
%60 = getelementptr inbounds float, float* %23, i64 %54
%61 = load float, float* %60
%62 = tail call i64 @fabsf(float %61)
%63 = sitofp i64 %62 to float
%64 = fadd float %50, %63
%65 = load float, float* %60
%66 = getelementptr inbounds float, float* %23, i64 %47
%67 = load float, float* %66
%68 = fsub float %65, %67
%69 = tail call i64 @fabsf(float %68)
%70 = sitofp i64 %69 to float
%71 = fadd float %51, %70
%72 = load float, float* %60
%73 = load float, float* %66
%74 = load float, float* %11
%75 = tail call float @llvm.fmuladd.f32(float %72, float %73, float %74)
store float %75, float* %11
%76 = load float, float* %55
%77 = load i32, i32* %6
%78 = sext i32 %77 to i64
%79 = sub nsw i64 %54, %78
%80 = getelementptr inbounds float, float* %19, i64 %79
%81 = load float, float* %80
%82 = add nsw i64 %54, %78
%83 = getelementptr inbounds float, float* %19, i64 %82
%84 = load float, float* %83
%85 = insertelement <2 x float> poison, float %72, i64 0
%86 = insertelement <2 x float> %85, float %76, i64 1
%87 = insertelement <2 x float> %85, float %84, i64 1
%88 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %86, <2 x float> %87, <2 x float> %53)
%89 = insertelement <4 x float> poison, float %76, i64 0
%90 = insertelement <4 x float> %89, float %81, i64 1
%91 = insertelement <4 x float> %90, float %84, i64 2
%92 = insertelement <4 x float> %91, float %76, i64 3
%93 = insertelement <4 x float> %91, float %81, i64 3
%94 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %92, <4 x float> %93, <4 x float> %52)
%95 = load float, float* %60
%96 = load float, float* %5
%97 = fadd float %95, %96
%98 = tail call float @r_sign(float 1.000000e+00, float %97)
%99 = fcmp une float %98, %49
br i1 %99, label %100, label %104
100: ; preds = %46
%101 = load i32, i32* %7
%102 = add nsw i32 %101, 1
store i32 %102, i32* %7
%103 = fneg float %49
br label %104
104: ; preds = %100, %46
%105 = phi float [ %103, %100 ], [ %49, %46 ]
%106 = load float, float* %5
%107 = fneg float %106
store float %107, float* %5
%108 = icmp eq i64 %54, %45
br i1 %108, label %109, label %46
109: ; preds = %104
%110 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %92, <4 x float> %93, <4 x float> %52)
%111 = fmul float %59, 2.500000e-01
%112 = extractelement <2 x float> %88, i64 0
%113 = extractelement <2 x float> %88, i64 1
br label %114
114: ; preds = %109, %14
%115 = phi float [ 0.000000e+00, %14 ], [ %71, %109 ]
%116 = phi float [ 0.000000e+00, %14 ], [ %64, %109 ]
%117 = phi float [ 0.000000e+00, %14 ], [ %111, %109 ]
%118 = phi float [ 0.000000e+00, %14 ], [ %113, %109 ]
%119 = phi float [ 0.000000e+00, %14 ], [ %112, %109 ]
%120 = phi <4 x float> [ zeroinitializer, %14 ], [ %110, %109 ]
%121 = fcmp oge float %119, 1.000000e+00
%122 = select i1 %121, float %119, float 1.000000e+00
%123 = load float, float* %11
%124 = fdiv float %123, %122
store float %124, float* %11
%125 = fmul float %116, 2.000000e+00
%126 = fcmp oge float %125, 1.000000e+00
%127 = select i1 %126, float %125, float 1.000000e+00
%128 = fdiv float %115, %127
store float %128, float* %10
%129 = extractelement <4 x float> %120, i64 1
%130 = fcmp oge float %129, 1.000000e+00
%131 = select i1 %130, float %129, float 1.000000e+00
%132 = extractelement <4 x float> %120, i64 3
%133 = fdiv float %132, %131
%134 = extractelement <4 x float> %120, i64 0
%135 = fcmp oge float %134, 1.000000e+00
%136 = select i1 %135, float %134, float 1.000000e+00
%137 = fdiv float %132, %136
%138 = fmul float %133, %137
store float %138, float* %12
%139 = extractelement <4 x float> %120, i64 2
%140 = fcmp oge float %139, 1.000000e+00
%141 = select i1 %140, float %139, float 1.000000e+00
%142 = fdiv float %118, %141
%143 = fdiv float %118, %136
%144 = fmul float %142, %143
store float %144, float* %13
%145 = load i32, i32* %7
%146 = shl i32 %145, 1
%147 = sitofp i32 %146 to float
%148 = sitofp i32 %28 to float
%149 = fdiv float 9.000000e+01, %148
%150 = fmul float %149, %147
%151 = tail call i32 @lfastrintf(float %150)
store i32 %151, i32* %7
%152 = fmul float %149, %117
%153 = tail call i32 @lfastrintf(float %152)
%154 = icmp slt i32 %153, 32768
br i1 %154, label %155, label %157
155: ; preds = %114
%156 = tail call i32 @lfastrintf(float %152)
br label %157
157: ; preds = %114, %155
%158 = phi i32 [ %156, %155 ], [ 32767, %114 ]
store i32 %158, i32* %8
%159 = fmul float %116, 2.500000e-01
%160 = fmul float %149, %159
%161 = tail call i32 @lfastrintf(float %160)
%162 = icmp slt i32 %161, 32768
br i1 %162, label %163, label %165
163: ; preds = %157
%164 = tail call i32 @lfastrintf(float %160)
br label %165
165: ; preds = %157, %163
%166 = phi i32 [ %164, %163 ], [ 32767, %157 ]
store i32 %166, i32* %9
ret void
}