#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 /*<<< orphan*/ a;

/* Variables and functions */
scalar_t__ cos(float);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
void lsptopc(float *f, float *pc) {
  int i, j, k, lspflag;
  float freq[10], p[10 / 2], q[10 / 2];
  float a[10 / 2 + 1], a1[10 / 2 + 1], a2[10 / 2 + 1];
  float b[10 / 2 + 1], b1[10 / 2 + 1], b2[10 / 2 + 1];
  float xx, xf;
  lspflag = 0;
  for (i = 1; i < 10; i++) {
    if (f[i] <= f[i - 1])
      lspflag = 1;
  }
  for (j = 0; j < 10; j++)
    freq[j] = f[j];
  memset(a, 0, sizeof(a[0]) * (10 / 2 + 1));
  memset(a1, 0, sizeof(a[0]) * (10 / 2 + 1));
  memset(a2, 0, sizeof(a[0]) * (10 / 2 + 1));
  memset(b, 0, sizeof(a[0]) * (10 / 2 + 1));
  memset(b1, 0, sizeof(a[0]) * (10 / 2 + 1));
  memset(b2, 0, sizeof(a[0]) * (10 / 2 + 1));
  for (i = 0; i < (10 / 2); i++) {
    p[i] = -2.f * (float)cos(2.f * 3.14159265358979323846f * freq[2 * i]);
    q[i] = -2.f * (float)cos(2.f * 3.14159265358979323846f * freq[2 * i + 1]);
  }
  xf = 0.0f;
  for (k = 0; k < 10 + 1; k++) {
    xx = 0.0;
    if (k == 0)
      xx = 1.0f;
    a[0] = xx + xf;
    b[0] = xx - xf;
    xf = xx;
    for (i = 0; i < (10 / 2); i++) {
      a[i + 1] = a[i] + p[i] * a1[i] + a2[i];
      b[i + 1] = b[i] + q[i] * b1[i] + b2[i];
      a2[i] = a1[i];
      a1[i] = a[i];
      b2[i] = b1[i];
      b1[i] = b[i];
    }
    if (k != 0)
      pc[k - 1] = -.5f * (a[10 / 2] + b[10 / 2]);
  }
  for (i = 10 - 1; i >= 0; i--)
    pc[i + 1] = -pc[i];
  pc[0] = 1.0f;
}


