#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 */
scalar_t__ cos(float);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
void lsf2a(float *a_coef, float *freq) {
  int i, j;
  float hlp;
  float p[(10 / 2)], q[(10 / 2)];
  float a[(10 / 2) + 1], a1[(10 / 2)], a2[(10 / 2)];
  float b[(10 / 2) + 1], b1[(10 / 2)], b2[(10 / 2)];
  for (i = 0; i < 10; i++) {
    freq[i] = freq[i] * (float)0.159154943;
  }
  if ((freq[0] <= 0.0) || (freq[10 - 1] >= 0.5)) {
    if (freq[0] <= 0.0) {
      freq[0] = (float)0.022;
    }
    if (freq[10 - 1] >= 0.5) {
      freq[10 - 1] = (float)0.499;
    }
    hlp = (freq[10 - 1] - freq[0]) / (float)(10 - 1);
    for (i = 1; i < 10; i++) {
      freq[i] = freq[i - 1] + hlp;
    }
  }
  memset(a1, 0, (10 / 2) * sizeof(float));
  memset(a2, 0, (10 / 2) * sizeof(float));
  memset(b1, 0, (10 / 2) * sizeof(float));
  memset(b2, 0, (10 / 2) * sizeof(float));
  memset(a, 0, ((10 / 2) + 1) * sizeof(float));
  memset(b, 0, ((10 / 2) + 1) * sizeof(float));
  for (i = 0; i < (10 / 2); i++) {
    p[i] = (float)cos((float)6.283185307 * freq[2 * i]);
    q[i] = (float)cos((float)6.283185307 * freq[2 * i + 1]);
  }
  a[0] = 0.25;
  b[0] = 0.25;
  for (i = 0; i < (10 / 2); i++) {
    a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
    b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
    a2[i] = a1[i];
    a1[i] = a[i];
    b2[i] = b1[i];
    b1[i] = b[i];
  }
  for (j = 0; j < 10; j++) {
    if (j == 0) {
      a[0] = 0.25;
      b[0] = -0.25;
    } else {
      a[0] = b[0] = 0.0;
    }
    for (i = 0; i < (10 / 2); i++) {
      a[i + 1] = a[i] - 2 * p[i] * a1[i] + a2[i];
      b[i + 1] = b[i] - 2 * q[i] * b1[i] + b2[i];
      a2[i] = a1[i];
      a1[i] = a[i];
      b2[i] = b1[i];
      b1[i] = b[i];
    }
    a_coef[j + 1] = 2 * (a[(10 / 2)] + b[(10 / 2)]);
  }
  a_coef[0] = 1.0;
}


