#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fa_atlvs(float *, int, float *, float *, float *, float *);
int /*<<< orphan*/ fa_atlvs_hp(double *, int, double *, double *, double *,
                               double *);
int /*<<< orphan*/ fa_autocorr(float *, int, int, float *);
int /*<<< orphan*/ fa_autocorr_hp(double *, int, int, double *);
int /*<<< orphan*/ fa_levinson(float *, int, float *, float *, float *);
int /*<<< orphan*/ fa_levinson_hp(double *, int, double *, double *, double *);
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ sin(int);
int main(int argc, char *argv[]) {
  int i;
  int p;
  float x[200];
  float r[14 + 1];
  float a[14 + 1], kcof[14 + 1];
  float err;
  double x1[200];
  double r1[14 + 1];
  double a1[14 + 1], kcof1[14 + 1];
  double err1;
  float b[14];
  float a3[14], k3[14];
  float err3;
  double b1[14];
  double a4[14], k4[14];
  double err4;
  p = 14;
  for (i = 0; i < 200; i++) {
    x[i] = (float)(sin(2 * 3.1415926 * i / 200));
    x1[i] = (double)x[i];
  }
  fa_autocorr_hp(x1, 200, p, r1);
  fa_levinson_hp(r1, p, a1, kcof1, &err1);
  fa_autocorr(x, 200, p, r);
  fa_levinson(r, p, a, kcof, &err);
  for (i = 0; i <= p; i++)
    printf("a[%d]=%f, a1[%d]=%f\n", i, a[i], i, a1[i]);
  printf("\n");
  for (i = 0; i <= p; i++)
    printf("k[%d]=%f, k1[%d]=%f\n", i, kcof[i], i, kcof1[i]);
  printf("\n");
  printf("err=%f, err1=%f\n", err, err1);
  printf("\n");
  for (i = 0; i < p; i++)
    b1[i] = -r1[i + 1];
  fa_atlvs_hp(r1, p, b1, a4, k4, &err4);
  for (i = 0; i < p; i++)
    b[i] = -r[i + 1];
  fa_atlvs(r, p, b, a3, k3, &err3);
  for (i = 0; i < p; i++)
    printf("a3[%d]=%f, a4[%d]=%f\n", i, a3[i], i, a4[i]);
  printf("\n");
  for (i = 0; i < p; i++)
    printf("k3[%d]=%f, k4[%d]=%f\n", i, k3[i], i, k4[i]);
  printf("\n");
  printf("err3=%f, err4=%f\n", err3, err4);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe00,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0xe,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0xc8,-0x14(%rbp)
jge    1218 <main+0x98>
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  0xe47(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0xe33(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1080 <sin@plt>
cvtsi2ss %rax,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0x340(%rbp,%rax,4)
ff ff
movslq -0x14(%rbp),%rax
movss  -0x340(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xa50(%rbp,%rax,8)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a7 <main+0x27>
lea    -0xa50(%rbp),%rdi
mov    -0x18(%rbp),%edx
lea    -0xad0(%rbp),%rcx
mov    $0xc8,%esi
call   10a0 <fa_autocorr_hp@plt>
lea    -0xad0(%rbp),%rdi
mov    -0x18(%rbp),%esi
lea    -0xb50(%rbp),%rdx
lea    -0xbd0(%rbp),%rcx
lea    -0xbd8(%rbp),%r8
call   1050 <fa_levinson_hp@plt>
lea    -0x340(%rbp),%rdi
mov    -0x18(%rbp),%edx
lea    -0x380(%rbp),%rcx
mov    $0xc8,%esi
call   1030 <fa_autocorr@plt>
lea    -0x380(%rbp),%rdi
mov    -0x18(%rbp),%esi
lea    -0x3c0(%rbp),%rdx
lea    -0x400(%rbp),%rcx
lea    -0x404(%rbp),%r8
call   1090 <fa_levinson@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     12e9 <main+0x169>
mov    -0x14(%rbp),%esi
movslq -0x14(%rbp),%rax
movss  -0x3c0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
mov    -0x14(%rbp),%edx
movslq -0x14(%rbp),%rax
movsd  -0xb50(%rbp,%rax,8),%xmm1
ff ff
lea    0xd3c(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    129d <main+0x11d>
lea    0xd59(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     134a <main+0x1ca>
mov    -0x14(%rbp),%esi
movslq -0x14(%rbp),%rax
movss  -0x400(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
mov    -0x14(%rbp),%edx
movslq -0x14(%rbp),%rax
movsd  -0xbd0(%rbp,%rax,8),%xmm1
ff ff
lea    0xcf0(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12fe <main+0x17e>
lea    0xcf8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movss  -0x404(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xbd8(%rbp),%xmm1
ff
lea    0xcc7(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xcc8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13de <main+0x25e>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movsd  -0xad0(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movslq -0x14(%rbp),%rax
movsd  %xmm0,-0xd10(%rbp,%rax,8)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    138f <main+0x20f>
lea    -0xad0(%rbp),%rdi
mov    -0x18(%rbp),%esi
lea    -0xd10(%rbp),%rdx
lea    -0xd80(%rbp),%rcx
lea    -0xdf0(%rbp),%r8
lea    -0xdf8(%rbp),%r9
call   1070 <fa_atlvs_hp@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1455 <main+0x2d5>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
movss  -0x380(%rbp,%rax,4),%xmm0
ff ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movslq -0x14(%rbp),%rax
movss  %xmm0,-0xc10(%rbp,%rax,4)
ff ff
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1410 <main+0x290>
lea    -0x380(%rbp),%rdi
mov    -0x18(%rbp),%esi
lea    -0xc10(%rbp),%rdx
lea    -0xc50(%rbp),%rcx
lea    -0xc90(%rbp),%r8
lea    -0xc94(%rbp),%r9
call   1060 <fa_atlvs@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    14d3 <main+0x353>
mov    -0x14(%rbp),%esi
movslq -0x14(%rbp),%rax
movss  -0xc50(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
mov    -0x14(%rbp),%edx
movslq -0x14(%rbp),%rax
movsd  -0xd80(%rbp,%rax,8),%xmm1
ff ff
lea    0xb8d(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1487 <main+0x307>
lea    0xb6f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1534 <main+0x3b4>
mov    -0x14(%rbp),%esi
movslq -0x14(%rbp),%rax
movss  -0xc90(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
mov    -0x14(%rbp),%edx
movslq -0x14(%rbp),%rax
movsd  -0xdf0(%rbp,%rax,8),%xmm1
ff ff
lea    0xb42(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14e8 <main+0x368>
lea    0xb0e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movss  -0xc94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  -0xdf8(%rbp),%xmm1
ff
lea    0xb1a(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xade(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0xe00,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
sub    $0xdd0,%rsp
xor    %ebx,%ebx
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mulsd  0xe51(%rip),%xmm0
divsd  0xe51(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1090 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x470(%rsp,%rbx,4)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x790(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0xc8,%rbx
jne    11a0 <main+0x10>
lea    0x790(%rsp),%rdi
lea    0x3f0(%rsp),%r15
mov    $0xc8,%esi
mov    $0xe,%edx
mov    %r15,%rcx
call   10b0 <fa_autocorr_hp@plt>
lea    0x280(%rsp),%rdx
lea    0x200(%rsp),%rcx
lea    0x118(%rsp),%r8
mov    %r15,%rdi
mov    $0xe,%esi
call   1060 <fa_levinson_hp@plt>
lea    0x470(%rsp),%rdi
lea    0x340(%rsp),%r14
mov    $0xc8,%esi
mov    $0xe,%edx
mov    %r14,%rcx
call   1040 <fa_autocorr@plt>
lea    0xd0(%rsp),%rdx
lea    0x90(%rsp),%rcx
lea    0xc(%rsp),%r8
mov    %r14,%rdi
mov    $0xe,%esi
call   10a0 <fa_levinson@plt>
movss  0xd0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x280(%rsp),%xmm1
lea    0xd9d(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xd4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x288(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xd8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x290(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xdc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x298(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x3,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xe0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2a0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x4,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xe4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2a8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x5,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xe8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2b0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x6,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xec(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2b8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x7,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xf0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2c0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x8,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xf4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2c8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x9,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xf8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2d0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0xa,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xfc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2d8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0xb,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x100(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2e0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0xc,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x104(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2e8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0xd,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x108(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2f0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xe,%esi
mov    $0xe,%edx
mov    $0x2,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x90(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x200(%rsp),%xmm1
lea    0xb31(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x94(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x208(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x98(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x210(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x9c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x218(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x3,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xa0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x220(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x4,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xa4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x228(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x5,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xa8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x230(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x6,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xac(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x238(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x7,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xb0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x240(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x8,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xb4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x248(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x9,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xb8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x250(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0xa,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xbc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x258(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0xb,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xc0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x260(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0xc,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xc4(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x268(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0xd,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0xc8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x270(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xe,%esi
mov    $0xe,%edx
mov    $0x2,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x118(%rsp),%xmm1
lea    0x8c8(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movaps 0x866(%rip),%xmm0
movups 0x3f8(%rsp),%xmm1
movups 0x408(%rsp),%xmm2
movups 0x418(%rsp),%xmm3
movups 0x428(%rsp),%xmm4
xorps  %xmm0,%xmm1
movaps %xmm1,0x380(%rsp)
xorps  %xmm0,%xmm2
movaps %xmm2,0x390(%rsp)
xorps  %xmm0,%xmm3
movaps %xmm3,0x3a0(%rsp)
xorps  %xmm0,%xmm4
movaps %xmm4,0x3b0(%rsp)
movups 0x438(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x3c0(%rsp)
movups 0x448(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x3d0(%rsp)
movups 0x458(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x3e0(%rsp)
lea    0x380(%rsp),%rdx
lea    0x190(%rsp),%rcx
lea    0x120(%rsp),%r8
lea    0x110(%rsp),%r9
mov    %r15,%rdi
mov    $0xe,%esi
call   1080 <fa_atlvs_hp@plt>
movaps 0x7bd(%rip),%xmm0
movups 0x344(%rsp),%xmm1
movups 0x354(%rsp),%xmm2
movups 0x364(%rsp),%xmm3
xorps  %xmm0,%xmm1
movaps %xmm1,0x300(%rsp)
xorps  %xmm0,%xmm2
movaps %xmm2,0x310(%rsp)
xorps  %xmm0,%xmm3
movaps %xmm3,0x320(%rsp)
movss  0x374(%rsp),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x330(%rsp)
movss  0x378(%rsp),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x334(%rsp)
lea    0x300(%rsp),%rdx
lea    0x50(%rsp),%rcx
lea    0x10(%rsp),%r8
lea    0x8(%rsp),%r9
mov    %r14,%rdi
mov    $0xe,%esi
call   1070 <fa_atlvs@plt>
movss  0x50(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x190(%rsp),%xmm1
lea    0x767(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x54(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x198(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x58(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1a0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x5c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1a8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x3,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x60(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1b0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x4,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x64(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1b8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x5,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x68(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x6,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x6c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1c8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x7,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x70(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x8,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x74(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x9,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x78(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0xa,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x7c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0xb,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x80(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1f0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0xc,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x84(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1f8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0xd,%edx
mov    $0x2,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x120(%rsp),%xmm1
lea    0x54a(%rip),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x128(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x130(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x138(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x3,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x140(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x4,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x148(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x5,%esi
mov    $0x5,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x150(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x6,%esi
mov    $0x6,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x2c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x158(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x7,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x160(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x8,%esi
mov    $0x8,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x168(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x9,%esi
mov    $0x9,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x38(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x170(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xa,%esi
mov    $0xa,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x178(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xb,%esi
mov    $0xb,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x40(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x180(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xc,%esi
mov    $0xc,%edx
mov    $0x2,%al
call   1050 <printf@plt>
movss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x188(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0xd,%esi
mov    $0xd,%edx
mov    $0x2,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x110(%rsp),%xmm1
lea    0x333(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0xdd0,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [21 x i8] c"a[%d]=%f, a1[%d]=%f\0A\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [21 x i8] c"k[%d]=%f, k1[%d]=%f\0A\00"
@.str.3 = [17 x i8] c"err=%f, err1=%f\0A\00"
@.str.4 = [22 x i8] c"a3[%d]=%f, a4[%d]=%f\0A\00"
@.str.5 = [22 x i8] c"k3[%d]=%f, k4[%d]=%f\0A\00"
@.str.6 = [18 x i8] c"err3=%f, err4=%f\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca [200 x float]
%9 = alloca [15 x float]
%10 = alloca [15 x float]
%11 = alloca [15 x float]
%12 = alloca float
%13 = alloca [200 x double]
%14 = alloca [15 x double]
%15 = alloca [15 x double]
%16 = alloca [15 x double]
%17 = alloca double
%18 = alloca [14 x float]
%19 = alloca [14 x float]
%20 = alloca [14 x float]
%21 = alloca float
%22 = alloca [14 x double]
%23 = alloca [14 x double]
%24 = alloca [14 x double]
%25 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 14, i32* %7
store i32 0, i32* %6
br label %26
26: ; preds = %48, %2
%27 = load i32, i32* %6
%28 = icmp slt i32 %27, 200
br i1 %28, label %29, label %51
29: ; preds = %26
%30 = load i32, i32* %6
%31 = sitofp i32 %30 to double
%32 = fmul double 0x401921FB4D12D84A, %31
%33 = fdiv double %32, 2.000000e+02
%34 = fptosi double %33 to i32
%35 = call i64 @sin(i32 %34)
%36 = sitofp i64 %35 to float
%37 = load i32, i32* %6
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [200 x float], [200 x float]* %8, i64 0, i64 %38
store float %36, float* %39
%40 = load i32, i32* %6
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [200 x float], [200 x float]* %8, i64 0, i64 %41
%43 = load float, float* %42
%44 = fpext float %43 to double
%45 = load i32, i32* %6
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [200 x double], [200 x double]* %13, i64 0, i64 %46
store double %44, double* %47
br label %48
48: ; preds = %29
%49 = load i32, i32* %6
%50 = add nsw i32 %49, 1
store i32 %50, i32* %6
br label %26
51: ; preds = %26
%52 = getelementptr inbounds [200 x double], [200 x double]* %13, i64 0, i64 0
%53 = load i32, i32* %7
%54 = getelementptr inbounds [15 x double], [15 x double]* %14, i64 0, i64 0
%55 = call i32 @fa_autocorr_hp(double* %52, i32 200, i32 %53, double* %54)
%56 = getelementptr inbounds [15 x double], [15 x double]* %14, i64 0, i64 0
%57 = load i32, i32* %7
%58 = getelementptr inbounds [15 x double], [15 x double]* %15, i64 0, i64 0
%59 = getelementptr inbounds [15 x double], [15 x double]* %16, i64 0, i64 0
%60 = call i32 @fa_levinson_hp(double* %56, i32 %57, double* %58, double* %59, double* %17)
%61 = getelementptr inbounds [200 x float], [200 x float]* %8, i64 0, i64 0
%62 = load i32, i32* %7
%63 = getelementptr inbounds [15 x float], [15 x float]* %9, i64 0, i64 0
%64 = call i32 @fa_autocorr(float* %61, i32 200, i32 %62, float* %63)
%65 = getelementptr inbounds [15 x float], [15 x float]* %9, i64 0, i64 0
%66 = load i32, i32* %7
%67 = getelementptr inbounds [15 x float], [15 x float]* %10, i64 0, i64 0
%68 = getelementptr inbounds [15 x float], [15 x float]* %11, i64 0, i64 0
%69 = call i32 @fa_levinson(float* %65, i32 %66, float* %67, float* %68, float* %12)
store i32 0, i32* %6
br label %70
70: ; preds = %87, %51
%71 = load i32, i32* %6
%72 = load i32, i32* %7
%73 = icmp sle i32 %71, %72
br i1 %73, label %74, label %90
74: ; preds = %70
%75 = load i32, i32* %6
%76 = load i32, i32* %6
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [15 x float], [15 x float]* %10, i64 0, i64 %77
%79 = load float, float* %78
%80 = fpext float %79 to double
%81 = load i32, i32* %6
%82 = load i32, i32* %6
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [15 x double], [15 x double]* %15, i64 0, i64 %83
%85 = load double, double* %84
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), i32 %75, double %80, i32 %81, double %85)
br label %87
87: ; preds = %74
%88 = load i32, i32* %6
%89 = add nsw i32 %88, 1
store i32 %89, i32* %6
br label %70
90: ; preds = %70
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %6
br label %92
92: ; preds = %109, %90
%93 = load i32, i32* %6
%94 = load i32, i32* %7
%95 = icmp sle i32 %93, %94
br i1 %95, label %96, label %112
96: ; preds = %92
%97 = load i32, i32* %6
%98 = load i32, i32* %6
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [15 x float], [15 x float]* %11, i64 0, i64 %99
%101 = load float, float* %100
%102 = fpext float %101 to double
%103 = load i32, i32* %6
%104 = load i32, i32* %6
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [15 x double], [15 x double]* %16, i64 0, i64 %105
%107 = load double, double* %106
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), i32 %97, double %102, i32 %103, double %107)
br label %109
109: ; preds = %96
%110 = load i32, i32* %6
%111 = add nsw i32 %110, 1
store i32 %111, i32* %6
br label %92
112: ; preds = %92
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%114 = load float, float* %12
%115 = fpext float %114 to double
%116 = load double, double* %17
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), double %115, double %116)
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %6
br label %119
119: ; preds = %133, %112
%120 = load i32, i32* %6
%121 = load i32, i32* %7
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %136
123: ; preds = %119
%124 = load i32, i32* %6
%125 = add nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [15 x double], [15 x double]* %14, i64 0, i64 %126
%128 = load double, double* %127
%129 = fneg double %128
%130 = load i32, i32* %6
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [14 x double], [14 x double]* %22, i64 0, i64 %131
store double %129, double* %132
br label %133
133: ; preds = %123
%134 = load i32, i32* %6
%135 = add nsw i32 %134, 1
store i32 %135, i32* %6
br label %119
136: ; preds = %119
%137 = getelementptr inbounds [15 x double], [15 x double]* %14, i64 0, i64 0
%138 = load i32, i32* %7
%139 = getelementptr inbounds [14 x double], [14 x double]* %22, i64 0, i64 0
%140 = getelementptr inbounds [14 x double], [14 x double]* %23, i64 0, i64 0
%141 = getelementptr inbounds [14 x double], [14 x double]* %24, i64 0, i64 0
%142 = call i32 @fa_atlvs_hp(double* %137, i32 %138, double* %139, double* %140, double* %141, double* %25)
store i32 0, i32* %6
br label %143
143: ; preds = %157, %136
%144 = load i32, i32* %6
%145 = load i32, i32* %7
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %160
147: ; preds = %143
%148 = load i32, i32* %6
%149 = add nsw i32 %148, 1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [15 x float], [15 x float]* %9, i64 0, i64 %150
%152 = load float, float* %151
%153 = fneg float %152
%154 = load i32, i32* %6
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [14 x float], [14 x float]* %18, i64 0, i64 %155
store float %153, float* %156
br label %157
157: ; preds = %147
%158 = load i32, i32* %6
%159 = add nsw i32 %158, 1
store i32 %159, i32* %6
br label %143
160: ; preds = %143
%161 = getelementptr inbounds [15 x float], [15 x float]* %9, i64 0, i64 0
%162 = load i32, i32* %7
%163 = getelementptr inbounds [14 x float], [14 x float]* %18, i64 0, i64 0
%164 = getelementptr inbounds [14 x float], [14 x float]* %19, i64 0, i64 0
%165 = getelementptr inbounds [14 x float], [14 x float]* %20, i64 0, i64 0
%166 = call i32 @fa_atlvs(float* %161, i32 %162, float* %163, float* %164, float* %165, float* %21)
store i32 0, i32* %6
br label %167
167: ; preds = %184, %160
%168 = load i32, i32* %6
%169 = load i32, i32* %7
%170 = icmp slt i32 %168, %169
br i1 %170, label %171, label %187
171: ; preds = %167
%172 = load i32, i32* %6
%173 = load i32, i32* %6
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [14 x float], [14 x float]* %19, i64 0, i64 %174
%176 = load float, float* %175
%177 = fpext float %176 to double
%178 = load i32, i32* %6
%179 = load i32, i32* %6
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [14 x double], [14 x double]* %23, i64 0, i64 %180
%182 = load double, double* %181
%183 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i32 %172, double %177, i32 %178, double %182)
br label %184
184: ; preds = %171
%185 = load i32, i32* %6
%186 = add nsw i32 %185, 1
store i32 %186, i32* %6
br label %167
187: ; preds = %167
%188 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %6
br label %189
189: ; preds = %206, %187
%190 = load i32, i32* %6
%191 = load i32, i32* %7
%192 = icmp slt i32 %190, %191
br i1 %192, label %193, label %209
193: ; preds = %189
%194 = load i32, i32* %6
%195 = load i32, i32* %6
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [14 x float], [14 x float]* %20, i64 0, i64 %196
%198 = load float, float* %197
%199 = fpext float %198 to double
%200 = load i32, i32* %6
%201 = load i32, i32* %6
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [14 x double], [14 x double]* %24, i64 0, i64 %202
%204 = load double, double* %203
%205 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0), i32 %194, double %199, i32 %200, double %204)
br label %206
206: ; preds = %193
%207 = load i32, i32* %6
%208 = add nsw i32 %207, 1
store i32 %208, i32* %6
br label %189
209: ; preds = %189
%210 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%211 = load float, float* %21
%212 = fpext float %211 to double
%213 = load double, double* %25
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.6, i64 0, i64 0), double %212, double %213)
%215 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
ret i32 0
}

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