x86 assembly (clang, -O0):
<lsptopc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    118d <lsptopc+0x6d>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     117a <lsptopc+0x5a>
movl   $0x1,-0x20(%rbp)
jmp    117f <lsptopc+0x5f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1141 <lsptopc+0x21>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    11c3 <lsptopc+0xa3>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x18(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1194 <lsptopc+0x74>
lea    -0xb0(%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>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x110(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x130(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    -0x150(%rbp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    12c6 <lsptopc+0x1a6>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
cltq
movss  0xdb6(%rip),%xmm0
mulss  -0x50(%rbp,%rax,4),%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm1
movss  0xd9a(%rip),%xmm0
mulss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movss  0xd7d(%rip),%xmm0
mulss  -0x50(%rbp,%rax,4),%xmm0
call   1040 <cos@plt>
cvtsi2ss %rax,%xmm1
movss  0xd61(%rip),%xmm0
mulss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x90(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    123c <lsptopc+0x11c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0x1c(%rbp)
cmpl   $0xb,-0x1c(%rbp)
jge    14b0 <lsptopc+0x390>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x154(%rbp)
ff
cmpl   $0x0,-0x1c(%rbp)
jne    1307 <lsptopc+0x1e7>
movss  0xd01(%rip),%xmm0
movss  %xmm0,-0x154(%rbp)
ff
movss  -0x154(%rbp),%xmm0
ff
addss  -0x158(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x154(%rbp),%xmm0
ff
subss  -0x158(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x154(%rbp),%xmm0
ff
movss  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0x14(%rbp)
cmpl   $0x5,-0x14(%rbp)
jge    1465 <lsptopc+0x345>
movslq -0x14(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm1
ff ff
movslq -0x14(%rbp),%rax
movss  -0x70(%rbp,%rax,4),%xmm0
movslq -0x14(%rbp),%rax
movss  -0xd0(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
addss  -0xf0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0xb0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x110(%rbp,%rax,4),%xmm1
ff ff
movslq -0x14(%rbp),%rax
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm2
ff ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x14(%rbp),%rax
addss  -0x150(%rbp,%rax,4),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
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
movslq -0x14(%rbp),%rax
movss  -0xb0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xd0(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x130(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x150(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x130(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    134e <lsptopc+0x22e>
cmpl   $0x0,-0x1c(%rbp)
je     149d <lsptopc+0x37d>
movss  -0x9c(%rbp),%xmm1
ff
addss  -0xfc(%rbp),%xmm1
ff
movss  0xb7d(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    14a2 <lsptopc+0x382>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12d8 <lsptopc+0x1b8>
movl   $0x9,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     14fb <lsptopc+0x3db>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    14b7 <lsptopc+0x397>
mov    -0x10(%rbp),%rax
movss  0xaf9(%rip),%xmm0
movss  %xmm0,(%rax)
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lsptopc>:
push   %r14
push   %rbx
sub    $0x128,%rsp
mov    %rsi,%r14
movss  0xecb(%rip),%xmm0
movss  (%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsp)
movss  0x4(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
movss  0x8(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
movss  0xc(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x10(%rsp)
movss  0x10(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x14(%rsp)
movss  0x14(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x18(%rsp)
movss  0x18(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x1c(%rsp)
movss  0x1c(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x20(%rsp)
movss  0x20(%rdi),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x24(%rsp)
mulss  0x24(%rdi),%xmm0
movss  %xmm0,0x28(%rsp)
lea    0x110(%rsp),%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0x90(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0xd0(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0xf0(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0x70(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
lea    0xb0(%rsp),%rdi
xor    %esi,%esi
mov    $0x18,%edx
call   1030 <memset@plt>
movss  0x4(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xdac(%rip),%xmm0
movss  %xmm0,0x48(%rsp)
movss  0x8(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xd8b(%rip),%xmm0
movss  %xmm0,0x44(%rsp)
movss  0xc(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xd6a(%rip),%xmm0
movss  %xmm0,0x40(%rsp)
movss  0x10(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xd49(%rip),%xmm0
movss  %xmm0,0x3c(%rsp)
movss  0x14(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xd28(%rip),%xmm0
movss  %xmm0,0x38(%rsp)
movss  0x18(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xd07(%rip),%xmm0
movss  %xmm0,0x34(%rsp)
movss  0x1c(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xce6(%rip),%xmm0
movss  %xmm0,0x30(%rsp)
movss  0x20(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xcc5(%rip),%xmm0
movss  %xmm0,0x2c(%rsp)
movss  0x24(%rsp),%xmm0
call   1040 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xca4(%rip),%xmm0
movss  %xmm0,0x54(%rsp)
movss  0x28(%rsp),%xmm0
call   1040 <cos@plt>
movss  0x70(%rsp),%xmm2
movss  0x74(%rsp),%xmm5
movss  0x90(%rsp),%xmm1
movss  0x94(%rsp),%xmm3
movss  0x98(%rsp),%xmm6
movss  0x78(%rsp),%xmm7
movss  0x9c(%rsp),%xmm8
movss  0x48(%rsp),%xmm13
movss  %xmm1,0x20(%rsp)
mulss  %xmm1,%xmm13
movss  0xc46(%rip),%xmm4
addss  %xmm4,%xmm13
addss  0xd0(%rsp),%xmm13
movss  0x44(%rsp),%xmm1
movaps %xmm2,%xmm11
mulss  %xmm2,%xmm1
addss  %xmm4,%xmm1
addss  0xb0(%rsp),%xmm1
movss  0x40(%rsp),%xmm2
movss  %xmm3,0x8(%rsp)
mulss  %xmm3,%xmm2
addss  %xmm13,%xmm2
addss  0xd4(%rsp),%xmm2
movss  0x3c(%rsp),%xmm3
movss  %xmm5,0xc(%rsp)
mulss  %xmm5,%xmm3
addss  %xmm1,%xmm3
addss  0xb4(%rsp),%xmm3
movss  0x38(%rsp),%xmm5
movss  %xmm6,0x18(%rsp)
mulss  %xmm6,%xmm5
addss  %xmm2,%xmm5
addss  0xd8(%rsp),%xmm5
movss  0x34(%rsp),%xmm6
movss  %xmm7,0x1c(%rsp)
mulss  %xmm7,%xmm6
addss  %xmm3,%xmm6
addss  0xb8(%rsp),%xmm6
movss  0x30(%rsp),%xmm7
movss  %xmm8,0x28(%rsp)
mulss  %xmm8,%xmm7
addss  %xmm5,%xmm7
addss  0xdc(%rsp),%xmm7
movss  %xmm7,0x4c(%rsp)
movss  0x7c(%rsp),%xmm8
movss  0x2c(%rsp),%xmm7
movss  %xmm8,0x10(%rsp)
mulss  %xmm8,%xmm7
addss  %xmm6,%xmm7
addss  0xbc(%rsp),%xmm7
movss  %xmm7,0x4(%rsp)
xorps  %xmm7,%xmm7
cvtsi2ss %rax,%xmm7
mulss  0xb42(%rip),%xmm7
movss  %xmm7,0x50(%rsp)
movss  0xa0(%rsp),%xmm7
movss  %xmm7,0x24(%rsp)
movss  0x80(%rsp),%xmm7
movss  %xmm7,0x14(%rsp)
movaps %xmm4,%xmm8
movaps %xmm4,%xmm7
nopl   (%rax)
movaps %xmm8,%xmm9
movss  %xmm8,0x6c(%rsp)
movss  %xmm4,0x58(%rsp)
xorps  %xmm8,%xmm8
subss  %xmm7,%xmm8
movaps %xmm7,%xmm0
xorps  %xmm7,%xmm7
addss  %xmm7,%xmm0
movss  %xmm0,0x68(%rsp)
movaps %xmm13,%xmm7
movss  %xmm13,0x64(%rsp)
movss  0x48(%rsp),%xmm13
mulss  %xmm4,%xmm13
addss  %xmm0,%xmm13
addss  0x20(%rsp),%xmm13
movaps %xmm1,%xmm0
movss  %xmm1,0x60(%rsp)
movss  0x44(%rsp),%xmm1
mulss  %xmm9,%xmm1
addss  %xmm8,%xmm1
addss  %xmm11,%xmm1
movaps %xmm2,%xmm9
movss  %xmm2,0x5c(%rsp)
movss  0x40(%rsp),%xmm2
mulss  %xmm7,%xmm2
addss  %xmm13,%xmm2
addss  0x8(%rsp),%xmm2
movaps %xmm3,%xmm7
movss  0x3c(%rsp),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
addss  0xc(%rsp),%xmm3
movaps %xmm5,%xmm4
movss  0x38(%rsp),%xmm5
mulss  %xmm9,%xmm5
addss  %xmm2,%xmm5
addss  0x18(%rsp),%xmm5
movaps %xmm6,%xmm0
movss  0x34(%rsp),%xmm6
mulss  %xmm7,%xmm6
addss  %xmm3,%xmm6
addss  0x1c(%rsp),%xmm6
movss  0x4c(%rsp),%xmm15
movss  0x30(%rsp),%xmm9
mulss  %xmm4,%xmm9
addss  %xmm5,%xmm9
addss  0x28(%rsp),%xmm9
movss  0x2c(%rsp),%xmm12
mulss  %xmm0,%xmm12
addss  %xmm6,%xmm12
addss  0x10(%rsp),%xmm12
movss  0x50(%rsp),%xmm10
movss  0x4(%rsp),%xmm11
mulss  %xmm11,%xmm10
addss  %xmm12,%xmm10
addss  0x14(%rsp),%xmm10
movss  0x54(%rsp),%xmm14
mulss  %xmm15,%xmm14
addss  %xmm9,%xmm14
addss  0x24(%rsp),%xmm14
addss  %xmm10,%xmm14
mulss  0x9d0(%rip),%xmm14
movss  %xmm14,(%r14,%rbx,4)
add    $0x1,%rbx
movss  %xmm11,0x14(%rsp)
movss  %xmm12,0x4(%rsp)
movss  %xmm15,0x24(%rsp)
movss  %xmm9,0x4c(%rsp)
movss  %xmm0,0x10(%rsp)
movss  %xmm4,0x28(%rsp)
movss  0x58(%rsp),%xmm4
movaps %xmm4,%xmm12
movss  %xmm4,0x20(%rsp)
movss  0x68(%rsp),%xmm4
movaps %xmm7,%xmm9
movss  %xmm7,0x1c(%rsp)
movss  0x5c(%rsp),%xmm7
movaps %xmm7,%xmm0
movss  %xmm7,0x18(%rsp)
movss  0x60(%rsp),%xmm7
movaps %xmm7,%xmm14
movss  %xmm7,0xc(%rsp)
movss  0x64(%rsp),%xmm7
movaps %xmm7,%xmm10
movss  %xmm7,0x8(%rsp)
movss  0x6c(%rsp),%xmm11
xorps  %xmm7,%xmm7
cmp    $0xa,%rbx
jne    14f0 <lsptopc+0x3d0>
movss  %xmm4,0x110(%rsp)
movss  %xmm8,0xf0(%rsp)
movss  %xmm4,0x90(%rsp)
movss  %xmm12,0xd0(%rsp)
movss  %xmm13,0x114(%rsp)
movss  %xmm1,0xf4(%rsp)
movss  %xmm11,0xb0(%rsp)
movss  %xmm8,0x70(%rsp)
movss  %xmm2,0x118(%rsp)
movss  %xmm3,0xf8(%rsp)
movss  %xmm10,0xd4(%rsp)
movss  %xmm13,0x94(%rsp)
movss  %xmm14,0xb4(%rsp)
movss  %xmm1,0x74(%rsp)
movss  %xmm5,0x11c(%rsp)
movss  %xmm6,0xfc(%rsp)
movss  %xmm0,0xd8(%rsp)
movss  %xmm2,0x98(%rsp)
movss  %xmm9,0xb8(%rsp)
movss  %xmm3,0x78(%rsp)
movss  0x24(%r14),%xmm0
movaps 0x87e(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0x28(%r14)
movss  0x20(%r14),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x24(%r14)
movups (%r14),%xmm0
movups 0x10(%r14),%xmm2
xorps  %xmm1,%xmm2
movups %xmm2,0x14(%r14)
xorps  %xmm1,%xmm0
movups %xmm0,0x4(%r14)
movl   $0x3f800000,(%r14)
add    $0x128,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @lsptopc(float* nocapture %0, float* nocapture %1) {
%3 = alloca [6 x float]
%4 = alloca [6 x float]
%5 = alloca [6 x float]
%6 = alloca [6 x float]
%7 = alloca [6 x float]
%8 = alloca [6 x float]
%9 = bitcast [6 x float]* %3 to i8*
%10 = bitcast [6 x float]* %4 to i8*
%11 = bitcast [6 x float]* %5 to i8*
%12 = bitcast [6 x float]* %6 to i8*
%13 = bitcast [6 x float]* %7 to i8*
%14 = bitcast [6 x float]* %8 to i8*
%15 = load float, float* %0
%16 = getelementptr inbounds float, float* %0, i64 1
%17 = load float, float* %16
%18 = getelementptr inbounds float, float* %0, i64 2
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %0, i64 3
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %0, i64 4
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %0, i64 5
%25 = load float, float* %24
%26 = getelementptr inbounds float, float* %0, i64 6
%27 = load float, float* %26
%28 = getelementptr inbounds float, float* %0, i64 7
%29 = load float, float* %28
%30 = getelementptr inbounds float, float* %0, i64 8
%31 = load float, float* %30
%32 = getelementptr inbounds float, float* %0, i64 9
%33 = load float, float* %32
%34 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 0, i64 0
%35 = call i32 @memset(float* %34, i32 0, i32 24)
%36 = getelementptr inbounds [6 x float], [6 x float]* %4, i64 0, i64 0
%37 = call i32 @memset(float* %36, i32 0, i32 24)
%38 = getelementptr inbounds [6 x float], [6 x float]* %5, i64 0, i64 0
%39 = call i32 @memset(float* %38, i32 0, i32 24)
%40 = getelementptr inbounds [6 x float], [6 x float]* %6, i64 0, i64 0
%41 = call i32 @memset(float* %40, i32 0, i32 24)
%42 = getelementptr inbounds [6 x float], [6 x float]* %7, i64 0, i64 0
%43 = call i32 @memset(float* %42, i32 0, i32 24)
%44 = getelementptr inbounds [6 x float], [6 x float]* %8, i64 0, i64 0
%45 = call i32 @memset(float* %44, i32 0, i32 24)
%46 = fmul float %15, 0x401921FB60000000
%47 = call i64 @cos(float %46)
%48 = sitofp i64 %47 to float
%49 = fmul float %48, -2.000000e+00
%50 = fmul float %17, 0x401921FB60000000
%51 = call i64 @cos(float %50)
%52 = sitofp i64 %51 to float
%53 = fmul float %52, -2.000000e+00
%54 = fmul float %19, 0x401921FB60000000
%55 = call i64 @cos(float %54)
%56 = sitofp i64 %55 to float
%57 = fmul float %56, -2.000000e+00
%58 = fmul float %21, 0x401921FB60000000
%59 = call i64 @cos(float %58)
%60 = sitofp i64 %59 to float
%61 = fmul float %60, -2.000000e+00
%62 = fmul float %23, 0x401921FB60000000
%63 = call i64 @cos(float %62)
%64 = sitofp i64 %63 to float
%65 = fmul float %64, -2.000000e+00
%66 = fmul float %25, 0x401921FB60000000
%67 = call i64 @cos(float %66)
%68 = sitofp i64 %67 to float
%69 = fmul float %68, -2.000000e+00
%70 = fmul float %27, 0x401921FB60000000
%71 = call i64 @cos(float %70)
%72 = sitofp i64 %71 to float
%73 = fmul float %72, -2.000000e+00
%74 = fmul float %29, 0x401921FB60000000
%75 = call i64 @cos(float %74)
%76 = sitofp i64 %75 to float
%77 = fmul float %76, -2.000000e+00
%78 = fmul float %31, 0x401921FB60000000
%79 = call i64 @cos(float %78)
%80 = sitofp i64 %79 to float
%81 = fmul float %80, -2.000000e+00
%82 = fmul float %33, 0x401921FB60000000
%83 = call i64 @cos(float %82)
%84 = sitofp i64 %83 to float
%85 = fmul float %84, -2.000000e+00
%86 = load float, float* %42
%87 = load float, float* %44
%88 = getelementptr inbounds [6 x float], [6 x float]* %4, i64 0, i64 1
%89 = load float, float* %88
%90 = getelementptr inbounds [6 x float], [6 x float]* %5, i64 0, i64 1
%91 = load float, float* %90
%92 = getelementptr inbounds [6 x float], [6 x float]* %7, i64 0, i64 1
%93 = load float, float* %92
%94 = getelementptr inbounds [6 x float], [6 x float]* %8, i64 0, i64 1
%95 = load float, float* %94
%96 = getelementptr inbounds [6 x float], [6 x float]* %4, i64 0, i64 2
%97 = load float, float* %96
%98 = getelementptr inbounds [6 x float], [6 x float]* %5, i64 0, i64 2
%99 = load float, float* %98
%100 = getelementptr inbounds [6 x float], [6 x float]* %7, i64 0, i64 2
%101 = load float, float* %100
%102 = getelementptr inbounds [6 x float], [6 x float]* %8, i64 0, i64 2
%103 = load float, float* %102
%104 = getelementptr inbounds [6 x float], [6 x float]* %4, i64 0, i64 3
%105 = load float, float* %104
%106 = getelementptr inbounds [6 x float], [6 x float]* %5, i64 0, i64 3
%107 = load float, float* %106
%108 = getelementptr inbounds [6 x float], [6 x float]* %7, i64 0, i64 3
%109 = load float, float* %108
%110 = getelementptr inbounds [6 x float], [6 x float]* %8, i64 0, i64 3
%111 = load float, float* %110
%112 = getelementptr inbounds [6 x float], [6 x float]* %4, i64 0, i64 4
%113 = load float, float* %112
%114 = getelementptr inbounds [6 x float], [6 x float]* %7, i64 0, i64 4
%115 = load float, float* %114
%116 = load float, float* %36
%117 = load float, float* %38
%118 = call float @llvm.fmuladd.f32(float %49, float %116, float 1.000000e+00)
%119 = fadd float %118, %117
%120 = call float @llvm.fmuladd.f32(float %53, float %86, float 1.000000e+00)
%121 = fadd float %120, %87
%122 = call float @llvm.fmuladd.f32(float %57, float %89, float %119)
%123 = fadd float %122, %91
%124 = call float @llvm.fmuladd.f32(float %61, float %93, float %121)
%125 = fadd float %124, %95
%126 = call float @llvm.fmuladd.f32(float %65, float %97, float %123)
%127 = fadd float %126, %99
%128 = call float @llvm.fmuladd.f32(float %69, float %101, float %125)
%129 = fadd float %128, %103
%130 = call float @llvm.fmuladd.f32(float %73, float %105, float %127)
%131 = fadd float %130, %107
%132 = call float @llvm.fmuladd.f32(float %77, float %109, float %129)
%133 = fadd float %132, %111
br label %134
134: ; preds = %2, %134
%135 = phi float [ %116, %2 ], [ %136, %134 ]
%136 = phi float [ 1.000000e+00, %2 ], [ %157, %134 ]
%137 = phi float [ %115, %2 ], [ %138, %134 ]
%138 = phi float [ %133, %2 ], [ %174, %134 ]
%139 = phi float [ %113, %2 ], [ %140, %134 ]
%140 = phi float [ %131, %2 ], [ %172, %134 ]
%141 = phi float [ %109, %2 ], [ %142, %134 ]
%142 = phi float [ %129, %2 ], [ %170, %134 ]
%143 = phi float [ %105, %2 ], [ %144, %134 ]
%144 = phi float [ %127, %2 ], [ %168, %134 ]
%145 = phi float [ %101, %2 ], [ %146, %134 ]
%146 = phi float [ %125, %2 ], [ %166, %134 ]
%147 = phi float [ %97, %2 ], [ %148, %134 ]
%148 = phi float [ %123, %2 ], [ %164, %134 ]
%149 = phi float [ %93, %2 ], [ %150, %134 ]
%150 = phi float [ %121, %2 ], [ %162, %134 ]
%151 = phi float [ %89, %2 ], [ %152, %134 ]
%152 = phi float [ %119, %2 ], [ %160, %134 ]
%153 = phi float [ %86, %2 ], [ %154, %134 ]
%154 = phi float [ 1.000000e+00, %2 ], [ %158, %134 ]
%155 = phi i64 [ 1, %2 ], [ %183, %134 ]
%156 = phi float [ 1.000000e+00, %2 ], [ 0.000000e+00, %134 ]
%157 = fadd float %156, 0.000000e+00
%158 = fsub float 0.000000e+00, %156
%159 = call float @llvm.fmuladd.f32(float %49, float %136, float %157)
%160 = fadd float %159, %135
%161 = call float @llvm.fmuladd.f32(float %53, float %154, float %158)
%162 = fadd float %161, %153
%163 = call float @llvm.fmuladd.f32(float %57, float %152, float %160)
%164 = fadd float %163, %151
%165 = call float @llvm.fmuladd.f32(float %61, float %150, float %162)
%166 = fadd float %165, %149
%167 = call float @llvm.fmuladd.f32(float %65, float %148, float %164)
%168 = fadd float %167, %147
%169 = call float @llvm.fmuladd.f32(float %69, float %146, float %166)
%170 = fadd float %169, %145
%171 = call float @llvm.fmuladd.f32(float %73, float %144, float %168)
%172 = fadd float %171, %143
%173 = call float @llvm.fmuladd.f32(float %77, float %142, float %170)
%174 = fadd float %173, %141
%175 = call float @llvm.fmuladd.f32(float %85, float %138, float %174)
%176 = fadd float %175, %137
%177 = call float @llvm.fmuladd.f32(float %81, float %140, float %172)
%178 = fadd float %177, %139
%179 = fadd float %178, %176
%180 = fmul float %179, -5.000000e-01
%181 = add nsw i64 %155, -1
%182 = getelementptr inbounds float, float* %1, i64 %181
store float %180, float* %182
%183 = add nuw nsw i64 %155, 1
%184 = icmp eq i64 %183, 11
br i1 %184, label %185, label %134
185: ; preds = %134
%186 = getelementptr inbounds [6 x float], [6 x float]* %6, i64 0, i64 3
%187 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 0, i64 3
%188 = getelementptr inbounds [6 x float], [6 x float]* %6, i64 0, i64 2
%189 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 0, i64 2
%190 = getelementptr inbounds [6 x float], [6 x float]* %6, i64 0, i64 1
%191 = getelementptr inbounds [6 x float], [6 x float]* %3, i64 0, i64 1
store float %157, float* %34
store float %158, float* %40
store float %157, float* %36
store float %136, float* %38
store float %160, float* %191
store float %162, float* %190
store float %154, float* %44
store float %158, float* %42
store float %164, float* %189
store float %166, float* %188
store float %152, float* %90
store float %160, float* %88
store float %150, float* %94
store float %162, float* %92
store float %168, float* %187
store float %170, float* %186
store float %148, float* %98
store float %164, float* %96
store float %146, float* %102
store float %166, float* %100
%192 = getelementptr inbounds float, float* %1, i64 9
%193 = load float, float* %192
%194 = fneg float %193
%195 = getelementptr inbounds float, float* %1, i64 10
store float %194, float* %195
%196 = getelementptr inbounds float, float* %1, i64 8
%197 = load float, float* %196
%198 = fneg float %197
store float %198, float* %192
%199 = getelementptr inbounds float, float* %1, i64 5
%200 = getelementptr inbounds float, float* %1, i64 4
%201 = bitcast float* %200 to <4 x float>*
%202 = load <4 x float>, <4 x float>* %201
%203 = fneg <4 x float> %202
%204 = bitcast float* %199 to <4 x float>*
store <4 x float> %203, <4 x float>* %204
%205 = getelementptr inbounds float, float* %1, i64 1
%206 = bitcast float* %1 to <4 x float>*
%207 = load <4 x float>, <4 x float>* %206
%208 = fneg <4 x float> %207
%209 = bitcast float* %205 to <4 x float>*
store <4 x float> %208, <4 x float>* %209
store float 1.000000e+00, float* %1
ret void
}