#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*/ c;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
double hamming(int);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, int);
double sinc(double);
void gentbl_hapn4800(FILE *f) {
  int i, j, k, l;
  float s;
  float c[40];
  float min, max;
  fprintf(f, "\n/*\n * hapn4800 specific tables\n */\n\n");
  min = max = 0;
  memset(c, 0, sizeof(c));
  for (i = 0; i < 24; i++)
    c[8 + i] = sinc(1.5 * ((i - 11.5) / 8.0)) * hamming(i / 23.0) / 2.4;
  for (i = 0; i < 24; i++)
    c[i] -= c[i + 8];
  fprintf(f, "static unsigned char hapn48_txfilt_8[] = {\n\t");
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 16; j++) {
      for (k = 1, s = 0, l = i; k < 16; k <<= 1, l += 8) {
        if (j & k)
          s += c[l];
        else
          s -= c[l];
      }
      if (s > max)
        max = s;
      if (s < min)
        min = s;
      fprintf(f, "%4d", (int)(128 + 127 * s));
      if (i < 7 || j < 15)
        fprintf(f, ",%s", (j & 7) == 7 ? "\n\t" : "");
    }
  }
  fprintf(f, "\n};\n\n");
  min = max = 0;
  memset(c, 0, sizeof(c));
  for (i = 0; i < 30; i++)
    c[10 + i] = sinc(1.5 * ((i - 14.5) / 10.0)) * hamming(i / 29.0) / 2.4;
  for (i = 0; i < 30; i++)
    c[i] -= c[i + 10];
  fprintf(f, "static unsigned char hapn48_txfilt_10[] = {\n\t");
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 16; j++) {
      for (k = 1, s = 0, l = i; k < 16; k <<= 1, l += 10) {
        if (j & k)
          s += c[l];
        else
          s -= c[l];
      }
      if (s > max)
        max = s;
      if (s < min)
        min = s;
      fprintf(f, "%4d", (int)(128 + 127 * s));
      if (i < 9 || j < 15)
        fprintf(f, ",%s", (j & 7) == 7 ? "\n\t" : "");
    }
  }
  fprintf(f, "\n};\n\n");
  min = max = 0;
  memset(c, 0, sizeof(c));
  for (i = 0; i < 25; i++)
    c[i] = sinc(1.4 * ((i - 12.0) / 8.0)) * hamming(i / 24.0) / 6.3;
  for (i = 0; i < 25; i++)
    for (j = 1; j < 8; j++)
      c[i] += c[i + j];
  fprintf(f, "static unsigned char hapn48_txfilt_pm8[] = {\n\t");
  for (i = 0; i < 8; i++) {
    for (j = 0; j < 16; j++) {
      for (k = 1, s = 0, l = i; k < 16; k <<= 1, l += 8) {
        if (j & k)
          s += c[l];
        else
          s -= c[l];
      }
      if (s > max)
        max = s;
      if (s < min)
        min = s;
      fprintf(f, "%4d", (int)(128 + 127 * s));
      if (i < 7 || j < 15)
        fprintf(f, ",%s", (j & 7) == 7 ? "\n\t" : "");
    }
  }
  fprintf(f, "\n};\n\n");
  min = max = 0;
  memset(c, 0, sizeof(c));
  for (i = 0; i < 31; i++)
    c[10 + i] = sinc(1.4 * ((i - 15.0) / 10.0)) * hamming(i / 30.0) / 7.9;
  for (i = 0; i < 31; i++)
    for (j = 1; j < 10; j++)
      c[i] += c[i + j];
  fprintf(f, "static unsigned char hapn48_txfilt_pm10[] = {\n\t");
  for (i = 0; i < 10; i++) {
    for (j = 0; j < 16; j++) {
      for (k = 1, s = 0, l = i; k < 16; k <<= 1, l += 10) {
        if (j & k)
          s += c[l];
        else
          s -= c[l];
      }
      if (s > max)
        max = s;
      if (s < min)
        min = s;
      fprintf(f, "%4d", (int)(128 + 127 * s));
      if (i < 9 || j < 15)
        fprintf(f, ",%s", (j & 7) == 7 ? "\n\t" : "");
    }
  }
  fprintf(f, "\n};\n\n");
}