x86 assembly (clang, -O0):
<lsf2a>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    1174 <lsf2a+0x54>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  0xed4(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    113a <lsf2a+0x1a>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jae    11ac <lsf2a+0x8c>
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe5e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     126f <lsf2a+0x14f>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jb     11d5 <lsf2a+0xb5>
mov    -0x10(%rbp),%rax
movss  0xe37(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe16(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     1205 <lsf2a+0xe5>
mov    -0x10(%rbp),%rax
movss  0xe0c(%rip),%xmm0
movss  %xmm0,0x24(%rax)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  0xdf2(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    126a <lsf2a+0x14a>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    122e <lsf2a+0x10e>
jmp    126f <lsf2a+0x14f>
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0xd0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    135c <lsf2a+0x23c>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movss  0xd20(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x30(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  0xcef(%rip),%xmm0
mulss  (%rax,%rcx,4),%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12e5 <lsf2a+0x1c5>
movss  0xcb0(%rip),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xca3(%rip),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    14b5 <lsf2a+0x395>
movslq -0x14(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm1
movslq -0x14(%rbp),%rax
movss  0xc80(%rip),%xmm0
mulss  -0x30(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
addss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
movslq -0x14(%rbp),%rax
movss  0xc24(%rip),%xmm0
mulss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  -0xf0(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0xd0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xf0(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1380 <lsf2a+0x260>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    167a <lsf2a+0x55a>
cmpl   $0x0,-0x18(%rbp)
jne    14f2 <lsf2a+0x3d2>
movss  0xb3c(%rip),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0xb37(%rip),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
jmp    1505 <lsf2a+0x3e5>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    1641 <lsf2a+0x521>
movslq -0x14(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm1
movslq -0x14(%rbp),%rax
movss  0xaf4(%rip),%xmm0
mulss  -0x30(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
addss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x70(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm1
ff ff
movslq -0x14(%rbp),%rax
movss  0xa98(%rip),%xmm0
mulss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  -0xf0(%rbp,%rax,4),%xmm2
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
addss  -0x110(%rbp,%rax,4),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0xd0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xf0(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    150c <lsf2a+0x3ec>
movss  -0x5c(%rbp),%xmm1
addss  -0xbc(%rbp),%xmm1
ff
movss  0x9ca(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14bc <lsf2a+0x39c>
mov    -0x8(%rbp),%rax
movss  0x992(%rip),%xmm0
movss  %xmm0,(%rax)
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lsf2a>:
push   %r14
push   %rbx
sub    $0x168,%rsp
mov    %rsi,%rbx
mov    %rdi,%r14
movaps 0xec9(%rip),%xmm1
movups (%rsi),%xmm0
movups 0x10(%rsi),%xmm2
mulps  %xmm1,%xmm0
movups %xmm0,(%rsi)
mulps  %xmm1,%xmm2
movups %xmm2,0x10(%rsi)
movss  0xebd(%rip),%xmm2
movss  0x20(%rsi),%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,0x20(%rsi)
mulss  0x24(%rsi),%xmm2
movss  %xmm2,0x24(%rsi)
xorps  %xmm1,%xmm1
ucomiss %xmm0,%xmm1
jae    1181 <lsf2a+0x61>
ucomiss 0xe9e(%rip),%xmm2
jae    118f <lsf2a+0x6f>
jmp    120a <lsf2a+0xea>
movl   $0x3cb43958,(%rbx)
movss  0xe85(%rip),%xmm0
movss  0xe81(%rip),%xmm1
cmpnless %xmm2,%xmm1
andps  %xmm1,%xmm2
movss  0xe75(%rip),%xmm3
andnps %xmm3,%xmm1
orps   %xmm2,%xmm1
subss  %xmm0,%xmm1
divss  0xe67(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x18(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x24(%rbx)
lea    0xa0(%rsp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    0x80(%rsp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    0x60(%rsp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    0x40(%rsp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1030 <memset@plt>
lea    0xf0(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0xc0(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movss  (%rbx),%xmm0
mulss  0xd9c(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x4(%rbx),%xmm0
mulss  0xd7c(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x8(%rbx),%xmm0
mulss  0xd5c(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x20(%rsp)
movss  0xc(%rbx),%xmm0
mulss  0xd3c(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x10(%rsp)
movss  0x10(%rbx),%xmm0
mulss  0xd1c(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0xc(%rsp)
movss  0x14(%rbx),%xmm0
mulss  0xcfc(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x18(%rbx),%xmm0
mulss  0xcdc(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0x1c(%rbx),%xmm0
mulss  0xcbc(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x20(%rbx),%xmm0
mulss  0xc9c(%rip),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%rsp)
movss  0xc82(%rip),%xmm0
mulss  0x24(%rbx),%xmm0
call   1040 <cos@plt>
movss  0xc73(%rip),%xmm12
movss  0x14(%rsp),%xmm0
mulss  %xmm12,%xmm0
movss  %xmm0,0x14(%rsp)
movaps 0xa0(%rsp),%xmm1
movaps %xmm0,%xmm7
mulss  %xmm1,%xmm7
movss  0xc4f(%rip),%xmm0
addss  %xmm0,%xmm7
addss  0x80(%rsp),%xmm7
movss  0x24(%rsp),%xmm5
mulss  %xmm12,%xmm5
movaps 0x60(%rsp),%xmm4
movaps %xmm5,%xmm6
movaps %xmm5,%xmm13
mulss  %xmm4,%xmm6
addss  %xmm0,%xmm6
addss  0x40(%rsp),%xmm6
movss  0x20(%rsp),%xmm5
mulss  %xmm12,%xmm5
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps %xmm2,0xe0(%rsp)
movaps %xmm5,%xmm15
mulss  %xmm2,%xmm15
addss  %xmm7,%xmm15
addss  0x84(%rsp),%xmm15
movss  0x10(%rsp),%xmm10
mulss  %xmm12,%xmm10
movss  %xmm10,0x10(%rsp)
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
movaps %xmm2,0x140(%rsp)
mulss  %xmm2,%xmm10
addss  %xmm6,%xmm10
addss  0x44(%rsp),%xmm10
movss  0xc(%rsp),%xmm9
mulss  %xmm12,%xmm9
movss  %xmm9,0xc(%rsp)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movaps %xmm2,0x130(%rsp)
mulss  %xmm2,%xmm9
addss  %xmm15,%xmm9
addss  0x88(%rsp),%xmm9
movss  0x8(%rsp),%xmm8
mulss  %xmm12,%xmm8
movss  %xmm8,0x8(%rsp)
movaps %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
movaps %xmm0,0x120(%rsp)
mulss  %xmm0,%xmm8
addss  %xmm10,%xmm8
addss  0x48(%rsp),%xmm8
movss  0x1c(%rsp),%xmm3
mulss  %xmm12,%xmm3
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movaps %xmm0,0x110(%rsp)
movaps %xmm3,%xmm2
mulss  %xmm0,%xmm2
addss  %xmm9,%xmm2
addss  0x8c(%rsp),%xmm2
movss  0x4(%rsp),%xmm11
mulss  %xmm12,%xmm11
movss  %xmm11,0x4(%rsp)
movaps %xmm1,0x80(%rsp)
movaps %xmm4,%xmm1
shufps $0xff,%xmm4,%xmm1
movaps %xmm1,0x150(%rsp)
mulss  %xmm1,%xmm11
addss  %xmm8,%xmm11
addss  0x4c(%rsp),%xmm11
movaps %xmm4,0x40(%rsp)
movl   $0x3e800000,0xf0(%rsp)
movss  %xmm7,0xf4(%rsp)
movl   $0x3e800000,0xa0(%rsp)
movss  %xmm15,0xf8(%rsp)
movss  %xmm7,0xa4(%rsp)
movss  %xmm9,0xfc(%rsp)
movss  %xmm15,0xa8(%rsp)
movss  %xmm2,0x100(%rsp)
movss  %xmm9,0xac(%rsp)
movss  (%rsp),%xmm4
mulss  %xmm12,%xmm4
movss  %xmm4,(%rsp)
movss  0xb0(%rsp),%xmm1
mulss  %xmm1,%xmm4
movaps %xmm1,%xmm14
movss  %xmm1,0x28(%rsp)
addss  %xmm2,%xmm4
addss  0x90(%rsp),%xmm4
movss  %xmm4,0x104(%rsp)
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
mulss  %xmm12,%xmm1
movss  %xmm1,0x30(%rsp)
movl   $0x3e800000,0xc0(%rsp)
movss  %xmm6,0xc4(%rsp)
movl   $0x3e800000,0x60(%rsp)
3e
movss  %xmm10,0xc8(%rsp)
movss  %xmm6,0x64(%rsp)
movss  %xmm8,0xcc(%rsp)
movss  %xmm10,0x68(%rsp)
movss  %xmm11,0xd0(%rsp)
movss  %xmm8,0x6c(%rsp)
movss  0x70(%rsp),%xmm0
movss  %xmm0,0x2c(%rsp)
mulss  %xmm0,%xmm1
addss  %xmm11,%xmm1
addss  0x50(%rsp),%xmm1
movss  %xmm1,0xd4(%rsp)
movss  %xmm14,0x90(%rsp)
movss  %xmm2,0xb0(%rsp)
movss  %xmm0,0x50(%rsp)
movss  %xmm11,0x70(%rsp)
movss  0xa0(%rsp),%xmm0
movss  0x14(%rsp),%xmm4
movaps %xmm0,%xmm12
mulss  %xmm0,%xmm4
addss  0x987(%rip),%xmm4
addss  0x80(%rsp),%xmm4
movss  0x60(%rsp),%xmm0
movss  %xmm13,0x24(%rsp)
movaps %xmm13,%xmm1
movss  %xmm0,0x18(%rsp)
mulss  %xmm0,%xmm1
movss  0x95f(%rip),%xmm0
movss  %xmm0,0x3c(%rsp)
addss  %xmm0,%xmm1
addss  0x40(%rsp),%xmm1
movss  %xmm5,0x20(%rsp)
movaps %xmm7,%xmm13
mulss  %xmm7,%xmm5
movaps %xmm4,%xmm14
addss  %xmm4,%xmm5
addss  0xe0(%rsp),%xmm5
movss  0x10(%rsp),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm1,%xmm7
addss  0x140(%rsp),%xmm7
movss  0xc(%rsp),%xmm4
mulss  %xmm15,%xmm4
movss  %xmm5,0xe0(%rsp)
addss  %xmm5,%xmm4
addss  0x130(%rsp),%xmm4
movss  0x8(%rsp),%xmm0
movss  %xmm10,0x38(%rsp)
mulss  %xmm10,%xmm0
addss  %xmm7,%xmm0
addss  0x120(%rsp),%xmm0
movss  %xmm3,0x1c(%rsp)
movaps %xmm3,%xmm5
mulss  %xmm9,%xmm5
movss  %xmm4,0x34(%rsp)
addss  %xmm4,%xmm5
addss  0x110(%rsp),%xmm5
movss  0x4(%rsp),%xmm3
movss  %xmm8,0x140(%rsp)
mulss  %xmm8,%xmm3
movss  %xmm0,0x110(%rsp)
addss  %xmm0,%xmm3
addss  0x150(%rsp),%xmm3
movss  (%rsp),%xmm0
movss  %xmm2,0x130(%rsp)
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
addss  0x28(%rsp),%xmm0
movaps %xmm9,%xmm4
movss  0x30(%rsp),%xmm2
movss  %xmm11,0x120(%rsp)
mulss  %xmm11,%xmm2
addss  %xmm3,%xmm2
addss  0x2c(%rsp),%xmm2
addss  %xmm0,%xmm2
movss  0x83e(%rip),%xmm0
movaps %xmm15,%xmm11
movl   $0x3e800000,0xf0(%rsp)
movl   $0xbe800000,0xc0(%rsp)
addss  %xmm2,%xmm2
movss  %xmm2,0x4(%r14)
mov    $0x2,%eax
nopw   0x0(%rax,%rax,1)
movss  %xmm5,0x28(%rsp)
movss  %xmm0,0x2c(%rsp)
movss  0x3c(%rsp),%xmm15
movss  0x14(%rsp),%xmm2
mulss  %xmm0,%xmm2
movaps %xmm3,%xmm9
movaps %xmm6,%xmm10
xorps  %xmm6,%xmm6
addss  %xmm6,%xmm2
addss  %xmm12,%xmm2
movaps %xmm1,%xmm8
movss  0x24(%rsp),%xmm1
mulss  %xmm15,%xmm1
xorps  %xmm0,%xmm0
movss  %xmm0,0x3c(%rsp)
addss  %xmm6,%xmm1
addss  0x18(%rsp),%xmm1
movss  0x20(%rsp),%xmm12
movss  %xmm14,0x150(%rsp)
mulss  %xmm14,%xmm12
addss  %xmm2,%xmm12
addss  %xmm13,%xmm12
movaps %xmm7,%xmm3
movss  %xmm7,0x18(%rsp)
movss  0x10(%rsp),%xmm7
mulss  %xmm8,%xmm7
addss  %xmm1,%xmm7
addss  %xmm10,%xmm7
movss  0xc(%rsp),%xmm6
mulss  0xe0(%rsp),%xmm6
addss  %xmm12,%xmm6
addss  %xmm11,%xmm6
movss  0x8(%rsp),%xmm0
mulss  %xmm3,%xmm0
addss  %xmm7,%xmm0
addss  0x38(%rsp),%xmm0
movss  0x1c(%rsp),%xmm5
movss  0x34(%rsp),%xmm13
mulss  %xmm13,%xmm5
addss  %xmm6,%xmm5
addss  %xmm4,%xmm5
movss  0x4(%rsp),%xmm3
movss  0x110(%rsp),%xmm11
mulss  %xmm11,%xmm3
addss  %xmm0,%xmm3
addss  0x140(%rsp),%xmm3
movss  (%rsp),%xmm4
movss  0x28(%rsp),%xmm14
mulss  %xmm14,%xmm4
addss  %xmm5,%xmm4
addss  0x130(%rsp),%xmm4
movss  0x30(%rsp),%xmm10
mulss  %xmm9,%xmm10
addss  %xmm3,%xmm10
addss  0x120(%rsp),%xmm10
addss  %xmm4,%xmm10
movl   $0x0,0xc0(%rsp)
movl   $0x0,0xf0(%rsp)
addss  %xmm10,%xmm10
movss  %xmm10,(%r14,%rax,4)
add    $0x1,%rax
movss  %xmm9,0x120(%rsp)
movss  %xmm14,0x130(%rsp)
movss  %xmm11,0x140(%rsp)
movss  %xmm0,0x110(%rsp)
movaps %xmm13,%xmm4
movss  %xmm6,0x34(%rsp)
movss  0x18(%rsp),%xmm0
movss  %xmm0,0x38(%rsp)
movss  0xe0(%rsp),%xmm11
movss  %xmm12,0xe0(%rsp)
movss  0x150(%rsp),%xmm13
movaps %xmm2,%xmm14
movss  0x2c(%rsp),%xmm2
movss  %xmm15,0x18(%rsp)
movaps %xmm2,%xmm12
xorps  %xmm0,%xmm0
movaps %xmm8,%xmm6
cmp    $0xb,%rax
jne    1820 <lsf2a+0x700>
movl   $0x0,0xa0(%rsp)
movss  %xmm2,0x80(%rsp)
movl   $0x0,0x60(%rsp)
movss  %xmm15,0x40(%rsp)
movss  %xmm1,0xc4(%rsp)
movss  %xmm7,0xc8(%rsp)
movss  %xmm8,0x44(%rsp)
movss  %xmm1,0x64(%rsp)
movl   $0x3f800000,(%r14)
add    $0x168,%rsp
pop    %rbx
pop    %r14
ret

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

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