x86 assembly (clang, -O0):
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xf26(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x18,-0xc(%rbp)
jge    1229 <gentbl_hapn4800+0xe9>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xed0(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xe8c(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  0xea0(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0xe92(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0xe4e(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xc(%rbp),%eax
add    $0x8,%eax
cltq
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1191 <gentbl_hapn4800+0x51>
movl   $0x0,-0xc(%rbp)
cmpl   $0x18,-0xc(%rbp)
jge    1273 <gentbl_hapn4800+0x133>
mov    -0xc(%rbp),%eax
add    $0x8,%eax
cltq
movss  -0xc0(%rbp,%rax,4),%xmm1
ff ff
movslq -0xc(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1230 <gentbl_hapn4800+0xf0>
mov    -0x8(%rbp),%rdi
lea    0xe28(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    1404 <gentbl_hapn4800+0x2c4>
movl   $0x0,-0x10(%rbp)
cmpl   $0x10,-0x10(%rbp)
jge    13f1 <gentbl_hapn4800+0x2b1>
movl   $0x1,-0x14(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    1328 <gentbl_hapn4800+0x1e8>
mov    -0x10(%rbp),%eax
and    -0x14(%rbp),%eax
cmp    $0x0,%eax
je     12f1 <gentbl_hapn4800+0x1b1>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    130c <gentbl_hapn4800+0x1cc>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm1
ff ff
movss  -0x1c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1311 <gentbl_hapn4800+0x1d1>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
jmp    12bc <gentbl_hapn4800+0x17c>
movss  -0x1c(%rbp),%xmm0
ucomiss -0xc8(%rbp),%xmm0
jbe    1347 <gentbl_hapn4800+0x207>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x1c(%rbp),%xmm1
movss  -0xc4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    136a <gentbl_hapn4800+0x22a>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x8(%rbp),%rdi
movss  -0x1c(%rbp),%xmm0
movss  0xc85(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0xc7d(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edx
lea    0xd3d(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
cmpl   $0x7,-0xc(%rbp)
jl     13b1 <gentbl_hapn4800+0x271>
cmpl   $0xf,-0x10(%rbp)
jge    13de <gentbl_hapn4800+0x29e>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%ecx
and    $0x7,%ecx
lea    0xd4c(%rip),%rdx
lea    0xd43(%rip),%rax
cmp    $0x7,%ecx
cmove  %rax,%rdx
lea    0xd00(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    13e3 <gentbl_hapn4800+0x2a3>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    129d <gentbl_hapn4800+0x15d>
jmp    13f6 <gentbl_hapn4800+0x2b6>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    128c <gentbl_hapn4800+0x14c>
mov    -0x8(%rbp),%rdi
lea    0xccc(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x1e,-0xc(%rbp)
jge    14de <gentbl_hapn4800+0x39e>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xc0b(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xbb7(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  0xbeb(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,-0xd8(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0xbc5(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
movaps %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0xb99(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xc(%rbp),%eax
add    $0xa,%eax
cltq
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1446 <gentbl_hapn4800+0x306>
movl   $0x0,-0xc(%rbp)
cmpl   $0x1e,-0xc(%rbp)
jge    1528 <gentbl_hapn4800+0x3e8>
mov    -0xc(%rbp),%eax
add    $0xa,%eax
cltq
movss  -0xc0(%rbp,%rax,4),%xmm1
ff ff
movslq -0xc(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14e5 <gentbl_hapn4800+0x3a5>
mov    -0x8(%rbp),%rdi
lea    0xbae(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0xa,-0xc(%rbp)
jge    16b9 <gentbl_hapn4800+0x579>
movl   $0x0,-0x10(%rbp)
cmpl   $0x10,-0x10(%rbp)
jge    16a6 <gentbl_hapn4800+0x566>
movl   $0x1,-0x14(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    15dd <gentbl_hapn4800+0x49d>
mov    -0x10(%rbp),%eax
and    -0x14(%rbp),%eax
cmp    $0x0,%eax
je     15a6 <gentbl_hapn4800+0x466>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    15c1 <gentbl_hapn4800+0x481>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm1
ff ff
movss  -0x1c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    15c6 <gentbl_hapn4800+0x486>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x18(%rbp)
jmp    1571 <gentbl_hapn4800+0x431>
movss  -0x1c(%rbp),%xmm0
ucomiss -0xc8(%rbp),%xmm0
jbe    15fc <gentbl_hapn4800+0x4bc>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x1c(%rbp),%xmm1
movss  -0xc4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    161f <gentbl_hapn4800+0x4df>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x8(%rbp),%rdi
movss  -0x1c(%rbp),%xmm0
movss  0x9d0(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x9c8(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edx
lea    0xa88(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
cmpl   $0x9,-0xc(%rbp)
jl     1666 <gentbl_hapn4800+0x526>
cmpl   $0xf,-0x10(%rbp)
jge    1693 <gentbl_hapn4800+0x553>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%ecx
and    $0x7,%ecx
lea    0xa97(%rip),%rdx
lea    0xa8e(%rip),%rax
cmp    $0x7,%ecx
cmove  %rax,%rdx
lea    0xa4b(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1698 <gentbl_hapn4800+0x558>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1552 <gentbl_hapn4800+0x412>
jmp    16ab <gentbl_hapn4800+0x56b>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1541 <gentbl_hapn4800+0x401>
mov    -0x8(%rbp),%rdi
lea    0xa17(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x19,-0xc(%rbp)
jge    178f <gentbl_hapn4800+0x64f>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0x936(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x922(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  0x8ee(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x8f0(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x8c4(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0xc(%rbp),%rax
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16fb <gentbl_hapn4800+0x5bb>
movl   $0x0,-0xc(%rbp)
cmpl   $0x19,-0xc(%rbp)
jge    17f9 <gentbl_hapn4800+0x6b9>
movl   $0x1,-0x10(%rbp)
cmpl   $0x8,-0x10(%rbp)
jge    17e6 <gentbl_hapn4800+0x6a6>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
movslq -0xc(%rbp),%rax
addss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    17a7 <gentbl_hapn4800+0x667>
jmp    17eb <gentbl_hapn4800+0x6ab>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1796 <gentbl_hapn4800+0x656>
mov    -0x8(%rbp),%rdi
lea    0x90b(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x8,-0xc(%rbp)
jge    198a <gentbl_hapn4800+0x84a>
movl   $0x0,-0x10(%rbp)
cmpl   $0x10,-0x10(%rbp)
jge    1977 <gentbl_hapn4800+0x837>
movl   $0x1,-0x14(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    18ae <gentbl_hapn4800+0x76e>
mov    -0x10(%rbp),%eax
and    -0x14(%rbp),%eax
cmp    $0x0,%eax
je     1877 <gentbl_hapn4800+0x737>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1892 <gentbl_hapn4800+0x752>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm1
ff ff
movss  -0x1c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1897 <gentbl_hapn4800+0x757>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x18(%rbp)
jmp    1842 <gentbl_hapn4800+0x702>
movss  -0x1c(%rbp),%xmm0
ucomiss -0xc8(%rbp),%xmm0
jbe    18cd <gentbl_hapn4800+0x78d>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x1c(%rbp),%xmm1
movss  -0xc4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    18f0 <gentbl_hapn4800+0x7b0>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x8(%rbp),%rdi
movss  -0x1c(%rbp),%xmm0
movss  0x6ff(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x6f7(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edx
lea    0x7b7(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
cmpl   $0x7,-0xc(%rbp)
jl     1937 <gentbl_hapn4800+0x7f7>
cmpl   $0xf,-0x10(%rbp)
jge    1964 <gentbl_hapn4800+0x824>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%ecx
and    $0x7,%ecx
lea    0x7c6(%rip),%rdx
lea    0x7bd(%rip),%rax
cmp    $0x7,%ecx
cmove  %rax,%rdx
lea    0x77a(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1969 <gentbl_hapn4800+0x829>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1823 <gentbl_hapn4800+0x6e3>
jmp    197c <gentbl_hapn4800+0x83c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1812 <gentbl_hapn4800+0x6d2>
mov    -0x8(%rbp),%rdi
lea    0x746(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
lea    -0xc0(%rbp),%rdi
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x1f,-0xc(%rbp)
jge    1a64 <gentbl_hapn4800+0x924>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0x645(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0x631(%rip),%xmm0
divsd  %xmm0,%xmm1
movsd  0x61d(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,-0xe8(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x5f7(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
movaps %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  0x5cb(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0xc(%rbp),%eax
add    $0xa,%eax
cltq
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    19cc <gentbl_hapn4800+0x88c>
movl   $0x0,-0xc(%rbp)
cmpl   $0x1f,-0xc(%rbp)
jge    1ace <gentbl_hapn4800+0x98e>
movl   $0x1,-0x10(%rbp)
cmpl   $0xa,-0x10(%rbp)
jge    1abb <gentbl_hapn4800+0x97b>
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
movslq -0xc(%rbp),%rax
addss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xc0(%rbp,%rax,4)
ff ff
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1a7c <gentbl_hapn4800+0x93c>
jmp    1ac0 <gentbl_hapn4800+0x980>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1a6b <gentbl_hapn4800+0x92b>
mov    -0x8(%rbp),%rdi
lea    0x665(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0xa,-0xc(%rbp)
jge    1c5f <gentbl_hapn4800+0xb1f>
movl   $0x0,-0x10(%rbp)
cmpl   $0x10,-0x10(%rbp)
jge    1c4c <gentbl_hapn4800+0xb0c>
movl   $0x1,-0x14(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    1b83 <gentbl_hapn4800+0xa43>
mov    -0x10(%rbp),%eax
and    -0x14(%rbp),%eax
cmp    $0x0,%eax
je     1b4c <gentbl_hapn4800+0xa0c>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
addss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1b67 <gentbl_hapn4800+0xa27>
movslq -0x18(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm1
ff ff
movss  -0x1c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
jmp    1b6c <gentbl_hapn4800+0xa2c>
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0xa,%eax
mov    %eax,-0x18(%rbp)
jmp    1b17 <gentbl_hapn4800+0x9d7>
movss  -0x1c(%rbp),%xmm0
ucomiss -0xc8(%rbp),%xmm0
jbe    1ba2 <gentbl_hapn4800+0xa62>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x1c(%rbp),%xmm1
movss  -0xc4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1bc5 <gentbl_hapn4800+0xa85>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x8(%rbp),%rdi
movss  -0x1c(%rbp),%xmm0
movss  0x42a(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x422(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edx
lea    0x4e2(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
cmpl   $0x9,-0xc(%rbp)
jl     1c0c <gentbl_hapn4800+0xacc>
cmpl   $0xf,-0x10(%rbp)
jge    1c39 <gentbl_hapn4800+0xaf9>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%ecx
and    $0x7,%ecx
lea    0x4f1(%rip),%rdx
lea    0x4e8(%rip),%rax
cmp    $0x7,%ecx
cmove  %rax,%rdx
lea    0x4a5(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
jmp    1c3e <gentbl_hapn4800+0xafe>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1af8 <gentbl_hapn4800+0x9b8>
jmp    1c51 <gentbl_hapn4800+0xb11>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1ae7 <gentbl_hapn4800+0x9a7>
mov    -0x8(%rbp),%rdi
lea    0x471(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdi,%r13
lea    0xf19(%rip),%rdi
mov    $0x25,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0xb0(%rsp)
addsd  0xe58(%rip),%xmm0
mulsd  0xe58(%rip),%xmm0
mulsd  0xe58(%rip),%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xb0(%rsp),%xmm0
divsd  0xe41(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
mulsd  0xa8(%rsp),%xmm0
divsd  0xe2f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x18,%rbx
jne    1190 <gentbl_hapn4800+0x40>
movaps (%rsp),%xmm0
movaps 0x10(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
movaps 0x30(%rsp),%xmm3
subps  %xmm2,%xmm0
movaps %xmm0,(%rsp)
subps  %xmm3,%xmm1
movaps %xmm1,0x10(%rsp)
movaps 0x40(%rsp),%xmm0
subps  %xmm0,%xmm2
movaps %xmm2,0x20(%rsp)
movaps 0x50(%rsp),%xmm1
subps  %xmm1,%xmm3
movaps %xmm3,0x30(%rsp)
subps  0x60(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
subps  0x70(%rsp),%xmm1
movaps %xmm1,0x50(%rsp)
lea    0xe4e(%rip),%rdi
mov    $0x2c,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
lea    0xe62(%rip),%r14
lea    0xe5f(%rip),%r15
xor    %ebp,%ebp
jmp    128e <gentbl_hapn4800+0x13e>
add    $0x1,%rbp
cmp    $0x8,%rbp
je     137a <gentbl_hapn4800+0x22a>
xor    %r12d,%r12d
jmp    12d0 <gentbl_hapn4800+0x180>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12d,%eax
not    %eax
test   $0x7,%al
lea    0xe64(%rip),%rdx
lea    0xe5b(%rip),%rax
cmove  %rax,%rdx
mov    %r13,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
add    $0x1,%r12d
cmp    $0x10,%r12d
je     1280 <gentbl_hapn4800+0x130>
test   $0x1,%r12b
jne    1310 <gentbl_hapn4800+0x1c0>
xorps  %xmm0,%xmm0
subss  (%rsp,%rbp,4),%xmm0
test   $0x2,%r12b
je     1323 <gentbl_hapn4800+0x1d3>
addss  0x20(%rsp,%rbp,4),%xmm0
test   $0x4,%r12b
je     132f <gentbl_hapn4800+0x1df>
addss  0x40(%rsp,%rbp,4),%xmm0
test   $0x8,%r12b
je     133b <gentbl_hapn4800+0x1eb>
addss  0x60(%rsp,%rbp,4),%xmm0
jmp    1341 <gentbl_hapn4800+0x1f1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rsp,%rbp,4),%xmm0
addss  0xd63(%rip),%xmm0
test   $0x2,%r12b
jne    12e4 <gentbl_hapn4800+0x194>
subss  0x20(%rsp,%rbp,4),%xmm0
test   $0x4,%r12b
jne    12f0 <gentbl_hapn4800+0x1a0>
subss  0x40(%rsp,%rbp,4),%xmm0
test   $0x8,%r12b
jne    12fc <gentbl_hapn4800+0x1ac>
subss  0x60(%rsp,%rbp,4),%xmm0
mulss  0xd2f(%rip),%xmm0
addss  0xd2b(%rip),%xmm0
cvttss2si %xmm0,%edx
mov    %r13,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
cmp    $0x7,%ebp
jb     12a0 <gentbl_hapn4800+0x150>
cmp    $0xe,%r12d
ja     12c6 <gentbl_hapn4800+0x176>
jmp    12a0 <gentbl_hapn4800+0x150>
lea    0xd5e(%rip),%rdi
mov    $0x5,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0xb0(%rsp)
addsd  0xc60(%rip),%xmm0
divsd  0xc60(%rip),%xmm0
mulsd  0xc38(%rip),%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xb0(%rsp),%xmm0
divsd  0xc41(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
mulsd  0xa8(%rsp),%xmm0
divsd  0xc0f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x28(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x1e,%rbx
jne    13b0 <gentbl_hapn4800+0x260>
movups 0x28(%rsp),%xmm0
movaps (%rsp),%xmm1
subps  %xmm0,%xmm1
movaps 0x10(%rsp),%xmm0
movaps 0x20(%rsp),%xmm2
movaps %xmm1,(%rsp)
movups 0x38(%rsp),%xmm1
subps  %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
movups 0x48(%rsp),%xmm0
subps  %xmm0,%xmm2
movaps %xmm2,0x20(%rsp)
movups 0x58(%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
subps  %xmm0,%xmm1
movaps %xmm1,0x30(%rsp)
movups 0x68(%rsp),%xmm0
movaps 0x40(%rsp),%xmm1
subps  %xmm0,%xmm1
movaps %xmm1,0x40(%rsp)
movups 0x78(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
subps  %xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
movups 0x88(%rsp),%xmm0
movaps 0x60(%rsp),%xmm1
subps  %xmm0,%xmm1
movaps %xmm1,0x60(%rsp)
movss  0x70(%rsp),%xmm0
subss  0x98(%rsp),%xmm0
movss  %xmm0,0x70(%rsp)
movss  0x74(%rsp),%xmm0
subss  0x9c(%rsp),%xmm0
movss  %xmm0,0x74(%rsp)
lea    0xc10(%rip),%rdi
mov    $0x2d,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
lea    0xbe9(%rip),%r14
lea    0xbe6(%rip),%r15
xor    %ebp,%ebp
lea    0xc12(%rip),%r12
jmp    150e <gentbl_hapn4800+0x3be>
add    $0x1,%rbp
cmp    $0xa,%rbp
je     15e6 <gentbl_hapn4800+0x496>
xor    %ebx,%ebx
jmp    1546 <gentbl_hapn4800+0x3f6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%eax
not    %eax
test   $0x7,%al
lea    0xbe5(%rip),%rdx
cmove  %r12,%rdx
mov    %r13,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
add    $0x1,%ebx
cmp    $0x10,%ebx
je     1500 <gentbl_hapn4800+0x3b0>
test   $0x1,%bl
jne    1580 <gentbl_hapn4800+0x430>
xorps  %xmm0,%xmm0
subss  (%rsp,%rbp,4),%xmm0
test   $0x2,%bl
je     1592 <gentbl_hapn4800+0x442>
addss  0x28(%rsp,%rbp,4),%xmm0
test   $0x4,%bl
je     159d <gentbl_hapn4800+0x44d>
addss  0x50(%rsp,%rbp,4),%xmm0
test   $0x8,%bl
je     15a8 <gentbl_hapn4800+0x458>
addss  0x78(%rsp,%rbp,4),%xmm0
jmp    15ae <gentbl_hapn4800+0x45e>
cs nopw 0x0(%rax,%rax,1)
movss  (%rsp,%rbp,4),%xmm0
addss  0xaf3(%rip),%xmm0
test   $0x2,%bl
jne    1558 <gentbl_hapn4800+0x408>
subss  0x28(%rsp,%rbp,4),%xmm0
test   $0x4,%bl
jne    1563 <gentbl_hapn4800+0x413>
subss  0x50(%rsp,%rbp,4),%xmm0
test   $0x8,%bl
jne    156e <gentbl_hapn4800+0x41e>
subss  0x78(%rsp,%rbp,4),%xmm0
mulss  0xac2(%rip),%xmm0
addss  0xabe(%rip),%xmm0
cvttss2si %xmm0,%edx
mov    %r13,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
cmp    $0x9,%ebp
jb     1520 <gentbl_hapn4800+0x3d0>
cmp    $0xe,%ebx
ja     153e <gentbl_hapn4800+0x3ee>
jmp    1520 <gentbl_hapn4800+0x3d0>
lea    0xaf2(%rip),%rdi
mov    $0x5,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0xb0(%rsp)
addsd  0xa18(%rip),%xmm0
mulsd  0x9d8(%rip),%xmm0
mulsd  0xa10(%rip),%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xb0(%rsp),%xmm0
divsd  0x9f9(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
mulsd  0xa8(%rsp),%xmm0
divsd  0x9e7(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x19,%rbx
jne    1610 <gentbl_hapn4800+0x4c0>
movups 0x4(%rsp),%xmm1
movss  (%rsp),%xmm0
movlhps %xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
addps  %xmm1,%xmm0
movups 0x8(%rsp),%xmm2
addps  %xmm0,%xmm2
movups 0xc(%rsp),%xmm0
addps  %xmm2,%xmm0
addps  0x10(%rsp),%xmm0
movups 0x14(%rsp),%xmm2
addps  %xmm2,%xmm0
movups 0x18(%rsp),%xmm3
addps  %xmm3,%xmm0
movups 0x1c(%rsp),%xmm4
addps  %xmm4,%xmm0
movaps %xmm0,(%rsp)
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
addps  %xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm4,%xmm1
addps  0x20(%rsp),%xmm1
movups 0x24(%rsp),%xmm0
addps  %xmm0,%xmm1
movups 0x28(%rsp),%xmm3
addps  %xmm3,%xmm1
movups 0x2c(%rsp),%xmm4
addps  %xmm4,%xmm1
movaps %xmm1,0x10(%rsp)
shufps $0x3,%xmm0,%xmm2
shufps $0x98,%xmm0,%xmm2
addps  %xmm0,%xmm2
addps  %xmm3,%xmm2
addps  %xmm4,%xmm2
addps  0x30(%rsp),%xmm2
movups 0x34(%rsp),%xmm1
addps  %xmm2,%xmm1
movups 0x38(%rsp),%xmm2
addps  %xmm1,%xmm2
movups 0x3c(%rsp),%xmm1
addps  %xmm2,%xmm1
movaps %xmm1,0x20(%rsp)
movups 0x34(%rsp),%xmm1
movups 0x38(%rsp),%xmm2
movups 0x3c(%rsp),%xmm3
movups 0x44(%rsp),%xmm4
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
addps  %xmm1,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
addps  0x40(%rsp),%xmm0
addps  %xmm4,%xmm0
movups 0x48(%rsp),%xmm2
addps  %xmm0,%xmm2
movups 0x4c(%rsp),%xmm0
addps  %xmm2,%xmm0
movaps %xmm0,0x30(%rsp)
movups 0x44(%rsp),%xmm0
movups 0x48(%rsp),%xmm2
movups 0x4c(%rsp),%xmm3
movups 0x54(%rsp),%xmm4
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
addps  %xmm0,%xmm1
addps  %xmm2,%xmm1
addps  %xmm3,%xmm1
addps  0x50(%rsp),%xmm1
addps  %xmm4,%xmm1
movups 0x58(%rsp),%xmm2
addps  %xmm1,%xmm2
movups 0x5c(%rsp),%xmm1
addps  %xmm2,%xmm1
movaps %xmm1,0x40(%rsp)
movups 0x54(%rsp),%xmm1
movups 0x58(%rsp),%xmm2
movups 0x5c(%rsp),%xmm3
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
addps  %xmm1,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
addps  0x60(%rsp),%xmm0
movups 0x64(%rsp),%xmm2
addps  %xmm2,%xmm0
movups 0x68(%rsp),%xmm2
addps  %xmm0,%xmm2
movups 0x6c(%rsp),%xmm0
addps  %xmm2,%xmm0
movaps %xmm0,0x50(%rsp)
shufps $0xff,%xmm1,%xmm1
addss  0x64(%rsp),%xmm1
addss  0x68(%rsp),%xmm1
addss  0x6c(%rsp),%xmm1
addss  0x70(%rsp),%xmm1
addss  0x74(%rsp),%xmm1
addss  0x78(%rsp),%xmm1
addss  0x7c(%rsp),%xmm1
movss  %xmm1,0x60(%rsp)
lea    0x8e3(%rip),%rdi
mov    $0x2e,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
lea    0x88e(%rip),%r14
lea    0x88b(%rip),%r15
xor    %ebp,%ebp
jmp    186e <gentbl_hapn4800+0x71e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    $0x8,%rbp
je     1946 <gentbl_hapn4800+0x7f6>
xor    %ebx,%ebx
jmp    18a6 <gentbl_hapn4800+0x756>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%eax
not    %eax
test   $0x7,%al
lea    0x885(%rip),%rdx
cmove  %r12,%rdx
mov    %r13,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
add    $0x1,%ebx
cmp    $0x10,%ebx
je     1860 <gentbl_hapn4800+0x710>
test   $0x1,%bl
jne    18e0 <gentbl_hapn4800+0x790>
xorps  %xmm0,%xmm0
subss  (%rsp,%rbp,4),%xmm0
test   $0x2,%bl
je     18f2 <gentbl_hapn4800+0x7a2>
addss  0x20(%rsp,%rbp,4),%xmm0
test   $0x4,%bl
je     18fd <gentbl_hapn4800+0x7ad>
addss  0x40(%rsp,%rbp,4),%xmm0
test   $0x8,%bl
je     1908 <gentbl_hapn4800+0x7b8>
addss  0x60(%rsp,%rbp,4),%xmm0
jmp    190e <gentbl_hapn4800+0x7be>
cs nopw 0x0(%rax,%rax,1)
movss  (%rsp,%rbp,4),%xmm0
addss  0x793(%rip),%xmm0
test   $0x2,%bl
jne    18b8 <gentbl_hapn4800+0x768>
subss  0x20(%rsp,%rbp,4),%xmm0
test   $0x4,%bl
jne    18c3 <gentbl_hapn4800+0x773>
subss  0x40(%rsp,%rbp,4),%xmm0
test   $0x8,%bl
jne    18ce <gentbl_hapn4800+0x77e>
subss  0x60(%rsp,%rbp,4),%xmm0
mulss  0x762(%rip),%xmm0
addss  0x75e(%rip),%xmm0
cvttss2si %xmm0,%edx
mov    %r13,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
cmp    $0x7,%ebp
jb     1880 <gentbl_hapn4800+0x730>
cmp    $0xe,%ebx
ja     189e <gentbl_hapn4800+0x74e>
jmp    1880 <gentbl_hapn4800+0x730>
lea    0x792(%rip),%rdi
mov    $0x5,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
mov    %rsp,%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0xa0,%edx
call   1030 <memset@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0xb0(%rsp)
addsd  0x6d8(%rip),%xmm0
divsd  0x6a0(%rip),%xmm0
mulsd  0x6b0(%rip),%xmm0
call   1060 <sinc@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xb0(%rsp),%xmm0
divsd  0x6b1(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1050 <hamming@plt>
mulsd  0xa8(%rsp),%xmm0
divsd  0x69f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x28(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x1f,%rbx
jne    1970 <gentbl_hapn4800+0x820>
movups 0x4(%rsp),%xmm1
movss  (%rsp),%xmm0
movlhps %xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
addps  %xmm1,%xmm0
movups 0x8(%rsp),%xmm2
addps  %xmm0,%xmm2
movups 0xc(%rsp),%xmm3
addps  %xmm2,%xmm3
addps  0x10(%rsp),%xmm3
movups 0x14(%rsp),%xmm0
addps  %xmm0,%xmm3
movups 0x18(%rsp),%xmm2
addps  %xmm2,%xmm3
movups 0x1c(%rsp),%xmm4
addps  %xmm4,%xmm3
movaps 0x20(%rsp),%xmm5
addps  %xmm5,%xmm3
movups 0x24(%rsp),%xmm6
addps  %xmm6,%xmm3
movaps %xmm3,(%rsp)
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
addps  %xmm0,%xmm1
addps  %xmm2,%xmm1
addps  %xmm4,%xmm1
addps  %xmm5,%xmm1
addps  %xmm6,%xmm1
movups 0x28(%rsp),%xmm2
addps  %xmm1,%xmm2
movups 0x2c(%rsp),%xmm1
addps  %xmm2,%xmm1
addps  0x30(%rsp),%xmm1
movups 0x34(%rsp),%xmm2
addps  %xmm1,%xmm2
movaps %xmm2,0x10(%rsp)
movups 0x24(%rsp),%xmm1
movups 0x28(%rsp),%xmm2
movups 0x2c(%rsp),%xmm3
movups 0x34(%rsp),%xmm4
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
addps  %xmm1,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
addps  0x30(%rsp),%xmm0
addps  %xmm4,%xmm0
movups 0x38(%rsp),%xmm2
addps  %xmm0,%xmm2
movups 0x3c(%rsp),%xmm0
addps  %xmm2,%xmm0
addps  0x40(%rsp),%xmm0
movups 0x44(%rsp),%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,0x20(%rsp)
movups 0x34(%rsp),%xmm0
movups 0x38(%rsp),%xmm2
movups 0x3c(%rsp),%xmm3
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
addps  %xmm0,%xmm1
addps  %xmm2,%xmm1
addps  %xmm3,%xmm1
addps  0x40(%rsp),%xmm1
movups 0x44(%rsp),%xmm2
addps  %xmm2,%xmm1
movups 0x48(%rsp),%xmm2
addps  %xmm1,%xmm2
movups 0x4c(%rsp),%xmm1
addps  %xmm2,%xmm1
addps  0x50(%rsp),%xmm1
movups 0x54(%rsp),%xmm2
addps  %xmm1,%xmm2
movaps %xmm2,0x30(%rsp)
movups 0x44(%rsp),%xmm1
movups 0x48(%rsp),%xmm2
movups 0x4c(%rsp),%xmm3
movups 0x54(%rsp),%xmm4
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
addps  %xmm1,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
addps  0x50(%rsp),%xmm0
addps  %xmm4,%xmm0
movups 0x58(%rsp),%xmm2
addps  %xmm0,%xmm2
movups 0x5c(%rsp),%xmm0
addps  %xmm2,%xmm0
addps  0x60(%rsp),%xmm0
movups 0x64(%rsp),%xmm2
addps  %xmm0,%xmm2
movaps %xmm2,0x40(%rsp)
movups 0x54(%rsp),%xmm2
movups 0x58(%rsp),%xmm0
movups 0x5c(%rsp),%xmm3
movups 0x64(%rsp),%xmm4
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
addps  %xmm2,%xmm1
addps  %xmm0,%xmm1
addps  %xmm3,%xmm1
addps  0x60(%rsp),%xmm1
addps  %xmm4,%xmm1
movups 0x68(%rsp),%xmm0
addps  %xmm1,%xmm0
movups 0x6c(%rsp),%xmm1
addps  %xmm0,%xmm1
addps  0x70(%rsp),%xmm1
movups 0x74(%rsp),%xmm0
addps  %xmm1,%xmm0
movaps %xmm0,0x50(%rsp)
movups 0x64(%rsp),%xmm0
movups 0x68(%rsp),%xmm1
movups 0x6c(%rsp),%xmm3
shufps $0x3,%xmm0,%xmm2
shufps $0x98,%xmm0,%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
addps  %xmm3,%xmm2
addps  0x70(%rsp),%xmm2
movups 0x74(%rsp),%xmm1
addps  %xmm1,%xmm2
movups 0x78(%rsp),%xmm1
addps  %xmm2,%xmm1
movups 0x7c(%rsp),%xmm2
addps  %xmm1,%xmm2
addps  0x80(%rsp),%xmm2
movups 0x84(%rsp),%xmm1
addps  %xmm2,%xmm1
movaps %xmm1,0x60(%rsp)
shufps $0xff,%xmm0,%xmm0
movss  0x74(%rsp),%xmm1
addss  %xmm1,%xmm0
addss  0x78(%rsp),%xmm0
addss  0x7c(%rsp),%xmm0
addss  0x80(%rsp),%xmm0
addss  0x84(%rsp),%xmm0
addss  0x88(%rsp),%xmm0
addss  0x8c(%rsp),%xmm0
addss  0x90(%rsp),%xmm0
addss  0x94(%rsp),%xmm0
movss  %xmm0,0x70(%rsp)
movss  0x78(%rsp),%xmm0
addss  %xmm0,%xmm1
addss  0x7c(%rsp),%xmm1
addss  0x80(%rsp),%xmm1
addss  0x84(%rsp),%xmm1
addss  0x88(%rsp),%xmm1
addss  0x8c(%rsp),%xmm1
addss  0x90(%rsp),%xmm1
addss  0x94(%rsp),%xmm1
addss  0x98(%rsp),%xmm1
movss  %xmm1,0x74(%rsp)
addss  0x7c(%rsp),%xmm0
addss  0x80(%rsp),%xmm0
addss  0x84(%rsp),%xmm0
addss  0x88(%rsp),%xmm0
addss  0x8c(%rsp),%xmm0
addss  0x90(%rsp),%xmm0
addss  0x94(%rsp),%xmm0
addss  0x98(%rsp),%xmm0
addss  0x9c(%rsp),%xmm0
movss  %xmm0,0x78(%rsp)
lea    0x438(%rip),%rdi
mov    $0x2f,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
lea    0x3b4(%rip),%r14
lea    0x3b1(%rip),%r15
xor    %ebp,%ebp
jmp    1d3e <gentbl_hapn4800+0xbee>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    $0xa,%rbp
je     1e16 <gentbl_hapn4800+0xcc6>
xor    %ebx,%ebx
jmp    1d76 <gentbl_hapn4800+0xc26>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%eax
not    %eax
test   $0x7,%al
lea    0x3b5(%rip),%rdx
cmove  %r12,%rdx
mov    %r13,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
add    $0x1,%ebx
cmp    $0x10,%ebx
je     1d30 <gentbl_hapn4800+0xbe0>
test   $0x1,%bl
jne    1db0 <gentbl_hapn4800+0xc60>
xorps  %xmm0,%xmm0
subss  (%rsp,%rbp,4),%xmm0
test   $0x2,%bl
je     1dc2 <gentbl_hapn4800+0xc72>
addss  0x28(%rsp,%rbp,4),%xmm0
test   $0x4,%bl
je     1dcd <gentbl_hapn4800+0xc7d>
addss  0x50(%rsp,%rbp,4),%xmm0
test   $0x8,%bl
je     1dd8 <gentbl_hapn4800+0xc88>
addss  0x78(%rsp,%rbp,4),%xmm0
jmp    1dde <gentbl_hapn4800+0xc8e>
cs nopw 0x0(%rax,%rax,1)
movss  (%rsp,%rbp,4),%xmm0
addss  0x2c3(%rip),%xmm0
test   $0x2,%bl
jne    1d88 <gentbl_hapn4800+0xc38>
subss  0x28(%rsp,%rbp,4),%xmm0
test   $0x4,%bl
jne    1d93 <gentbl_hapn4800+0xc43>
subss  0x50(%rsp,%rbp,4),%xmm0
test   $0x8,%bl
jne    1d9e <gentbl_hapn4800+0xc4e>
subss  0x78(%rsp,%rbp,4),%xmm0
mulss  0x292(%rip),%xmm0
addss  0x28e(%rip),%xmm0
cvttss2si %xmm0,%edx
mov    %r13,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <fprintf@plt>
cmp    $0x9,%ebp
jb     1d50 <gentbl_hapn4800+0xc00>
cmp    $0xe,%ebx
ja     1d6e <gentbl_hapn4800+0xc1e>
jmp    1d50 <gentbl_hapn4800+0xc00>
lea    0x2c2(%rip),%rdi
mov    $0x5,%esi
mov    $0x1,%edx
mov    %r13,%rcx
call   1070 <fwrite@plt>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [38 x i8] c"\0A/*\0A * hapn4800 specific tables\0A */\0A\0A\00"
@.str.1 = [45 x i8] c"static unsigned char hapn48_txfilt_8[] = {\0A\09\00"
@.str.2 = [4 x i8] c"%4d\00"
@.str.3 = [4 x i8] c",%s\00"
@.str.4 = [3 x i8] c"\0A\09\00"
@.str.5 = [1 x i8] zeroinitializer
@.str.6 = [6 x i8] c"\0A};\0A\0A\00"
@.str.7 = [46 x i8] c"static unsigned char hapn48_txfilt_10[] = {\0A\09\00"
@.str.8 = [47 x i8] c"static unsigned char hapn48_txfilt_pm8[] = {\0A\09\00"
@.str.9 = [48 x i8] c"static unsigned char hapn48_txfilt_pm10[] = {\0A\09\00"
define void @gentbl_hapn4800(i32* nocapture %0) {
%2 = alloca [40 x float]
%3 = bitcast [40 x float]* %2 to i8*
%4 = tail call i64 @fwrite(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0), i64 37, i64 1, i32* %0)
%5 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 0
%6 = call i32 @memset(float* %5, i32 0, i32 160)
br label %7
7: ; preds = %1, %7
%8 = phi i64 [ 0, %1 ], [ %23, %7 ]
%9 = trunc i64 %8 to i32
%10 = sitofp i32 %9 to double
%11 = fadd double %10, -1.150000e+01
%12 = fmul double %11, 1.250000e-01
%13 = fmul double %12, 1.500000e+00
%14 = call double @sinc(double %13)
%15 = fdiv double %10, 2.300000e+01
%16 = fptosi double %15 to i32
%17 = call double @hamming(i32 %16)
%18 = fmul double %14, %17
%19 = fdiv double %18, 2.400000e+00
%20 = fptrunc double %19 to float
%21 = add nuw nsw i64 %8, 8
%22 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %21
store float %20, float* %22
%23 = add nuw nsw i64 %8, 1
%24 = icmp eq i64 %23, 24
br i1 %24, label %25, label %7
25: ; preds = %7
%26 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%27 = bitcast float* %26 to <4 x float>*
%28 = load <4 x float>, <4 x float>* %27
%29 = bitcast [40 x float]* %2 to <4 x float>*
%30 = load <4 x float>, <4 x float>* %29
%31 = fsub <4 x float> %30, %28
%32 = bitcast [40 x float]* %2 to <4 x float>*
store <4 x float> %31, <4 x float>* %32
%33 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%34 = bitcast float* %33 to <4 x float>*
%35 = load <4 x float>, <4 x float>* %34
%36 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 4
%37 = bitcast float* %36 to <4 x float>*
%38 = load <4 x float>, <4 x float>* %37
%39 = fsub <4 x float> %38, %35
%40 = bitcast float* %36 to <4 x float>*
store <4 x float> %39, <4 x float>* %40
%41 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%42 = bitcast float* %41 to <4 x float>*
%43 = load <4 x float>, <4 x float>* %42
%44 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%45 = bitcast float* %44 to <4 x float>*
%46 = load <4 x float>, <4 x float>* %45
%47 = fsub <4 x float> %46, %43
%48 = bitcast float* %44 to <4 x float>*
store <4 x float> %47, <4 x float>* %48
%49 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%50 = bitcast float* %49 to <4 x float>*
%51 = load <4 x float>, <4 x float>* %50
%52 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%53 = bitcast float* %52 to <4 x float>*
%54 = load <4 x float>, <4 x float>* %53
%55 = fsub <4 x float> %54, %51
%56 = bitcast float* %52 to <4 x float>*
store <4 x float> %55, <4 x float>* %56
%57 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = fsub <4 x float> %62, %59
%64 = bitcast float* %60 to <4 x float>*
store <4 x float> %63, <4 x float>* %64
%65 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 28
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = fsub <4 x float> %70, %67
%72 = bitcast float* %68 to <4 x float>*
store <4 x float> %71, <4 x float>* %72
%73 = call i64 @fwrite(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.1, i64 0, i64 0), i64 44, i64 1, i32* %0)
br label %74
74: ; preds = %25, %144
%75 = phi i64 [ 0, %25 ], [ %145, %144 ]
%76 = trunc i64 %75 to i32
%77 = icmp ult i32 %76, 7
%78 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %75
%79 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %75
%80 = add nuw nsw i64 %75, 8
%81 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %80
%82 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %80
%83 = add nuw nsw i64 %75, 16
%84 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %83
%85 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %83
%86 = add nuw nsw i64 %75, 24
%87 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %86
%88 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %86
br label %89
89: ; preds = %74, %141
%90 = phi i32 [ 0, %74 ], [ %142, %141 ]
%91 = and i32 %90, 1
%92 = icmp eq i32 %91, 0
br i1 %92, label %96, label %93
93: ; preds = %89
%94 = load float, float* %78
%95 = fadd float %94, 0.000000e+00
br label %99
96: ; preds = %89
%97 = load float, float* %79
%98 = fsub float 0.000000e+00, %97
br label %99
99: ; preds = %93, %96
%100 = phi float [ %95, %93 ], [ %98, %96 ]
%101 = and i32 %90, 2
%102 = icmp eq i32 %101, 0
br i1 %102, label %106, label %103
103: ; preds = %99
%104 = load float, float* %81
%105 = fadd float %100, %104
br label %109
106: ; preds = %99
%107 = load float, float* %82
%108 = fsub float %100, %107
br label %109
109: ; preds = %106, %103
%110 = phi float [ %105, %103 ], [ %108, %106 ]
%111 = and i32 %90, 4
%112 = icmp eq i32 %111, 0
br i1 %112, label %116, label %113
113: ; preds = %109
%114 = load float, float* %84
%115 = fadd float %110, %114
br label %119
116: ; preds = %109
%117 = load float, float* %85
%118 = fsub float %110, %117
br label %119
119: ; preds = %116, %113
%120 = phi float [ %115, %113 ], [ %118, %116 ]
%121 = and i32 %90, 8
%122 = icmp eq i32 %121, 0
br i1 %122, label %126, label %123
123: ; preds = %119
%124 = load float, float* %87
%125 = fadd float %120, %124
br label %129
126: ; preds = %119
%127 = load float, float* %88
%128 = fsub float %120, %127
br label %129
129: ; preds = %126, %123
%130 = phi float [ %125, %123 ], [ %128, %126 ]
%131 = call float @llvm.fmuladd.f32(float %130, float 1.270000e+02, float 1.280000e+02)
%132 = fptosi float %131 to i32
%133 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %132)
%134 = icmp ult i32 %90, 15
%135 = select i1 %77, i1 true, i1 %134
br i1 %135, label %136, label %141
136: ; preds = %129
%137 = and i32 %90, 7
%138 = icmp eq i32 %137, 7
%139 = select i1 %138, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0)
%140 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i8* %139)
br label %141
141: ; preds = %136, %129
%142 = add nuw nsw i32 %90, 1
%143 = icmp eq i32 %142, 16
br i1 %143, label %144, label %89
144: ; preds = %141
%145 = add nuw nsw i64 %75, 1
%146 = icmp eq i64 %145, 8
br i1 %146, label %147, label %74
147: ; preds = %144
%148 = call i64 @fwrite(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i64 5, i64 1, i32* %0)
%149 = call i32 @memset(float* %5, i32 0, i32 160)
br label %150
150: ; preds = %147, %150
%151 = phi i64 [ 0, %147 ], [ %166, %150 ]
%152 = trunc i64 %151 to i32
%153 = sitofp i32 %152 to double
%154 = fadd double %153, -1.450000e+01
%155 = fdiv double %154, 1.000000e+01
%156 = fmul double %155, 1.500000e+00
%157 = call double @sinc(double %156)
%158 = fdiv double %153, 2.900000e+01
%159 = fptosi double %158 to i32
%160 = call double @hamming(i32 %159)
%161 = fmul double %157, %160
%162 = fdiv double %161, 2.400000e+00
%163 = fptrunc double %162 to float
%164 = add nuw nsw i64 %151, 10
%165 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %164
store float %163, float* %165
%166 = add nuw nsw i64 %151, 1
%167 = icmp eq i64 %166, 30
br i1 %167, label %168, label %150
168: ; preds = %150
%169 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 10
%170 = bitcast float* %169 to <4 x float>*
%171 = load <4 x float>, <4 x float>* %170
%172 = bitcast [40 x float]* %2 to <4 x float>*
%173 = load <4 x float>, <4 x float>* %172
%174 = fsub <4 x float> %173, %171
%175 = bitcast [40 x float]* %2 to <4 x float>*
store <4 x float> %174, <4 x float>* %175
%176 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 14
%177 = bitcast float* %176 to <4 x float>*
%178 = load <4 x float>, <4 x float>* %177
%179 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 4
%180 = bitcast float* %179 to <4 x float>*
%181 = load <4 x float>, <4 x float>* %180
%182 = fsub <4 x float> %181, %178
%183 = bitcast float* %179 to <4 x float>*
store <4 x float> %182, <4 x float>* %183
%184 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 18
%185 = bitcast float* %184 to <4 x float>*
%186 = load <4 x float>, <4 x float>* %185
%187 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%188 = bitcast float* %187 to <4 x float>*
%189 = load <4 x float>, <4 x float>* %188
%190 = fsub <4 x float> %189, %186
%191 = bitcast float* %187 to <4 x float>*
store <4 x float> %190, <4 x float>* %191
%192 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 22
%193 = bitcast float* %192 to <4 x float>*
%194 = load <4 x float>, <4 x float>* %193
%195 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%196 = bitcast float* %195 to <4 x float>*
%197 = load <4 x float>, <4 x float>* %196
%198 = fsub <4 x float> %197, %194
%199 = bitcast float* %195 to <4 x float>*
store <4 x float> %198, <4 x float>* %199
%200 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 26
%201 = bitcast float* %200 to <4 x float>*
%202 = load <4 x float>, <4 x float>* %201
%203 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%204 = bitcast float* %203 to <4 x float>*
%205 = load <4 x float>, <4 x float>* %204
%206 = fsub <4 x float> %205, %202
%207 = bitcast float* %203 to <4 x float>*
store <4 x float> %206, <4 x float>* %207
%208 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 30
%209 = bitcast float* %208 to <4 x float>*
%210 = load <4 x float>, <4 x float>* %209
%211 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%212 = bitcast float* %211 to <4 x float>*
%213 = load <4 x float>, <4 x float>* %212
%214 = fsub <4 x float> %213, %210
%215 = bitcast float* %211 to <4 x float>*
store <4 x float> %214, <4 x float>* %215
%216 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 34
%217 = bitcast float* %216 to <4 x float>*
%218 = load <4 x float>, <4 x float>* %217
%219 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%220 = bitcast float* %219 to <4 x float>*
%221 = load <4 x float>, <4 x float>* %220
%222 = fsub <4 x float> %221, %218
%223 = bitcast float* %219 to <4 x float>*
store <4 x float> %222, <4 x float>* %223
%224 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 38
%225 = load float, float* %224
%226 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 28
%227 = load float, float* %226
%228 = fsub float %227, %225
store float %228, float* %226
%229 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 39
%230 = load float, float* %229
%231 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 29
%232 = load float, float* %231
%233 = fsub float %232, %230
store float %233, float* %231
%234 = call i64 @fwrite(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.7, i64 0, i64 0), i64 45, i64 1, i32* %0)
br label %235
235: ; preds = %168, %305
%236 = phi i64 [ 0, %168 ], [ %306, %305 ]
%237 = trunc i64 %236 to i32
%238 = icmp ult i32 %237, 9
%239 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %236
%240 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %236
%241 = add nuw nsw i64 %236, 10
%242 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %241
%243 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %241
%244 = add nuw nsw i64 %236, 20
%245 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %244
%246 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %244
%247 = add nuw nsw i64 %236, 30
%248 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %247
%249 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %247
br label %250
250: ; preds = %235, %302
%251 = phi i32 [ 0, %235 ], [ %303, %302 ]
%252 = and i32 %251, 1
%253 = icmp eq i32 %252, 0
br i1 %253, label %257, label %254
254: ; preds = %250
%255 = load float, float* %239
%256 = fadd float %255, 0.000000e+00
br label %260
257: ; preds = %250
%258 = load float, float* %240
%259 = fsub float 0.000000e+00, %258
br label %260
260: ; preds = %254, %257
%261 = phi float [ %256, %254 ], [ %259, %257 ]
%262 = and i32 %251, 2
%263 = icmp eq i32 %262, 0
br i1 %263, label %267, label %264
264: ; preds = %260
%265 = load float, float* %242
%266 = fadd float %261, %265
br label %270
267: ; preds = %260
%268 = load float, float* %243
%269 = fsub float %261, %268
br label %270
270: ; preds = %267, %264
%271 = phi float [ %266, %264 ], [ %269, %267 ]
%272 = and i32 %251, 4
%273 = icmp eq i32 %272, 0
br i1 %273, label %277, label %274
274: ; preds = %270
%275 = load float, float* %245
%276 = fadd float %271, %275
br label %280
277: ; preds = %270
%278 = load float, float* %246
%279 = fsub float %271, %278
br label %280
280: ; preds = %277, %274
%281 = phi float [ %276, %274 ], [ %279, %277 ]
%282 = and i32 %251, 8
%283 = icmp eq i32 %282, 0
br i1 %283, label %287, label %284
284: ; preds = %280
%285 = load float, float* %248
%286 = fadd float %281, %285
br label %290
287: ; preds = %280
%288 = load float, float* %249
%289 = fsub float %281, %288
br label %290
290: ; preds = %287, %284
%291 = phi float [ %286, %284 ], [ %289, %287 ]
%292 = call float @llvm.fmuladd.f32(float %291, float 1.270000e+02, float 1.280000e+02)
%293 = fptosi float %292 to i32
%294 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %293)
%295 = icmp ult i32 %251, 15
%296 = select i1 %238, i1 true, i1 %295
br i1 %296, label %297, label %302
297: ; preds = %290
%298 = and i32 %251, 7
%299 = icmp eq i32 %298, 7
%300 = select i1 %299, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0)
%301 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i8* %300)
br label %302
302: ; preds = %297, %290
%303 = add nuw nsw i32 %251, 1
%304 = icmp eq i32 %303, 16
br i1 %304, label %305, label %250
305: ; preds = %302
%306 = add nuw nsw i64 %236, 1
%307 = icmp eq i64 %306, 10
br i1 %307, label %308, label %235
308: ; preds = %305
%309 = call i64 @fwrite(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i64 5, i64 1, i32* %0)
%310 = call i32 @memset(float* %5, i32 0, i32 160)
br label %311
311: ; preds = %308, %311
%312 = phi i64 [ 0, %308 ], [ %326, %311 ]
%313 = trunc i64 %312 to i32
%314 = sitofp i32 %313 to double
%315 = fadd double %314, -1.200000e+01
%316 = fmul double %315, 1.250000e-01
%317 = fmul double %316, 1.400000e+00
%318 = call double @sinc(double %317)
%319 = fdiv double %314, 2.400000e+01
%320 = fptosi double %319 to i32
%321 = call double @hamming(i32 %320)
%322 = fmul double %318, %321
%323 = fdiv double %322, 6.300000e+00
%324 = fptrunc double %323 to float
%325 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %312
store float %324, float* %325
%326 = add nuw nsw i64 %312, 1
%327 = icmp eq i64 %326, 25
br i1 %327, label %328, label %311
328: ; preds = %311
%329 = load float, float* %5
%330 = insertelement <4 x float> poison, float %329, i64 3
%331 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 1
%332 = bitcast float* %331 to <4 x float>*
%333 = load <4 x float>, <4 x float>* %332
%334 = shufflevector <4 x float> %330, <4 x float> %333, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%335 = fadd <4 x float> %333, %334
%336 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 2
%337 = bitcast float* %336 to <4 x float>*
%338 = load <4 x float>, <4 x float>* %337
%339 = fadd <4 x float> %338, %335
%340 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 3
%341 = bitcast float* %340 to <4 x float>*
%342 = load <4 x float>, <4 x float>* %341
%343 = fadd <4 x float> %342, %339
%344 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 4
%345 = bitcast float* %344 to <4 x float>*
%346 = load <4 x float>, <4 x float>* %345
%347 = fadd <4 x float> %346, %343
%348 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 5
%349 = bitcast float* %348 to <4 x float>*
%350 = load <4 x float>, <4 x float>* %349
%351 = fadd <4 x float> %350, %347
%352 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 6
%353 = bitcast float* %352 to <4 x float>*
%354 = load <4 x float>, <4 x float>* %353
%355 = fadd <4 x float> %354, %351
%356 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 7
%357 = bitcast float* %356 to <4 x float>*
%358 = load <4 x float>, <4 x float>* %357
%359 = fadd <4 x float> %358, %355
%360 = bitcast [40 x float]* %2 to <4 x float>*
store <4 x float> %359, <4 x float>* %360
%361 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 4
%362 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 5
%363 = bitcast float* %362 to <4 x float>*
%364 = load <4 x float>, <4 x float>* %363
%365 = shufflevector <4 x float> %333, <4 x float> %364, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%366 = fadd <4 x float> %364, %365
%367 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 6
%368 = bitcast float* %367 to <4 x float>*
%369 = load <4 x float>, <4 x float>* %368
%370 = fadd <4 x float> %369, %366
%371 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 7
%372 = bitcast float* %371 to <4 x float>*
%373 = load <4 x float>, <4 x float>* %372
%374 = fadd <4 x float> %373, %370
%375 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%376 = bitcast float* %375 to <4 x float>*
%377 = load <4 x float>, <4 x float>* %376
%378 = fadd <4 x float> %377, %374
%379 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 9
%380 = bitcast float* %379 to <4 x float>*
%381 = load <4 x float>, <4 x float>* %380
%382 = fadd <4 x float> %381, %378
%383 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 10
%384 = bitcast float* %383 to <4 x float>*
%385 = load <4 x float>, <4 x float>* %384
%386 = fadd <4 x float> %385, %382
%387 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 11
%388 = bitcast float* %387 to <4 x float>*
%389 = load <4 x float>, <4 x float>* %388
%390 = fadd <4 x float> %389, %386
%391 = bitcast float* %361 to <4 x float>*
store <4 x float> %390, <4 x float>* %391
%392 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%393 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 9
%394 = bitcast float* %393 to <4 x float>*
%395 = load <4 x float>, <4 x float>* %394
%396 = shufflevector <4 x float> %364, <4 x float> %395, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%397 = fadd <4 x float> %395, %396
%398 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 10
%399 = bitcast float* %398 to <4 x float>*
%400 = load <4 x float>, <4 x float>* %399
%401 = fadd <4 x float> %400, %397
%402 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 11
%403 = bitcast float* %402 to <4 x float>*
%404 = load <4 x float>, <4 x float>* %403
%405 = fadd <4 x float> %404, %401
%406 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%407 = bitcast float* %406 to <4 x float>*
%408 = load <4 x float>, <4 x float>* %407
%409 = fadd <4 x float> %408, %405
%410 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 13
%411 = bitcast float* %410 to <4 x float>*
%412 = load <4 x float>, <4 x float>* %411
%413 = fadd <4 x float> %412, %409
%414 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 14
%415 = bitcast float* %414 to <4 x float>*
%416 = load <4 x float>, <4 x float>* %415
%417 = fadd <4 x float> %416, %413
%418 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 15
%419 = bitcast float* %418 to <4 x float>*
%420 = load <4 x float>, <4 x float>* %419
%421 = fadd <4 x float> %420, %417
%422 = bitcast float* %392 to <4 x float>*
store <4 x float> %421, <4 x float>* %422
%423 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%424 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 13
%425 = bitcast float* %424 to <4 x float>*
%426 = load <4 x float>, <4 x float>* %425
%427 = shufflevector <4 x float> %395, <4 x float> %426, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%428 = fadd <4 x float> %426, %427
%429 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 14
%430 = bitcast float* %429 to <4 x float>*
%431 = load <4 x float>, <4 x float>* %430
%432 = fadd <4 x float> %431, %428
%433 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 15
%434 = bitcast float* %433 to <4 x float>*
%435 = load <4 x float>, <4 x float>* %434
%436 = fadd <4 x float> %435, %432
%437 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%438 = bitcast float* %437 to <4 x float>*
%439 = load <4 x float>, <4 x float>* %438
%440 = fadd <4 x float> %439, %436
%441 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 17
%442 = bitcast float* %441 to <4 x float>*
%443 = load <4 x float>, <4 x float>* %442
%444 = fadd <4 x float> %443, %440
%445 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 18
%446 = bitcast float* %445 to <4 x float>*
%447 = load <4 x float>, <4 x float>* %446
%448 = fadd <4 x float> %447, %444
%449 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 19
%450 = bitcast float* %449 to <4 x float>*
%451 = load <4 x float>, <4 x float>* %450
%452 = fadd <4 x float> %451, %448
%453 = bitcast float* %423 to <4 x float>*
store <4 x float> %452, <4 x float>* %453
%454 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%455 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 17
%456 = bitcast float* %455 to <4 x float>*
%457 = load <4 x float>, <4 x float>* %456
%458 = shufflevector <4 x float> %426, <4 x float> %457, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%459 = fadd <4 x float> %457, %458
%460 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 18
%461 = bitcast float* %460 to <4 x float>*
%462 = load <4 x float>, <4 x float>* %461
%463 = fadd <4 x float> %462, %459
%464 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 19
%465 = bitcast float* %464 to <4 x float>*
%466 = load <4 x float>, <4 x float>* %465
%467 = fadd <4 x float> %466, %463
%468 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%469 = bitcast float* %468 to <4 x float>*
%470 = load <4 x float>, <4 x float>* %469
%471 = fadd <4 x float> %470, %467
%472 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 21
%473 = bitcast float* %472 to <4 x float>*
%474 = load <4 x float>, <4 x float>* %473
%475 = fadd <4 x float> %474, %471
%476 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 22
%477 = bitcast float* %476 to <4 x float>*
%478 = load <4 x float>, <4 x float>* %477
%479 = fadd <4 x float> %478, %475
%480 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 23
%481 = bitcast float* %480 to <4 x float>*
%482 = load <4 x float>, <4 x float>* %481
%483 = fadd <4 x float> %482, %479
%484 = bitcast float* %454 to <4 x float>*
store <4 x float> %483, <4 x float>* %484
%485 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%486 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 21
%487 = bitcast float* %486 to <4 x float>*
%488 = load <4 x float>, <4 x float>* %487
%489 = shufflevector <4 x float> %457, <4 x float> %488, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%490 = fadd <4 x float> %488, %489
%491 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 22
%492 = bitcast float* %491 to <4 x float>*
%493 = load <4 x float>, <4 x float>* %492
%494 = fadd <4 x float> %493, %490
%495 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 23
%496 = bitcast float* %495 to <4 x float>*
%497 = load <4 x float>, <4 x float>* %496
%498 = fadd <4 x float> %497, %494
%499 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%500 = bitcast float* %499 to <4 x float>*
%501 = load <4 x float>, <4 x float>* %500
%502 = fadd <4 x float> %501, %498
%503 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 25
%504 = bitcast float* %503 to <4 x float>*
%505 = load <4 x float>, <4 x float>* %504
%506 = fadd <4 x float> %505, %502
%507 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 26
%508 = bitcast float* %507 to <4 x float>*
%509 = load <4 x float>, <4 x float>* %508
%510 = fadd <4 x float> %509, %506
%511 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 27
%512 = bitcast float* %511 to <4 x float>*
%513 = load <4 x float>, <4 x float>* %512
%514 = fadd <4 x float> %513, %510
%515 = bitcast float* %485 to <4 x float>*
store <4 x float> %514, <4 x float>* %515
%516 = extractelement <4 x float> %488, i64 3
%517 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%518 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 25
%519 = load float, float* %518
%520 = fadd float %519, %516
%521 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 26
%522 = load float, float* %521
%523 = fadd float %522, %520
%524 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 27
%525 = load float, float* %524
%526 = fadd float %525, %523
%527 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 28
%528 = load float, float* %527
%529 = fadd float %528, %526
%530 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 29
%531 = load float, float* %530
%532 = fadd float %531, %529
%533 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 30
%534 = load float, float* %533
%535 = fadd float %534, %532
%536 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 31
%537 = load float, float* %536
%538 = fadd float %537, %535
store float %538, float* %517
%539 = call i64 @fwrite(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.8, i64 0, i64 0), i64 46, i64 1, i32* %0)
br label %540
540: ; preds = %328, %610
%541 = phi i64 [ 0, %328 ], [ %611, %610 ]
%542 = trunc i64 %541 to i32
%543 = icmp ult i32 %542, 7
%544 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %541
%545 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %541
%546 = add nuw nsw i64 %541, 8
%547 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %546
%548 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %546
%549 = add nuw nsw i64 %541, 16
%550 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %549
%551 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %549
%552 = add nuw nsw i64 %541, 24
%553 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %552
%554 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %552
br label %555
555: ; preds = %540, %607
%556 = phi i32 [ 0, %540 ], [ %608, %607 ]
%557 = and i32 %556, 1
%558 = icmp eq i32 %557, 0
br i1 %558, label %562, label %559
559: ; preds = %555
%560 = load float, float* %544
%561 = fadd float %560, 0.000000e+00
br label %565
562: ; preds = %555
%563 = load float, float* %545
%564 = fsub float 0.000000e+00, %563
br label %565
565: ; preds = %559, %562
%566 = phi float [ %561, %559 ], [ %564, %562 ]
%567 = and i32 %556, 2
%568 = icmp eq i32 %567, 0
br i1 %568, label %572, label %569
569: ; preds = %565
%570 = load float, float* %547
%571 = fadd float %566, %570
br label %575
572: ; preds = %565
%573 = load float, float* %548
%574 = fsub float %566, %573
br label %575
575: ; preds = %572, %569
%576 = phi float [ %571, %569 ], [ %574, %572 ]
%577 = and i32 %556, 4
%578 = icmp eq i32 %577, 0
br i1 %578, label %582, label %579
579: ; preds = %575
%580 = load float, float* %550
%581 = fadd float %576, %580
br label %585
582: ; preds = %575
%583 = load float, float* %551
%584 = fsub float %576, %583
br label %585
585: ; preds = %582, %579
%586 = phi float [ %581, %579 ], [ %584, %582 ]
%587 = and i32 %556, 8
%588 = icmp eq i32 %587, 0
br i1 %588, label %592, label %589
589: ; preds = %585
%590 = load float, float* %553
%591 = fadd float %586, %590
br label %595
592: ; preds = %585
%593 = load float, float* %554
%594 = fsub float %586, %593
br label %595
595: ; preds = %592, %589
%596 = phi float [ %591, %589 ], [ %594, %592 ]
%597 = call float @llvm.fmuladd.f32(float %596, float 1.270000e+02, float 1.280000e+02)
%598 = fptosi float %597 to i32
%599 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %598)
%600 = icmp ult i32 %556, 15
%601 = select i1 %543, i1 true, i1 %600
br i1 %601, label %602, label %607
602: ; preds = %595
%603 = and i32 %556, 7
%604 = icmp eq i32 %603, 7
%605 = select i1 %604, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0)
%606 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i8* %605)
br label %607
607: ; preds = %602, %595
%608 = add nuw nsw i32 %556, 1
%609 = icmp eq i32 %608, 16
br i1 %609, label %610, label %555
610: ; preds = %607
%611 = add nuw nsw i64 %541, 1
%612 = icmp eq i64 %611, 8
br i1 %612, label %613, label %540
613: ; preds = %610
%614 = call i64 @fwrite(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i64 5, i64 1, i32* %0)
%615 = call i32 @memset(float* %5, i32 0, i32 160)
br label %616
616: ; preds = %613, %616
%617 = phi i64 [ 0, %613 ], [ %632, %616 ]
%618 = trunc i64 %617 to i32
%619 = sitofp i32 %618 to double
%620 = fadd double %619, -1.500000e+01
%621 = fdiv double %620, 1.000000e+01
%622 = fmul double %621, 1.400000e+00
%623 = call double @sinc(double %622)
%624 = fdiv double %619, 3.000000e+01
%625 = fptosi double %624 to i32
%626 = call double @hamming(i32 %625)
%627 = fmul double %623, %626
%628 = fdiv double %627, 7.900000e+00
%629 = fptrunc double %628 to float
%630 = add nuw nsw i64 %617, 10
%631 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %630
store float %629, float* %631
%632 = add nuw nsw i64 %617, 1
%633 = icmp eq i64 %632, 31
br i1 %633, label %634, label %616
634: ; preds = %616
%635 = load float, float* %5
%636 = insertelement <4 x float> poison, float %635, i64 3
%637 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 1
%638 = bitcast float* %637 to <4 x float>*
%639 = load <4 x float>, <4 x float>* %638
%640 = shufflevector <4 x float> %636, <4 x float> %639, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%641 = fadd <4 x float> %639, %640
%642 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 2
%643 = bitcast float* %642 to <4 x float>*
%644 = load <4 x float>, <4 x float>* %643
%645 = fadd <4 x float> %644, %641
%646 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 3
%647 = bitcast float* %646 to <4 x float>*
%648 = load <4 x float>, <4 x float>* %647
%649 = fadd <4 x float> %648, %645
%650 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 4
%651 = bitcast float* %650 to <4 x float>*
%652 = load <4 x float>, <4 x float>* %651
%653 = fadd <4 x float> %652, %649
%654 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 5
%655 = bitcast float* %654 to <4 x float>*
%656 = load <4 x float>, <4 x float>* %655
%657 = fadd <4 x float> %656, %653
%658 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 6
%659 = bitcast float* %658 to <4 x float>*
%660 = load <4 x float>, <4 x float>* %659
%661 = fadd <4 x float> %660, %657
%662 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 7
%663 = bitcast float* %662 to <4 x float>*
%664 = load <4 x float>, <4 x float>* %663
%665 = fadd <4 x float> %664, %661
%666 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%667 = bitcast float* %666 to <4 x float>*
%668 = load <4 x float>, <4 x float>* %667
%669 = fadd <4 x float> %668, %665
%670 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 9
%671 = bitcast float* %670 to <4 x float>*
%672 = load <4 x float>, <4 x float>* %671
%673 = fadd <4 x float> %672, %669
%674 = bitcast [40 x float]* %2 to <4 x float>*
store <4 x float> %673, <4 x float>* %674
%675 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 4
%676 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 5
%677 = bitcast float* %676 to <4 x float>*
%678 = load <4 x float>, <4 x float>* %677
%679 = shufflevector <4 x float> %639, <4 x float> %678, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%680 = fadd <4 x float> %678, %679
%681 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 6
%682 = bitcast float* %681 to <4 x float>*
%683 = load <4 x float>, <4 x float>* %682
%684 = fadd <4 x float> %683, %680
%685 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 7
%686 = bitcast float* %685 to <4 x float>*
%687 = load <4 x float>, <4 x float>* %686
%688 = fadd <4 x float> %687, %684
%689 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%690 = bitcast float* %689 to <4 x float>*
%691 = load <4 x float>, <4 x float>* %690
%692 = fadd <4 x float> %691, %688
%693 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 9
%694 = bitcast float* %693 to <4 x float>*
%695 = load <4 x float>, <4 x float>* %694
%696 = fadd <4 x float> %695, %692
%697 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 10
%698 = bitcast float* %697 to <4 x float>*
%699 = load <4 x float>, <4 x float>* %698
%700 = fadd <4 x float> %699, %696
%701 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 11
%702 = bitcast float* %701 to <4 x float>*
%703 = load <4 x float>, <4 x float>* %702
%704 = fadd <4 x float> %703, %700
%705 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%706 = bitcast float* %705 to <4 x float>*
%707 = load <4 x float>, <4 x float>* %706
%708 = fadd <4 x float> %707, %704
%709 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 13
%710 = bitcast float* %709 to <4 x float>*
%711 = load <4 x float>, <4 x float>* %710
%712 = fadd <4 x float> %711, %708
%713 = bitcast float* %675 to <4 x float>*
store <4 x float> %712, <4 x float>* %713
%714 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 8
%715 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 9
%716 = bitcast float* %715 to <4 x float>*
%717 = load <4 x float>, <4 x float>* %716
%718 = shufflevector <4 x float> %678, <4 x float> %717, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%719 = fadd <4 x float> %717, %718
%720 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 10
%721 = bitcast float* %720 to <4 x float>*
%722 = load <4 x float>, <4 x float>* %721
%723 = fadd <4 x float> %722, %719
%724 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 11
%725 = bitcast float* %724 to <4 x float>*
%726 = load <4 x float>, <4 x float>* %725
%727 = fadd <4 x float> %726, %723
%728 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%729 = bitcast float* %728 to <4 x float>*
%730 = load <4 x float>, <4 x float>* %729
%731 = fadd <4 x float> %730, %727
%732 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 13
%733 = bitcast float* %732 to <4 x float>*
%734 = load <4 x float>, <4 x float>* %733
%735 = fadd <4 x float> %734, %731
%736 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 14
%737 = bitcast float* %736 to <4 x float>*
%738 = load <4 x float>, <4 x float>* %737
%739 = fadd <4 x float> %738, %735
%740 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 15
%741 = bitcast float* %740 to <4 x float>*
%742 = load <4 x float>, <4 x float>* %741
%743 = fadd <4 x float> %742, %739
%744 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%745 = bitcast float* %744 to <4 x float>*
%746 = load <4 x float>, <4 x float>* %745
%747 = fadd <4 x float> %746, %743
%748 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 17
%749 = bitcast float* %748 to <4 x float>*
%750 = load <4 x float>, <4 x float>* %749
%751 = fadd <4 x float> %750, %747
%752 = bitcast float* %714 to <4 x float>*
store <4 x float> %751, <4 x float>* %752
%753 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 12
%754 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 13
%755 = bitcast float* %754 to <4 x float>*
%756 = load <4 x float>, <4 x float>* %755
%757 = shufflevector <4 x float> %717, <4 x float> %756, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%758 = fadd <4 x float> %756, %757
%759 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 14
%760 = bitcast float* %759 to <4 x float>*
%761 = load <4 x float>, <4 x float>* %760
%762 = fadd <4 x float> %761, %758
%763 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 15
%764 = bitcast float* %763 to <4 x float>*
%765 = load <4 x float>, <4 x float>* %764
%766 = fadd <4 x float> %765, %762
%767 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%768 = bitcast float* %767 to <4 x float>*
%769 = load <4 x float>, <4 x float>* %768
%770 = fadd <4 x float> %769, %766
%771 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 17
%772 = bitcast float* %771 to <4 x float>*
%773 = load <4 x float>, <4 x float>* %772
%774 = fadd <4 x float> %773, %770
%775 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 18
%776 = bitcast float* %775 to <4 x float>*
%777 = load <4 x float>, <4 x float>* %776
%778 = fadd <4 x float> %777, %774
%779 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 19
%780 = bitcast float* %779 to <4 x float>*
%781 = load <4 x float>, <4 x float>* %780
%782 = fadd <4 x float> %781, %778
%783 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%784 = bitcast float* %783 to <4 x float>*
%785 = load <4 x float>, <4 x float>* %784
%786 = fadd <4 x float> %785, %782
%787 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 21
%788 = bitcast float* %787 to <4 x float>*
%789 = load <4 x float>, <4 x float>* %788
%790 = fadd <4 x float> %789, %786
%791 = bitcast float* %753 to <4 x float>*
store <4 x float> %790, <4 x float>* %791
%792 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 16
%793 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 17
%794 = bitcast float* %793 to <4 x float>*
%795 = load <4 x float>, <4 x float>* %794
%796 = shufflevector <4 x float> %756, <4 x float> %795, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%797 = fadd <4 x float> %795, %796
%798 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 18
%799 = bitcast float* %798 to <4 x float>*
%800 = load <4 x float>, <4 x float>* %799
%801 = fadd <4 x float> %800, %797
%802 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 19
%803 = bitcast float* %802 to <4 x float>*
%804 = load <4 x float>, <4 x float>* %803
%805 = fadd <4 x float> %804, %801
%806 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%807 = bitcast float* %806 to <4 x float>*
%808 = load <4 x float>, <4 x float>* %807
%809 = fadd <4 x float> %808, %805
%810 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 21
%811 = bitcast float* %810 to <4 x float>*
%812 = load <4 x float>, <4 x float>* %811
%813 = fadd <4 x float> %812, %809
%814 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 22
%815 = bitcast float* %814 to <4 x float>*
%816 = load <4 x float>, <4 x float>* %815
%817 = fadd <4 x float> %816, %813
%818 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 23
%819 = bitcast float* %818 to <4 x float>*
%820 = load <4 x float>, <4 x float>* %819
%821 = fadd <4 x float> %820, %817
%822 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%823 = bitcast float* %822 to <4 x float>*
%824 = load <4 x float>, <4 x float>* %823
%825 = fadd <4 x float> %824, %821
%826 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 25
%827 = bitcast float* %826 to <4 x float>*
%828 = load <4 x float>, <4 x float>* %827
%829 = fadd <4 x float> %828, %825
%830 = bitcast float* %792 to <4 x float>*
store <4 x float> %829, <4 x float>* %830
%831 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 20
%832 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 21
%833 = bitcast float* %832 to <4 x float>*
%834 = load <4 x float>, <4 x float>* %833
%835 = shufflevector <4 x float> %795, <4 x float> %834, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%836 = fadd <4 x float> %834, %835
%837 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 22
%838 = bitcast float* %837 to <4 x float>*
%839 = load <4 x float>, <4 x float>* %838
%840 = fadd <4 x float> %839, %836
%841 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 23
%842 = bitcast float* %841 to <4 x float>*
%843 = load <4 x float>, <4 x float>* %842
%844 = fadd <4 x float> %843, %840
%845 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%846 = bitcast float* %845 to <4 x float>*
%847 = load <4 x float>, <4 x float>* %846
%848 = fadd <4 x float> %847, %844
%849 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 25
%850 = bitcast float* %849 to <4 x float>*
%851 = load <4 x float>, <4 x float>* %850
%852 = fadd <4 x float> %851, %848
%853 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 26
%854 = bitcast float* %853 to <4 x float>*
%855 = load <4 x float>, <4 x float>* %854
%856 = fadd <4 x float> %855, %852
%857 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 27
%858 = bitcast float* %857 to <4 x float>*
%859 = load <4 x float>, <4 x float>* %858
%860 = fadd <4 x float> %859, %856
%861 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 28
%862 = bitcast float* %861 to <4 x float>*
%863 = load <4 x float>, <4 x float>* %862
%864 = fadd <4 x float> %863, %860
%865 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 29
%866 = bitcast float* %865 to <4 x float>*
%867 = load <4 x float>, <4 x float>* %866
%868 = fadd <4 x float> %867, %864
%869 = bitcast float* %831 to <4 x float>*
store <4 x float> %868, <4 x float>* %869
%870 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 24
%871 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 25
%872 = bitcast float* %871 to <4 x float>*
%873 = load <4 x float>, <4 x float>* %872
%874 = shufflevector <4 x float> %834, <4 x float> %873, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%875 = fadd <4 x float> %873, %874
%876 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 26
%877 = bitcast float* %876 to <4 x float>*
%878 = load <4 x float>, <4 x float>* %877
%879 = fadd <4 x float> %878, %875
%880 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 27
%881 = bitcast float* %880 to <4 x float>*
%882 = load <4 x float>, <4 x float>* %881
%883 = fadd <4 x float> %882, %879
%884 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 28
%885 = bitcast float* %884 to <4 x float>*
%886 = load <4 x float>, <4 x float>* %885
%887 = fadd <4 x float> %886, %883
%888 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 29
%889 = bitcast float* %888 to <4 x float>*
%890 = load <4 x float>, <4 x float>* %889
%891 = fadd <4 x float> %890, %887
%892 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 30
%893 = bitcast float* %892 to <4 x float>*
%894 = load <4 x float>, <4 x float>* %893
%895 = fadd <4 x float> %894, %891
%896 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 31
%897 = bitcast float* %896 to <4 x float>*
%898 = load <4 x float>, <4 x float>* %897
%899 = fadd <4 x float> %898, %895
%900 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 32
%901 = bitcast float* %900 to <4 x float>*
%902 = load <4 x float>, <4 x float>* %901
%903 = fadd <4 x float> %902, %899
%904 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 33
%905 = bitcast float* %904 to <4 x float>*
%906 = load <4 x float>, <4 x float>* %905
%907 = fadd <4 x float> %906, %903
%908 = bitcast float* %870 to <4 x float>*
store <4 x float> %907, <4 x float>* %908
%909 = extractelement <4 x float> %873, i64 3
%910 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 28
%911 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 29
%912 = load float, float* %911
%913 = fadd float %912, %909
%914 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 30
%915 = load float, float* %914
%916 = fadd float %915, %913
%917 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 31
%918 = load float, float* %917
%919 = fadd float %918, %916
%920 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 32
%921 = load float, float* %920
%922 = fadd float %921, %919
%923 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 33
%924 = load float, float* %923
%925 = fadd float %924, %922
%926 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 34
%927 = load float, float* %926
%928 = fadd float %927, %925
%929 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 35
%930 = load float, float* %929
%931 = fadd float %930, %928
%932 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 36
%933 = load float, float* %932
%934 = fadd float %933, %931
%935 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 37
%936 = load float, float* %935
%937 = fadd float %936, %934
store float %937, float* %910
%938 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 29
%939 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 30
%940 = load float, float* %939
%941 = fadd float %940, %912
%942 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 31
%943 = load float, float* %942
%944 = fadd float %943, %941
%945 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 32
%946 = load float, float* %945
%947 = fadd float %946, %944
%948 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 33
%949 = load float, float* %948
%950 = fadd float %949, %947
%951 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 34
%952 = load float, float* %951
%953 = fadd float %952, %950
%954 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 35
%955 = load float, float* %954
%956 = fadd float %955, %953
%957 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 36
%958 = load float, float* %957
%959 = fadd float %958, %956
%960 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 37
%961 = load float, float* %960
%962 = fadd float %961, %959
%963 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 38
%964 = load float, float* %963
%965 = fadd float %964, %962
store float %965, float* %938
%966 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 30
%967 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 31
%968 = load float, float* %967
%969 = fadd float %968, %940
%970 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 32
%971 = load float, float* %970
%972 = fadd float %971, %969
%973 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 33
%974 = load float, float* %973
%975 = fadd float %974, %972
%976 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 34
%977 = load float, float* %976
%978 = fadd float %977, %975
%979 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 35
%980 = load float, float* %979
%981 = fadd float %980, %978
%982 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 36
%983 = load float, float* %982
%984 = fadd float %983, %981
%985 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 37
%986 = load float, float* %985
%987 = fadd float %986, %984
%988 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 38
%989 = load float, float* %988
%990 = fadd float %989, %987
%991 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 39
%992 = load float, float* %991
%993 = fadd float %992, %990
store float %993, float* %966
%994 = call i64 @fwrite(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.9, i64 0, i64 0), i64 47, i64 1, i32* %0)
br label %995
995: ; preds = %634, %1065
%996 = phi i64 [ 0, %634 ], [ %1066, %1065 ]
%997 = trunc i64 %996 to i32
%998 = icmp ult i32 %997, 9
%999 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %996
%1000 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %996
%1001 = add nuw nsw i64 %996, 10
%1002 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %1001
%1003 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %1001
%1004 = add nuw nsw i64 %996, 20
%1005 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %1004
%1006 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %1004
%1007 = add nuw nsw i64 %996, 30
%1008 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %1007
%1009 = getelementptr inbounds [40 x float], [40 x float]* %2, i64 0, i64 %1007
br label %1010
1010: ; preds = %995, %1062
%1011 = phi i32 [ 0, %995 ], [ %1063, %1062 ]
%1012 = and i32 %1011, 1
%1013 = icmp eq i32 %1012, 0
br i1 %1013, label %1017, label %1014
1014: ; preds = %1010
%1015 = load float, float* %999
%1016 = fadd float %1015, 0.000000e+00
br label %1020
1017: ; preds = %1010
%1018 = load float, float* %1000
%1019 = fsub float 0.000000e+00, %1018
br label %1020
1020: ; preds = %1014, %1017
%1021 = phi float [ %1016, %1014 ], [ %1019, %1017 ]
%1022 = and i32 %1011, 2
%1023 = icmp eq i32 %1022, 0
br i1 %1023, label %1027, label %1024
1024: ; preds = %1020
%1025 = load float, float* %1002
%1026 = fadd float %1021, %1025
br label %1030
1027: ; preds = %1020
%1028 = load float, float* %1003
%1029 = fsub float %1021, %1028
br label %1030
1030: ; preds = %1027, %1024
%1031 = phi float [ %1026, %1024 ], [ %1029, %1027 ]
%1032 = and i32 %1011, 4
%1033 = icmp eq i32 %1032, 0
br i1 %1033, label %1037, label %1034
1034: ; preds = %1030
%1035 = load float, float* %1005
%1036 = fadd float %1031, %1035
br label %1040
1037: ; preds = %1030
%1038 = load float, float* %1006
%1039 = fsub float %1031, %1038
br label %1040
1040: ; preds = %1037, %1034
%1041 = phi float [ %1036, %1034 ], [ %1039, %1037 ]
%1042 = and i32 %1011, 8
%1043 = icmp eq i32 %1042, 0
br i1 %1043, label %1047, label %1044
1044: ; preds = %1040
%1045 = load float, float* %1008
%1046 = fadd float %1041, %1045
br label %1050
1047: ; preds = %1040
%1048 = load float, float* %1009
%1049 = fsub float %1041, %1048
br label %1050
1050: ; preds = %1047, %1044
%1051 = phi float [ %1046, %1044 ], [ %1049, %1047 ]
%1052 = call float @llvm.fmuladd.f32(float %1051, float 1.270000e+02, float 1.280000e+02)
%1053 = fptosi float %1052 to i32
%1054 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %1053)
%1055 = icmp ult i32 %1011, 15
%1056 = select i1 %998, i1 true, i1 %1055
br i1 %1056, label %1057, label %1062
1057: ; preds = %1050
%1058 = and i32 %1011, 7
%1059 = icmp eq i32 %1058, 7
%1060 = select i1 %1059, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.5, i64 0, i64 0)
%1061 = call i32 (i32*, i8*, ...) @fprintf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i8* %1060)
br label %1062
1062: ; preds = %1057, %1050
%1063 = add nuw nsw i32 %1011, 1
%1064 = icmp eq i32 %1063, 16
br i1 %1064, label %1065, label %1010
1065: ; preds = %1062
%1066 = add nuw nsw i64 %996, 1
%1067 = icmp eq i64 %1066, 10
br i1 %1067, label %1068, label %995
1068: ; preds = %1065
%1069 = call i64 @fwrite(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i64 5, i64 1, i32* %0)
ret void
}