#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*/ spDeltas;
typedef int /*<<< orphan*/ scDeltas;
typedef int /*<<< orphan*/ phDeltas;
typedef int /*<<< orphan*/ filter;

/* Variables and functions */
double CalcKaiserBeta(double);
double CalcKaiserWidth(double, int);
double Kaiser(double, double const);
double MaxDouble(double, double const);
double MinDouble(int, int);
double Sinc(double);
scalar_t__ floor(double const);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ memset(double ***, int /*<<< orphan*/, int);
int /*<<< orphan*/ stdout;
void BsiGenerateTables() {
  static double filter[(16)][(16) + 1][2 * (12)];
  static double scDeltas[(16) - 1][(16)][2 * (12)];
  static double phDeltas[(16)][(16) + 1][2 * (12)];
  static double spDeltas[(16) - 1][(16)][2 * (12)];
  static int mt[(16)];
  static double at[(16)];
  double width, beta, scaleBase, scaleRange;
  int si, pi, i;
  memset(filter, 0, sizeof(filter));
  memset(scDeltas, 0, sizeof(scDeltas));
  memset(phDeltas, 0, sizeof(phDeltas));
  memset(spDeltas, 0, sizeof(spDeltas));
  width = CalcKaiserWidth((60.0), (12));
  beta = CalcKaiserBeta((60.0));
  scaleBase = width / 2.0;
  scaleRange = 1.0 - scaleBase;
  for (si = 0; si < (16); si++) {
    const double scale = scaleBase + (scaleRange * si / ((16) - 1));
    const double a = MinDouble((12), (12) / (2.0 * scale));
    int m = 2 * (int)floor(a);
    m += ~(m - 1) & 3;
    mt[si] = m;
    at[si] = a;
  }
  for (si = 0; si < (16); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    const int l = (m / 2) - 1;
    const double a = at[si];
    const double scale = scaleBase + (scaleRange * si / ((16) - 1));
    const double cutoff = (0.5 * scale) - (scaleBase * MaxDouble(0.5, scale));
    for (pi = 0; pi <= (16); pi++) {
      const double phase = l + ((double)pi / (16));
      for (i = 0; i < m; i++) {
        const double x = i - phase;
        filter[si][pi][o + i] =
            Kaiser(beta, x / a) * 2.0 * cutoff * Sinc(2.0 * cutoff * x);
      }
    }
  }
  for (si = 0; si < ((16) - 1); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      for (i = 0; i < m; i++)
        scDeltas[si][pi][o + i] =
            filter[si + 1][pi][o + i] - filter[si][pi][o + i];
    }
  }
  for (si = 0; si < (16); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      for (i = 0; i < m; i++)
        phDeltas[si][pi][o + i] =
            filter[si][pi + 1][o + i] - filter[si][pi][o + i];
    }
  }
  for (si = 0; si < ((16) - 1); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      for (i = 0; i < m; i++)
        spDeltas[si][pi][o + i] =
            phDeltas[si + 1][pi][o + i] - phDeltas[si][pi][o + i];
    }
  }
  i = mt[0];
  for (si = 1; si < (16); si++)
    i += (16) * mt[si];
  for (si = 0; si < ((16) - 1); si++)
    i += 2 * (16) * mt[si];
  for (si = 1; si < (16); si++)
    i += (16) * mt[si];
  fprintf(stdout, "static const float bsincTab[%d] =\n{\n", i);
  fprintf(stdout, "    /* %2d,%2d */", mt[0], 0);
  for (i = 0; i < mt[0]; i++)
    fprintf(stdout, " %+14.9ef,", filter[0][0][i]);
  fprintf(stdout, "\n\n");
  for (si = 1; si < (16); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      fprintf(stdout, "    /* %2d,%2d */", m, pi);
      for (i = 0; i < m; i++)
        fprintf(stdout, " %+14.9ef,", filter[si][pi][o + i]);
      fprintf(stdout, "\n");
    }
  }
  fprintf(stdout, "\n");
  for (si = 0; si < ((16) - 1); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      fprintf(stdout, "    /* %2d,%2d */", m, pi);
      for (i = 0; i < m; i++)
        fprintf(stdout, " %+14.9ef,", scDeltas[si][pi][o + i]);
      fprintf(stdout, "\n");
    }
  }
  fprintf(stdout, "\n");
  for (si = 1; si < (16); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      fprintf(stdout, "    /* %2d,%2d */", m, pi);
      for (i = 0; i < m; i++)
        fprintf(stdout, " %+14.9ef,", phDeltas[si][pi][o + i]);
      fprintf(stdout, "\n");
    }
  }
  fprintf(stdout, "\n");
  for (si = 0; si < ((16) - 1); si++) {
    const int m = mt[si];
    const int o = (12) - (m / 2);
    for (pi = 0; pi < (16); pi++) {
      fprintf(stdout, "    /* %2d,%2d */", m, pi);
      for (i = 0; i < m; i++)
        fprintf(stdout, " %+14.9ef,", spDeltas[si][pi][o + i]);
      fprintf(stdout, "\n");
    }
  }
  fprintf(stdout, "};\n\n");
  fprintf(stdout,
          "    static const ALfloat scaleBase = %.9ef, scaleRange = %.9ef;\n",
          scaleBase, 1.0 / scaleRange);
  fprintf(stdout, "    static const ALuint m[BSINC_SCALE_COUNT] = {");
  fprintf(stdout, " %d", mt[0]);
  for (si = 1; si < (16); si++)
    fprintf(stdout, ", %d", mt[si]);
  fprintf(stdout, " };\n");
  fprintf(
      stdout,
      "    static const ALuint to[4][BSINC_SCALE_COUNT] =\n    {\n        { 0");
  i = mt[0];
  for (si = 1; si < (16); si++) {
    fprintf(stdout, ", %d", i);
    i += (16) * mt[si];
  }
  fprintf(stdout, " },\n        {");
  for (si = 0; si < ((16) - 1); si++) {
    fprintf(stdout, " %d,", i);
    i += (16) * mt[si];
  }
  fprintf(stdout, " 0 },\n        { 0");
  for (si = 1; si < (16); si++) {
    fprintf(stdout, ", %d", i);
    i += (16) * mt[si];
  }
  fprintf(stdout, " },\n        {");
  for (si = 0; si < ((16) - 1); si++) {
    fprintf(stdout, " %d,", i);
    i += (16) * mt[si];
  }
  fprintf(stdout, " 0 }\n    };\n");
  fprintf(stdout, "    static const ALuint tm[2][BSINC_SCALE_COUNT] = \n    "
                  "{\n        { 0");
  for (si = 1; si < (16); si++)
    fprintf(stdout, ", %d", mt[si]);
  fprintf(stdout, " },\n        {");
  for (si = 0; si < ((16) - 1); si++)
    fprintf(stdout, " %d,", mt[si]);
  fprintf(stdout, " 0 }\n    };\n\n");
}


x86 assembly (clang, -O0):
<BsiGenerateTables>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
lea    0x3ede(%rip),%rdi
xor    %esi,%esi
mov    $0xcc00,%edx
call   1070 <memset@plt>
lea    0x10acb(%rip),%rdi
xor    %esi,%esi
mov    $0xb400,%edx
call   1070 <memset@plt>
lea    0x1beb8(%rip),%rdi
xor    %esi,%esi
mov    $0xcc00,%edx
call   1070 <memset@plt>
lea    0x28aa5(%rip),%rdi
xor    %esi,%esi
mov    $0xb400,%edx
call   1070 <memset@plt>
movsd  0x1e21(%rip),%xmm0
mov    $0xc,%edi
call   1030 <CalcKaiserWidth@plt>
movsd  %xmm0,-0x8(%rbp)
movsd  0x1e0a(%rip),%xmm0
call   1040 <CalcKaiserBeta@plt>
movsd  %xmm0,-0x10(%rbp)
movsd  -0x8(%rbp),%xmm0
movsd  0x1deb(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0x1dd2(%rip),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    12f3 <BsiGenerateTables+0x163>
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
cvtsi2sdl -0x24(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1dbc(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0x1d8f(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
movsd  0x1daa(%rip),%xmm0
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
mov    $0xc,%edi
call   1060 <MinDouble@plt>
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
call   10b0 <floor@plt>
shl    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
xor    $0xffffffff,%eax
and    $0x3,%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edx
movslq -0x24(%rbp),%rcx
lea    0x33db3(%rip),%rax
mov    %edx,(%rax,%rcx,4)
movsd  -0x40(%rbp),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x33de0(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    123f <BsiGenerateTables+0xaf>
movl   $0x0,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    14f3 <BsiGenerateTables+0x363>
movslq -0x24(%rbp),%rcx
lea    0x33d71(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movslq -0x24(%rbp),%rcx
lea    0x33d78(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
cvtsi2sdl -0x24(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  0x1cb3(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x60(%rbp),%xmm1
movsd  0x1c77(%rip),%xmm0
call   1050 <MaxDouble@plt>
movsd  -0xc0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x1c3c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jg     14e0 <BsiGenerateTables+0x350>
cvtsi2sdl -0x50(%rbp),%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
movsd  0x1c1c(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    14cd <BsiGenerateTables+0x33d>
cvtsi2sdl -0x2c(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
divsd  -0x58(%rbp),%xmm1
call   10a0 <Kaiser@plt>
movsd  0x1bb1(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0x1b98(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
call   1080 <Sinc@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movslq -0x24(%rbp),%rcx
lea    0x3be7(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x4c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1420 <BsiGenerateTables+0x290>
jmp    14d2 <BsiGenerateTables+0x342>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13f0 <BsiGenerateTables+0x260>
jmp    14e5 <BsiGenerateTables+0x355>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12fa <BsiGenerateTables+0x16a>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    161c <BsiGenerateTables+0x48c>
movslq -0x24(%rbp),%rcx
lea    0x33b71(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0x80(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1609 <BsiGenerateTables+0x479>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    15f6 <BsiGenerateTables+0x466>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    0x3b20(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x3aef(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x106be(%rip),%rax
imul   $0xc00,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x80(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1544 <BsiGenerateTables+0x3b4>
jmp    15fb <BsiGenerateTables+0x46b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1533 <BsiGenerateTables+0x3a3>
jmp    160e <BsiGenerateTables+0x47e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14fa <BsiGenerateTables+0x36a>
movl   $0x0,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    175a <BsiGenerateTables+0x5ca>
movslq -0x24(%rbp),%rcx
lea    0x33a48(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0x88(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1747 <BsiGenerateTables+0x5b7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x84(%rbp),%eax
jge    1734 <BsiGenerateTables+0x5a4>
movslq -0x24(%rbp),%rcx
lea    0x39f0(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x39b7(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x1b983(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1676 <BsiGenerateTables+0x4e6>
jmp    1739 <BsiGenerateTables+0x5a9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1665 <BsiGenerateTables+0x4d5>
jmp    174c <BsiGenerateTables+0x5bc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1623 <BsiGenerateTables+0x493>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    1898 <BsiGenerateTables+0x708>
movslq -0x24(%rbp),%rcx
lea    0x3390a(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1885 <BsiGenerateTables+0x6f5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    1872 <BsiGenerateTables+0x6e2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    0x1b8ad(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x90(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x1b879(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x90(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movslq -0x24(%rbp),%rcx
lea    0x28445(%rip),%rax
imul   $0xc00,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x90(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17b4 <BsiGenerateTables+0x624>
jmp    1877 <BsiGenerateTables+0x6e7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17a3 <BsiGenerateTables+0x613>
jmp    188a <BsiGenerateTables+0x6fa>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1761 <BsiGenerateTables+0x5d1>
mov    0x337e2(%rip),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    18d7 <BsiGenerateTables+0x747>
movslq -0x24(%rbp),%rcx
lea    0x337c3(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18a8 <BsiGenerateTables+0x718>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    190d <BsiGenerateTables+0x77d>
movslq -0x24(%rbp),%rcx
lea    0x3378d(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x5,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18de <BsiGenerateTables+0x74e>
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    1943 <BsiGenerateTables+0x7b3>
movslq -0x24(%rbp),%rcx
lea    0x33757(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1914 <BsiGenerateTables+0x784>
mov    0x3696(%rip),%rax
mov    (%rax),%edi
mov    -0x2c(%rbp),%edx
lea    0x16e2(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x367c(%rip),%rax
mov    (%rax),%edi
mov    0x33714(%rip),%edx
lea    0x16ea(%rip),%rsi
xor    %ecx,%ecx
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x336f4(%rip),%eax
jge    19c7 <BsiGenerateTables+0x837>
mov    0x3647(%rip),%rax
mov    (%rax),%edi
movslq -0x2c(%rbp),%rcx
lea    0x36da(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
lea    0x16bd(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1983 <BsiGenerateTables+0x7f3>
mov    0x3612(%rip),%rax
mov    (%rax),%edi
lea    0x17e2(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    1af8 <BsiGenerateTables+0x968>
movslq -0x24(%rbp),%rcx
lea    0x33686(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0x98(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1ae5 <BsiGenerateTables+0x955>
mov    0x35a8(%rip),%rax
mov    (%rax),%edi
mov    -0x94(%rbp),%edx
mov    -0x28(%rbp),%ecx
lea    0x1613(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    1ac0 <BsiGenerateTables+0x930>
mov    0x3572(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x3605(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0x98(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x15c4(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a58 <BsiGenerateTables+0x8c8>
mov    0x3519(%rip),%rax
mov    (%rax),%edi
lea    0x16ea(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1a27 <BsiGenerateTables+0x897>
jmp    1aea <BsiGenerateTables+0x95a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19e5 <BsiGenerateTables+0x855>
mov    0x34e1(%rip),%rax
mov    (%rax),%edi
lea    0x16b2(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    1c29 <BsiGenerateTables+0xa99>
movslq -0x24(%rbp),%rcx
lea    0x33555(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1c16 <BsiGenerateTables+0xa86>
mov    0x3477(%rip),%rax
mov    (%rax),%edi
mov    -0x9c(%rbp),%edx
mov    -0x28(%rbp),%ecx
lea    0x14e2(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1bf1 <BsiGenerateTables+0xa61>
mov    0x3441(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x100d4(%rip),%rax
imul   $0xc00,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0xa0(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1493(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b89 <BsiGenerateTables+0x9f9>
mov    0x33e8(%rip),%rax
mov    (%rax),%edi
lea    0x15b9(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1b58 <BsiGenerateTables+0x9c8>
jmp    1c1b <BsiGenerateTables+0xa8b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1b16 <BsiGenerateTables+0x986>
mov    0x33b0(%rip),%rax
mov    (%rax),%edi
lea    0x1581(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    1d5a <BsiGenerateTables+0xbca>
movslq -0x24(%rbp),%rcx
lea    0x33424(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0xa8(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1d47 <BsiGenerateTables+0xbb7>
mov    0x3346(%rip),%rax
mov    (%rax),%edi
mov    -0xa4(%rbp),%edx
mov    -0x28(%rbp),%ecx
lea    0x13b1(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jge    1d22 <BsiGenerateTables+0xb92>
mov    0x3310(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x1b3a3(%rip),%rax
imul   $0xcc0,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0xa8(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1362(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1cba <BsiGenerateTables+0xb2a>
mov    0x32b7(%rip),%rax
mov    (%rax),%edi
lea    0x1488(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1c89 <BsiGenerateTables+0xaf9>
jmp    1d4c <BsiGenerateTables+0xbbc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c47 <BsiGenerateTables+0xab7>
mov    0x327f(%rip),%rax
mov    (%rax),%edi
lea    0x1450(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    1e8b <BsiGenerateTables+0xcfb>
movslq -0x24(%rbp),%rcx
lea    0x332f3(%rip),%rax
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0xc,%eax
sub    %ecx,%eax
mov    %eax,-0xb0(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    1e78 <BsiGenerateTables+0xce8>
mov    0x3215(%rip),%rax
mov    (%rax),%edi
mov    -0xac(%rbp),%edx
mov    -0x28(%rbp),%ecx
lea    0x1280(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xac(%rbp),%eax
jge    1e53 <BsiGenerateTables+0xcc3>
mov    0x31df(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x27e72(%rip),%rax
imul   $0xc00,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0xc0,%rcx,%rcx
add    %rcx,%rax
mov    -0xb0(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1231(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1deb <BsiGenerateTables+0xc5b>
mov    0x3186(%rip),%rax
mov    (%rax),%edi
lea    0x1357(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1dba <BsiGenerateTables+0xc2a>
jmp    1e7d <BsiGenerateTables+0xced>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1d78 <BsiGenerateTables+0xbe8>
mov    0x314e(%rip),%rax
mov    (%rax),%edi
lea    0x131c(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x3137(%rip),%rax
mov    (%rax),%edi
movsd  -0x18(%rbp),%xmm0
movsd  0x1148(%rip),%xmm1
divsd  -0x20(%rbp),%xmm1
lea    0x11b6(%rip),%rsi
mov    $0x2,%al
call   1090 <fprintf@plt>
mov    0x310e(%rip),%rax
mov    (%rax),%edi
lea    0x11e0(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x30f7(%rip),%rax
mov    (%rax),%edi
mov    0x3318f(%rip),%edx
lea    0x11f5(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    1f43 <BsiGenerateTables+0xdb3>
mov    0x30c9(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x3315c(%rip),%rax
mov    (%rax,%rcx,4),%edx
lea    0x11be(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1f06 <BsiGenerateTables+0xd76>
mov    0x3096(%rip),%rax
mov    (%rax),%edi
lea    0x1210(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x307f(%rip),%rax
mov    (%rax),%edi
lea    0x1187(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x33109(%rip),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    1fca <BsiGenerateTables+0xe3a>
mov    0x304e(%rip),%rax
mov    (%rax),%edi
mov    -0x2c(%rbp),%edx
lea    0x114e(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movslq -0x24(%rbp),%rcx
lea    0x330d0(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1f81 <BsiGenerateTables+0xdf1>
mov    0x300f(%rip),%rax
mov    (%rax),%edi
lea    0x115c(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    2031 <BsiGenerateTables+0xea1>
mov    0x2fe7(%rip),%rax
mov    (%rax),%edi
mov    -0x2c(%rbp),%edx
lea    0x113f(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movslq -0x24(%rbp),%rcx
lea    0x33069(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1fe8 <BsiGenerateTables+0xe58>
mov    0x2fa8(%rip),%rax
mov    (%rax),%edi
lea    0x1108(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    2098 <BsiGenerateTables+0xf08>
mov    0x2f80(%rip),%rax
mov    (%rax),%edi
mov    -0x2c(%rbp),%edx
lea    0x1080(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movslq -0x24(%rbp),%rcx
lea    0x33002(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    204f <BsiGenerateTables+0xebf>
mov    0x2f41(%rip),%rax
mov    (%rax),%edi
lea    0x108e(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    20ff <BsiGenerateTables+0xf6f>
mov    0x2f19(%rip),%rax
mov    (%rax),%edi
mov    -0x2c(%rbp),%edx
lea    0x1071(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movslq -0x24(%rbp),%rcx
lea    0x32f9b(%rip),%rax
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    20b6 <BsiGenerateTables+0xf26>
mov    0x2eda(%rip),%rax
mov    (%rax),%edi
lea    0x104c(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2ec3(%rip),%rax
mov    (%rax),%edi
lea    0x1042(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x1,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    2171 <BsiGenerateTables+0xfe1>
mov    0x2e9b(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x32f2e(%rip),%rax
mov    (%rax,%rcx,4),%edx
lea    0xf90(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    2134 <BsiGenerateTables+0xfa4>
mov    0x2e68(%rip),%rax
mov    (%rax),%edi
lea    0xfb5(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0xf,-0x24(%rbp)
jge    21cc <BsiGenerateTables+0x103c>
mov    0x2e40(%rip),%rax
mov    (%rax),%edi
movslq -0x24(%rbp),%rcx
lea    0x32ed3(%rip),%rax
mov    (%rax,%rcx,4),%edx
lea    0xf8d(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    218f <BsiGenerateTables+0xfff>
mov    0x2e0d(%rip),%rax
mov    (%rax),%edi
lea    0xfd2(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BsiGenerateTables>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
lea    0x3edb(%rip),%r13
xor    %r14d,%r14d
mov    %r13,%rdi
xor    %esi,%esi
mov    $0xcc00,%edx
call   1070 <memset@plt>
lea    0x10ac2(%rip),%rdi
xor    %esi,%esi
mov    $0xb400,%edx
call   1070 <memset@plt>
lea    0x1beaf(%rip),%rdi
xor    %esi,%esi
mov    $0xcc00,%edx
call   1070 <memset@plt>
lea    0x28a9c(%rip),%rdi
xor    %esi,%esi
mov    $0xb400,%edx
call   1070 <memset@plt>
movsd  0x1e08(%rip),%xmm0
mov    $0xc,%edi
call   1030 <CalcKaiserWidth@plt>
movaps %xmm0,0x50(%rsp)
movsd  0x1df1(%rip),%xmm0
call   1040 <CalcKaiserBeta@plt>
movapd 0x50(%rsp),%xmm4
movsd  %xmm0,0x28(%rsp)
mulsd  0x1de0(%rip),%xmm4
movsd  0x1de0(%rip),%xmm2
subsd  %xmm4,%xmm2
lea    0x33e85(%rip),%rbp
lea    0x33e3e(%rip),%rbx
movsd  0x1dce(%rip),%xmm3
movapd %xmm4,0x50(%rsp)
movsd  %xmm2,0x38(%rsp)
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
addsd  %xmm0,%xmm0
movsd  0x1da0(%rip),%xmm1
divsd  %xmm0,%xmm1
cvttsd2si %xmm1,%esi
mov    $0xc,%edi
call   1060 <MinDouble@plt>
movsd  %xmm0,0x8(%rsp)
call   10b0 <floor@plt>
movsd  0x1d73(%rip),%xmm3
movsd  0x38(%rsp),%xmm2
movapd 0x50(%rsp),%xmm4
lea    (%rax,%rax,1),%ecx
neg    %ecx
and    $0x2,%ecx
lea    (%rcx,%rax,2),%eax
mov    %eax,(%rbx)
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
add    $0x1,%r14
add    $0x8,%rbp
add    $0x4,%rbx
cmp    $0x10,%r14
jne    1260 <BsiGenerateTables+0xd0>
movapd 0x1d4d(%rip),%xmm0
xorpd  %xmm4,%xmm0
movapd %xmm0,0x60(%rsp)
xor    %r15d,%r15d
jmp    1322 <BsiGenerateTables+0x192>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
cmp    $0x10,%r15
movapd 0x50(%rsp),%xmm4
movsd  0x38(%rsp),%xmm2
movsd  0x1cfc(%rip),%xmm3
je     1492 <BsiGenerateTables+0x302>
lea    0x33d57(%rip),%rax
mov    (%rax,%r15,4),%r12d
mov    %r12d,%ebx
shr    $0x1f,%ebx
add    %r12d,%ebx
sar    %ebx
mov    %ebx,%ebp
neg    %ebp
add    $0xffffffff,%ebx
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
lea    0x33d72(%rip),%rax
movsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,0x20(%rsp)
mulsd  %xmm2,%xmm1
divsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0x1c94(%rip),%xmm0
call   1050 <MaxDouble@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x1c7b(%rip),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  %xmm1,0x30(%rsp)
movapd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x48(%rsp)
movslq %ebp,%rbp
add    $0xc,%rbp
xor    %ebx,%ebx
jmp    13ce <BsiGenerateTables+0x23e>
nopl   (%rax)
add    $0x1,%rbx
cmp    $0x11,%rbx
je     1300 <BsiGenerateTables+0x170>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mulsd  0x1c4b(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
test   %r12d,%r12d
movsd  0x28(%rsp),%xmm2
movsd  0x20(%rsp),%xmm3
jle    13c0 <BsiGenerateTables+0x230>
movsd  0x18(%rsp),%xmm0
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %r14d,%r14d
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
subsd  0x18(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
divsd  %xmm3,%xmm1
movapd %xmm2,%xmm0
call   10a0 <Kaiser@plt>
addsd  %xmm0,%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
mulsd  0x48(%rsp),%xmm0
call   1080 <Sinc@plt>
movsd  0x20(%rsp),%xmm3
movsd  0x28(%rsp),%xmm2
mulsd  0x10(%rsp),%xmm0
lea    (%r14,%rbp,1),%eax
cltq
imul   $0xcc0,%r15,%rcx
add    %r13,%rcx
lea    (%rbx,%rbx,2),%rdx
shl    $0x6,%rdx
add    %rcx,%rdx
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%r14
cmp    %r14,%r12
jne    1410 <BsiGenerateTables+0x280>
jmp    13c0 <BsiGenerateTables+0x230>
lea    0x48d7(%rip),%rcx
xor    %ebx,%ebx
mov    %r13,%rdi
lea    0x107db(%rip),%rsi
jmp    14e6 <BsiGenerateTables+0x356>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rsi
add    $0xc00,%rsi
mov    0x30(%rsp),%rcx
add    $0xcc0,%rcx
mov    0x48(%rsp),%rdi
add    $0xcc0,%rdi
mov    0x18(%rsp),%rax
mov    %rax,%rbx
cmp    $0xf,%rax
je     1703 <BsiGenerateTables+0x573>
lea    0x33b93(%rip),%rax
mov    (%rax,%rbx,4),%ebp
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
neg    %eax
movslq %eax,%r8
lea    0xc(%r8),%rax
mov    %rax,0x28(%rsp)
mov    %rbx,0x20(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x18(%rsp)
mov    %ebp,%ebx
and    $0xfffffffc,%ebx
lea    -0x4(%rbx),%r11
mov    %r11,0x8(%rsp)
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11,%rdx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdx
mov    %rdx,0x10(%rsp)
mov    %rsi,0x40(%rsp)
lea    (%rsi,%r8,8),%r14
add    $0x60,%r14
mov    %rcx,0x30(%rsp)
lea    (%rcx,%r8,8),%r15
add    $0x60,%r15
mov    %rdi,0x48(%rsp)
lea    (%rdi,%r8,8),%r12
add    $0x60,%r12
xor    %r9d,%r9d
jmp    1593 <BsiGenerateTables+0x403>
nopl   0x0(%rax)
add    $0x1,%r9
add    $0xc0,%r14
add    $0xc0,%r15
add    $0xc0,%r12
cmp    $0x10,%r9
je     14b0 <BsiGenerateTables+0x320>
test   %ebp,%ebp
jle    1570 <BsiGenerateTables+0x3e0>
cmp    $0x4,%ebp
jae    15b0 <BsiGenerateTables+0x420>
xor    %edx,%edx
jmp    16d0 <BsiGenerateTables+0x540>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,0x8(%rsp)
je     16f4 <BsiGenerateTables+0x564>
mov    0x10(%rsp),%r8
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x30(%r15,%r10,8),%xmm0
movupd -0x20(%r15,%r10,8),%xmm1
movupd -0xcf0(%r15,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm0
movupd -0xce0(%r15,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm1
movupd %xmm0,(%r14,%r10,8)
movupd %xmm1,0x10(%r14,%r10,8)
movupd -0x10(%r15,%r10,8),%xmm0
movupd (%r15,%r10,8),%xmm1
movupd -0xcd0(%r15,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm0
movupd -0xcc0(%r15,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm1
movupd %xmm0,0x20(%r14,%r10,8)
movupd %xmm1,0x30(%r14,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%r8
jne    15d0 <BsiGenerateTables+0x440>
test   $0x1,%r11b
je     16c3 <BsiGenerateTables+0x533>
add    0x28(%rsp),%r10
imul   $0xcc0,0x18(%rsp),%rdx
add    %r13,%rdx
mov    %r9,%rax
shl    $0x6,%rax
lea    (%rax,%rax,2),%rax
add    %rax,%rdx
movupd (%rdx,%r10,8),%xmm0
movupd 0x10(%rdx,%r10,8),%xmm1
mov    0x20(%rsp),%rcx
imul   $0xcc0,%rcx,%rdx
add    %r13,%rdx
add    %rax,%rdx
movupd (%rdx,%r10,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rdx,%r10,8),%xmm2
subpd  %xmm2,%xmm1
lea    (%rcx,%rcx,2),%rdx
shl    $0xa,%rdx
lea    0x105d0(%rip),%rcx
add    %rcx,%rdx
add    %rax,%rdx
movupd %xmm0,(%rdx,%r10,8)
movupd %xmm1,0x10(%rdx,%r10,8)
mov    %rbx,%rdx
cmp    %rbp,%rbx
je     1570 <BsiGenerateTables+0x3e0>
nop
movsd  0xcc0(%r12,%rdx,8),%xmm0
subsd  (%r12,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    16d0 <BsiGenerateTables+0x540>
jmp    1570 <BsiGenerateTables+0x3e0>
xor    %r10d,%r10d
test   $0x1,%r11b
jne    164e <BsiGenerateTables+0x4be>
jmp    16c3 <BsiGenerateTables+0x533>
lea    0x3a66(%rip),%rdx
lea    0x396f(%rip),%rdi
xor    %r12d,%r12d
lea    0x1b965(%rip),%rbp
jmp    1752 <BsiGenerateTables+0x5c2>
nopl   (%rax)
add    $0x1,%r12
mov    0x20(%rsp),%rbp
add    $0xcc0,%rbp
mov    0x10(%rsp),%rdx
add    $0xcc0,%rdx
mov    0x18(%rsp),%rdi
add    $0xcc0,%rdi
cmp    $0x10,%r12
je     1950 <BsiGenerateTables+0x7c0>
lea    0x33927(%rip),%rax
mov    (%rax,%r12,4),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
neg    %ecx
movslq %ecx,%rsi
lea    0xc(%rsi),%rcx
mov    %rcx,0x8(%rsp)
mov    %eax,%r14d
and    $0xfffffffc,%r14d
lea    -0x4(%r14),%r11
mov    %r11,%r13
shr    $0x2,%r13
add    $0x1,%r13
mov    %r13,%r10
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%r10
mov    %rbp,0x20(%rsp)
lea    0x60(,%rsi,8),%rbx
add    %rbp,%rbx
mov    %rdx,0x10(%rsp)
lea    (%rdx,%rsi,8),%rbp
add    $0x60,%rbp
mov    %rdi,0x18(%rsp)
lea    (%rdi,%rsi,8),%rsi
add    $0x60,%rsi
xor    %r9d,%r9d
jmp    17ef <BsiGenerateTables+0x65f>
nopl   0x0(%rax)
add    $0xc0,%rbx
add    $0xc0,%rbp
add    $0xc0,%rsi
cmp    $0x10,%r9
je     1720 <BsiGenerateTables+0x590>
mov    %r9,%rdi
add    $0x1,%r9
test   %eax,%eax
jle    17d0 <BsiGenerateTables+0x640>
cmp    $0x4,%eax
jae    1810 <BsiGenerateTables+0x680>
xor    %edi,%edi
jmp    1920 <BsiGenerateTables+0x790>
cs nopw 0x0(%rax,%rax,1)
test   %r11,%r11
je     1941 <BsiGenerateTables+0x7b1>
mov    %r10,%r15
xor    %r8d,%r8d
nop
movupd -0xf0(%rbp,%r8,8),%xmm0
ff ff ff
movupd -0xe0(%rbp,%r8,8),%xmm1
ff ff ff
movupd -0x30(%rbp,%r8,8),%xmm2
subpd  %xmm0,%xmm2
movupd -0x20(%rbp,%r8,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%rbx,%r8,8)
movupd %xmm0,0x10(%rbx,%r8,8)
movupd -0xd0(%rbp,%r8,8),%xmm0
ff ff ff
movupd -0xc0(%rbp,%r8,8),%xmm1
ff ff ff
movupd -0x10(%rbp,%r8,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x0(%rbp,%r8,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rbx,%r8,8)
movupd %xmm0,0x30(%rbx,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r15
jne    1820 <BsiGenerateTables+0x690>
test   $0x1,%r13b
je     1908 <BsiGenerateTables+0x778>
add    0x8(%rsp),%r8
imul   $0xcc0,%r12,%rcx
lea    0x37ce(%rip),%rdx
lea    (%rdx,%rcx,1),%r15
lea    (%r9,%r9,2),%rdx
shl    $0x6,%rdx
add    %r15,%rdx
movupd (%rdx,%r8,8),%xmm0
movupd 0x10(%rdx,%r8,8),%xmm1
shl    $0x6,%rdi
lea    (%rdi,%rdi,2),%rdx
add    %rdx,%r15
movupd (%r15,%r8,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%r15,%r8,8),%xmm2
subpd  %xmm2,%xmm1
lea    0x1b78b(%rip),%rdi
add    %rdi,%rcx
add    %rdx,%rcx
movupd %xmm0,(%rcx,%r8,8)
movupd %xmm1,0x10(%rcx,%r8,8)
mov    %r14,%rdi
cmp    %rax,%r14
je     17d0 <BsiGenerateTables+0x640>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0xc0(%rsi,%rdi,8),%xmm0
subsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1920 <BsiGenerateTables+0x790>
jmp    17d0 <BsiGenerateTables+0x640>
xor    %r8d,%r8d
test   $0x1,%r13b
jne    189f <BsiGenerateTables+0x70f>
jmp    1908 <BsiGenerateTables+0x778>
lea    0x1c419(%rip),%rdx
lea    0x1b722(%rip),%rsi
xor    %r14d,%r14d
lea    0x28318(%rip),%rdi
jmp    19a6 <BsiGenerateTables+0x816>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rdi
add    $0xc00,%rdi
mov    0x18(%rsp),%rdx
add    $0xcc0,%rdx
mov    0x20(%rsp),%rsi
add    $0xcc0,%rsi
mov    0x8(%rsp),%rax
mov    %rax,%r14
cmp    $0xf,%rax
je     1bc0 <BsiGenerateTables+0xa30>
lea    0x336d3(%rip),%rax
mov    (%rax,%r14,4),%ebx
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
neg    %eax
movslq %eax,%rcx
lea    0xc(%rcx),%rax
mov    %rax,0x10(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x8(%rsp)
mov    %ebx,%r15d
and    $0xfffffffc,%r15d
lea    -0x4(%r15),%r8
mov    %r8,%r13
shr    $0x2,%r13
add    $0x1,%r13
mov    %r13,%r11
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r11
mov    %rdi,0x28(%rsp)
lea    (%rdi,%rcx,8),%rax
add    $0x60,%rax
mov    %rdx,0x18(%rsp)
lea    (%rdx,%rcx,8),%rdx
add    $0x60,%rdx
mov    %rsi,0x20(%rsp)
lea    (%rsi,%rcx,8),%rdi
add    $0x60,%rdi
xor    %r9d,%r9d
jmp    1a52 <BsiGenerateTables+0x8c2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
add    $0xc0,%rax
add    $0xc0,%rdx
add    $0xc0,%rdi
cmp    $0x10,%r9
je     1970 <BsiGenerateTables+0x7e0>
test   %ebx,%ebx
jle    1a30 <BsiGenerateTables+0x8a0>
cmp    $0x4,%ebx
jae    1a70 <BsiGenerateTables+0x8e0>
xor    %ecx,%ecx
jmp    1b90 <BsiGenerateTables+0xa00>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r8,%r8
je     1bb1 <BsiGenerateTables+0xa21>
mov    %r11,%r12
xor    %r10d,%r10d
nop
movupd -0x30(%rdx,%r10,8),%xmm0
movupd -0x20(%rdx,%r10,8),%xmm1
movupd -0xcf0(%rdx,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm0
movupd -0xce0(%rdx,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm1
movupd %xmm0,(%rax,%r10,8)
movupd %xmm1,0x10(%rax,%r10,8)
movupd -0x10(%rdx,%r10,8),%xmm0
movupd (%rdx,%r10,8),%xmm1
movupd -0xcd0(%rdx,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm0
movupd -0xcc0(%rdx,%r10,8),%xmm2
f3 ff ff
subpd  %xmm2,%xmm1
movupd %xmm0,0x20(%rax,%r10,8)
movupd %xmm1,0x30(%rax,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%r12
jne    1a80 <BsiGenerateTables+0x8f0>
test   $0x1,%r13b
je     1b76 <BsiGenerateTables+0x9e6>
add    0x10(%rsp),%r10
imul   $0xcc0,0x8(%rsp),%rcx
lea    0x1b56d(%rip),%rsi
add    %rsi,%rcx
mov    %r9,%rbp
shl    $0x6,%rbp
lea    0x0(%rbp,%rbp,2),%rbp
add    %rbp,%rcx
movupd (%rcx,%r10,8),%xmm0
movupd 0x10(%rcx,%r10,8),%xmm1
imul   $0xcc0,%r14,%rcx
add    %rsi,%rcx
add    %rbp,%rcx
movupd (%rcx,%r10,8),%xmm2
subpd  %xmm2,%xmm0
movupd 0x10(%rcx,%r10,8),%xmm2
subpd  %xmm2,%xmm1
lea    (%r14,%r14,2),%rcx
shl    $0xa,%rcx
lea    0x2811d(%rip),%rsi
add    %rsi,%rcx
add    %rbp,%rcx
movupd %xmm0,(%rcx,%r10,8)
movupd %xmm1,0x10(%rcx,%r10,8)
mov    %r15,%rcx
cmp    %rbx,%r15
je     1a30 <BsiGenerateTables+0x8a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0xcc0(%rdi,%rcx,8),%xmm0
subsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1b90 <BsiGenerateTables+0xa00>
jmp    1a30 <BsiGenerateTables+0x8a0>
xor    %r10d,%r10d
test   $0x1,%r13b
jne    1afe <BsiGenerateTables+0x96e>
jmp    1b76 <BsiGenerateTables+0x9e6>
movdqu 0x334e4(%rip),%xmm5
movdqu 0x334cc(%rip),%xmm4
movd   %xmm4,%r8d
pshufd $0x55,%xmm4,%xmm1
pshufd $0xeb,%xmm4,%xmm0
movd   %xmm5,0x8(%rsp)
pshufd $0x55,%xmm5,%xmm2
pshufd $0xeb,%xmm5,%xmm3
pslld  $0x5,%xmm5
pslld  $0x5,%xmm4
paddd  %xmm5,%xmm4
pshufd $0xee,%xmm4,%xmm5
paddd  %xmm4,%xmm5
pshufd $0x55,%xmm5,%xmm4
paddd  %xmm5,%xmm4
movd   %xmm4,%edx
mov    0x33467(%rip),%ebp
mov    0x33465(%rip),%ebx
mov    %ebx,%r10d
shl    $0x4,%r10d
lea    (%r10,%rbp,1),%esi
mov    0x33458(%rip),%eax
mov    %eax,%r11d
shl    $0x4,%r11d
add    %r11d,%esi
mov    0x3344c(%rip),%ecx
mov    %ecx,%r14d
shl    $0x4,%r14d
add    %r14d,%esi
mov    0x33440(%rip),%edi
mov    0x3343d(%rip),%r13d
mov    0x3343a(%rip),%r12d
mov    %r12d,%r15d
shl    $0x5,%r12d
add    %r12d,%edx
mov    %r13d,%r12d
shl    $0x5,%r13d
add    %r13d,%edx
mov    %edi,%r13d
shl    $0x4,%r13d
add    %r13d,%esi
shl    $0x4,%r12d
add    %r12d,%esi
shl    $0x4,%r15d
add    %r15d,%esi
shl    $0x4,%r8d
mov    %r8d,0x10(%rsp)
add    %r8d,%esi
shl    $0x5,%edi
add    %edi,%edx
movd   %xmm1,%edi
shl    $0x4,%edi
add    %edi,%esi
pslld  $0x4,%xmm0
pshufd $0x55,%xmm0,%xmm1
shl    $0x5,%ecx
add    %ecx,%edx
movd   %xmm1,%r9d
add    %r9d,%esi
shl    $0x5,%eax
add    %eax,%edx
movd   %xmm0,%r8d
add    %r8d,%esi
mov    0x8(%rsp),%eax
shl    $0x4,%eax
mov    %eax,0x8(%rsp)
add    %eax,%esi
shl    $0x5,%ebx
add    %ebx,%edx
movd   %xmm2,%ebx
shl    $0x4,%ebx
add    %ebx,%esi
pslld  $0x4,%xmm3
pshufd $0x55,%xmm3,%xmm0
shl    $0x5,%ebp
add    %ebp,%edx
movd   %xmm0,%ebp
add    %ebp,%esi
movd   %xmm3,%ecx
add    %ecx,%esi
mov    0x333b8(%rip),%eax
shl    $0x4,%eax
add    %eax,%esi
add    %eax,%edx
add    %ecx,%edx
add    %ebp,%edx
add    %ebx,%edx
add    0x8(%rsp),%edx
add    %r8d,%edx
add    %r9d,%edx
add    %edi,%edx
add    0x10(%rsp),%edx
add    %r15d,%edx
add    %r12d,%edx
add    %r13d,%edx
add    %r14d,%edx
add    %r11d,%edx
add    %r10d,%edx
add    %esi,%edx
mov    0x32a4(%rip),%r14
mov    (%r14),%edi
lea    0x12fa(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3332a(%rip),%edx
lea    0x1308(%rip),%rsi
xor    %ecx,%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
cmpl   $0x0,0x33313(%rip)
jle    1da6 <BsiGenerateTables+0xc16>
lea    0x330a(%rip),%rbp
xor    %ebx,%ebx
lea    0x12f8(%rip),%r15
nop
mov    (%r14),%edi
movq   0x0(%rbp),%xmm0
mov    %r15,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%rbx
movslq 0x332e3(%rip),%rax
add    $0x8,%rbp
cmp    %rax,%rbx
jl     1d80 <BsiGenerateTables+0xbf0>
mov    (%r14),%edi
lea    0x1411(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    $0x1,%ecx
lea    0x3f7d(%rip),%rdx
lea    0x12ad(%rip),%r12
jmp    1def <BsiGenerateTables+0xc5f>
nopl   0x0(%rax)
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
mov    0x10(%rsp),%rdx
add    $0xcc0,%rdx
cmp    $0x10,%rcx
je     1e7f <BsiGenerateTables+0xcef>
lea    0x3328a(%rip),%rax
mov    %rcx,0x8(%rsp)
mov    (%rax,%rcx,4),%ebx
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
neg    %eax
cltq
mov    %rdx,0x10(%rsp)
lea    (%rdx,%rax,8),%rbp
add    $0x60,%rbp
xor    %r13d,%r13d
jmp    1e42 <BsiGenerateTables+0xcb2>
nopl   (%rax)
mov    (%r14),%edi
lea    0x1398(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%r13
add    $0xc0,%rbp
cmp    $0x10,%r13
je     1dd0 <BsiGenerateTables+0xc40>
mov    (%r14),%edi
lea    0x1219(%rip),%rsi
mov    %ebx,%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %ebx,%ebx
jle    1e20 <BsiGenerateTables+0xc90>
xor    %r15d,%r15d
nop
mov    (%r14),%edi
movq   0x0(%rbp,%r15,8),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%r15
cmp    %r15,%rbx
jne    1e60 <BsiGenerateTables+0xcd0>
jmp    1e20 <BsiGenerateTables+0xc90>
mov    (%r14),%edi
lea    0x1339(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0xfde9(%rip),%rcx
lea    0x11d9(%rip),%r12
xor    %edx,%edx
jmp    1ecf <BsiGenerateTables+0xd3f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rdx
add    $0x1,%rdx
mov    0x8(%rsp),%rcx
add    $0xc00,%rcx
cmp    $0xf,%rdx
je     1f5f <BsiGenerateTables+0xdcf>
lea    0x331aa(%rip),%rax
mov    %rdx,0x10(%rsp)
mov    (%rax,%rdx,4),%ebx
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
neg    %eax
cltq
mov    %rcx,0x8(%rsp)
lea    (%rcx,%rax,8),%rbp
add    $0x60,%rbp
xor    %r13d,%r13d
jmp    1f22 <BsiGenerateTables+0xd92>
nopl   (%rax)
mov    (%r14),%edi
lea    0x12b8(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%r13
add    $0xc0,%rbp
cmp    $0x10,%r13
je     1eb0 <BsiGenerateTables+0xd20>
mov    (%r14),%edi
lea    0x1139(%rip),%rsi
mov    %ebx,%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %ebx,%ebx
jle    1f00 <BsiGenerateTables+0xd70>
xor    %r15d,%r15d
nop
mov    (%r14),%edi
movq   0x0(%rbp,%r15,8),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%r15
cmp    %r15,%rbx
jne    1f40 <BsiGenerateTables+0xdb0>
jmp    1f00 <BsiGenerateTables+0xd70>
mov    (%r14),%edi
lea    0x1259(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    $0x1,%ecx
lea    0x1bdc4(%rip),%rdx
lea    0x10f4(%rip),%r12
jmp    1faf <BsiGenerateTables+0xe1f>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
mov    0x10(%rsp),%rdx
add    $0xcc0,%rdx
cmp    $0x10,%rcx
je     203f <BsiGenerateTables+0xeaf>
lea    0x330ca(%rip),%rax
mov    %rcx,0x8(%rsp)
mov    (%rax,%rcx,4),%ebx
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
neg    %eax
cltq
mov    %rdx,0x10(%rsp)
lea    (%rdx,%rax,8),%rbp
add    $0x60,%rbp
xor    %r13d,%r13d
jmp    2002 <BsiGenerateTables+0xe72>
nopl   (%rax)
mov    (%r14),%edi
lea    0x11d8(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%r13
add    $0xc0,%rbp
cmp    $0x10,%r13
je     1f90 <BsiGenerateTables+0xe00>
mov    (%r14),%edi
lea    0x1059(%rip),%rsi
mov    %ebx,%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %ebx,%ebx
jle    1fe0 <BsiGenerateTables+0xe50>
xor    %r15d,%r15d
nop
mov    (%r14),%edi
movq   0x0(%rbp,%r15,8),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%r15
cmp    %r15,%rbx
jne    2020 <BsiGenerateTables+0xe90>
jmp    1fe0 <BsiGenerateTables+0xe50>
mov    (%r14),%edi
lea    0x1179(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x27c29(%rip),%rcx
lea    0x1019(%rip),%r12
xor    %edx,%edx
jmp    208f <BsiGenerateTables+0xeff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rdx
add    $0x1,%rdx
mov    0x8(%rsp),%rcx
add    $0xc00,%rcx
cmp    $0xf,%rdx
je     211f <BsiGenerateTables+0xf8f>
lea    0x32fea(%rip),%rax
mov    %rdx,0x10(%rsp)
mov    (%rax,%rdx,4),%ebx
mov    %ebx,%eax
shr    $0x1f,%eax
add    %ebx,%eax
sar    %eax
neg    %eax
cltq
mov    %rcx,0x8(%rsp)
lea    (%rcx,%rax,8),%rbp
add    $0x60,%rbp
xor    %r13d,%r13d
jmp    20e2 <BsiGenerateTables+0xf52>
nopl   (%rax)
mov    (%r14),%edi
lea    0x10f8(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x1,%r13
add    $0xc0,%rbp
cmp    $0x10,%r13
je     2070 <BsiGenerateTables+0xee0>
mov    (%r14),%edi
lea    0xf79(%rip),%rsi
mov    %ebx,%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %ebx,%ebx
jle    20c0 <BsiGenerateTables+0xf30>
xor    %r15d,%r15d
nop
mov    (%r14),%edi
movq   0x0(%rbp,%r15,8),%xmm0
mov    %r12,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%r15
cmp    %r15,%rbx
jne    2100 <BsiGenerateTables+0xf70>
jmp    20c0 <BsiGenerateTables+0xf30>
mov    (%r14),%edi
lea    0x1096(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
movsd  0xed5(%rip),%xmm1
divsd  0x38(%rsp),%xmm1
lea    0xf3a(%rip),%rsi
movaps 0x50(%rsp),%xmm0
mov    $0x2,%al
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0xf65(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32f12(%rip),%edx
lea    0xf80(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32eff(%rip),%edx
lea    0xf68(%rip),%r12
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32ee9(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32eda(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32ecb(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32ebc(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32ead(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e9e(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e8f(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e80(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e71(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e62(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e53(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e44(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e35(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32e26(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0xec1(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0xe3e(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32db8(%rip),%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32da7(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d91(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d7b(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d65(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d4f(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d39(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d23(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32d0d(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32cf7(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32ce1(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32ccb(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32cb5(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32c9f(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32c89(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32c73(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
lea    0xce6(%rip),%r15
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0xce0(%rip),%r13
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32c02(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32bec(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32bd6(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32bc0(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32baa(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b94(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b7e(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b68(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b52(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b3c(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b26(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32b10(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32afa(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32ae4(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32ace(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
lea    0xb58(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32a6f(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32a59(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32a43(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32a2d(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32a17(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32a01(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x329eb(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x329d5(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x329bf(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x329a9(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32993(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x3297d(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32967(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32951(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r12,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x3293b(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x328d8(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x328c2(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x328ac(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32896(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32880(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x3286a(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32854(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x3283e(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32828(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x32812(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x327fc(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x327e6(%rip),%ebx
shl    $0x4,%ebx
add    %ebp,%ebx
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x327d0(%rip),%ebp
shl    $0x4,%ebp
add    %ebx,%ebp
mov    (%r14),%edi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x327ba(%rip),%edx
shl    $0x4,%edx
add    %ebp,%edx
mov    (%r14),%edi
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x84d(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x849(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3274d(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3273e(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3272f(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32720(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32711(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32702(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x326f3(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x326e4(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x326d5(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x326c6(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x326b7(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x326a8(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32699(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3268a(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3267b(%rip),%edx
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3261f(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32610(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32601(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x325f2(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x325e3(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x325d4(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x325c5(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x325b6(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x325a7(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32598(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x32589(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3257a(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3256b(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3255c(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
mov    0x3254d(%rip),%edx
mov    %r13,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x637(%rip),%rsi
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1090 <fprintf@plt>

LLVM IR (-O0):
@BsiGenerateTables.filter = internal global [16 x [17 x [24 x double]]] zeroinitializer
@BsiGenerateTables.scDeltas = internal global [15 x [16 x [24 x double]]] zeroinitializer
@BsiGenerateTables.phDeltas = internal global [16 x [17 x [24 x double]]] zeroinitializer
@BsiGenerateTables.spDeltas = internal global [15 x [16 x [24 x double]]] zeroinitializer
@BsiGenerateTables.mt = internal global [16 x i32] zeroinitializer
@BsiGenerateTables.at = internal global [16 x double] zeroinitializer
@stdout = global i32 0
@.str = [37 x i8] c"static const float bsincTab[%d] =\0A{\0A\00"
@.str.1 = [18 x i8] c" /* %2d,%2d */\00"
@.str.2 = [11 x i8] c" %+14.9ef,\00"
@.str.3 = [3 x i8] c"\0A\0A\00"
@.str.4 = [2 x i8] c"\0A\00"
@.str.5 = [5 x i8] c"};\0A\0A\00"
@.str.6 = [65 x i8] c" static const ALfloat scaleBase = %.9ef, scaleRange = %.9ef;\0A\00"
@.str.7 = [49 x i8] c" static const ALuint m[BSINC_SCALE_COUNT] = {\00"
@.str.8 = [4 x i8] c" %d\00"
@.str.9 = [5 x i8] c", %d\00"
@.str.10 = [5 x i8] c" };\0A\00"
@.str.11 = [69 x i8] c" static const ALuint to[4][BSINC_SCALE_COUNT] =\0A {\0A { 0\00"
@.str.12 = [14 x i8] c" },\0A {\00"
@.str.13 = [5 x i8] c" %d,\00"
@.str.14 = [18 x i8] c" 0 },\0A { 0\00"
@.str.15 = [13 x i8] c" 0 }\0A };\0A\00"
@.str.16 = [70 x i8] c" static const ALuint tm[2][BSINC_SCALE_COUNT] = \0A {\0A { 0\00"
@.str.17 = [14 x i8] c" 0 }\0A };\0A\0A\00"
define void @BsiGenerateTables() {
%1 = alloca double
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca double
%9 = alloca double
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = call i32 @memset(double*** bitcast ([16 x [17 x [24 x double]]]* @BsiGenerateTables.filter to double***), i32 0, i32 52224)
%34 = call i32 @memset(double*** bitcast ([15 x [16 x [24 x double]]]* @BsiGenerateTables.scDeltas to double***), i32 0, i32 46080)
%35 = call i32 @memset(double*** bitcast ([16 x [17 x [24 x double]]]* @BsiGenerateTables.phDeltas to double***), i32 0, i32 52224)
%36 = call i32 @memset(double*** bitcast ([15 x [16 x [24 x double]]]* @BsiGenerateTables.spDeltas to double***), i32 0, i32 46080)
%37 = call double @CalcKaiserWidth(double 6.000000e+01, i32 12)
store double %37, double* %1
%38 = call double @CalcKaiserBeta(double 6.000000e+01)
store double %38, double* %2
%39 = load double, double* %1
%40 = fdiv double %39, 2.000000e+00
store double %40, double* %3
%41 = load double, double* %3
%42 = fsub double 1.000000e+00, %41
store double %42, double* %4
store i32 0, i32* %5
br label %43
43: ; preds = %77, %0
%44 = load i32, i32* %5
%45 = icmp slt i32 %44, 16
br i1 %45, label %46, label %80
46: ; preds = %43
%47 = load double, double* %3
%48 = load double, double* %4
%49 = load i32, i32* %5
%50 = sitofp i32 %49 to double
%51 = fmul double %48, %50
%52 = fdiv double %51, 1.500000e+01
%53 = fadd double %47, %52
store double %53, double* %8
%54 = load double, double* %8
%55 = fmul double 2.000000e+00, %54
%56 = fdiv double 1.200000e+01, %55
%57 = fptosi double %56 to i32
%58 = call double @MinDouble(i32 12, i32 %57)
store double %58, double* %9
%59 = load double, double* %9
%60 = call i64 @floor(double %59)
%61 = trunc i64 %60 to i32
%62 = mul nsw i32 2, %61
store i32 %62, i32* %10
%63 = load i32, i32* %10
%64 = sub nsw i32 %63, 1
%65 = xor i32 %64, -1
%66 = and i32 %65, 3
%67 = load i32, i32* %10
%68 = add nsw i32 %67, %66
store i32 %68, i32* %10
%69 = load i32, i32* %10
%70 = load i32, i32* %5
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %71
store i32 %69, i32* %72
%73 = load double, double* %9
%74 = load i32, i32* %5
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [16 x double], [16 x double]* @BsiGenerateTables.at, i64 0, i64 %75
store double %73, double* %76
br label %77
77: ; preds = %46
%78 = load i32, i32* %5
%79 = add nsw i32 %78, 1
store i32 %79, i32* %5
br label %43
80: ; preds = %43
store i32 0, i32* %5
br label %81
81: ; preds = %165, %80
%82 = load i32, i32* %5
%83 = icmp slt i32 %82, 16
br i1 %83, label %84, label %168
84: ; preds = %81
%85 = load i32, i32* %5
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %86
%88 = load i32, i32* %87
store i32 %88, i32* %11
%89 = load i32, i32* %11
%90 = sdiv i32 %89, 2
%91 = sub nsw i32 12, %90
store i32 %91, i32* %12
%92 = load i32, i32* %11
%93 = sdiv i32 %92, 2
%94 = sub nsw i32 %93, 1
store i32 %94, i32* %13
%95 = load i32, i32* %5
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [16 x double], [16 x double]* @BsiGenerateTables.at, i64 0, i64 %96
%98 = load double, double* %97
store double %98, double* %14
%99 = load double, double* %3
%100 = load double, double* %4
%101 = load i32, i32* %5
%102 = sitofp i32 %101 to double
%103 = fmul double %100, %102
%104 = fdiv double %103, 1.500000e+01
%105 = fadd double %99, %104
store double %105, double* %15
%106 = load double, double* %15
%107 = load double, double* %3
%108 = load double, double* %15
%109 = call double @MaxDouble(double 5.000000e-01, double %108)
%110 = fmul double %107, %109
%111 = fneg double %110
%112 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %106, double %111)
store double %112, double* %16
store i32 0, i32* %6
br label %113
113: ; preds = %161, %84
%114 = load i32, i32* %6
%115 = icmp sle i32 %114, 16
br i1 %115, label %116, label %164
116: ; preds = %113
%117 = load i32, i32* %13
%118 = sitofp i32 %117 to double
%119 = load i32, i32* %6
%120 = sitofp i32 %119 to double
%121 = fdiv double %120, 1.600000e+01
%122 = fadd double %118, %121
store double %122, double* %17
store i32 0, i32* %7
br label %123
123: ; preds = %157, %116
%124 = load i32, i32* %7
%125 = load i32, i32* %11
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %160
127: ; preds = %123
%128 = load i32, i32* %7
%129 = sitofp i32 %128 to double
%130 = load double, double* %17
%131 = fsub double %129, %130
store double %131, double* %18
%132 = load double, double* %2
%133 = load double, double* %18
%134 = load double, double* %14
%135 = fdiv double %133, %134
%136 = call double @Kaiser(double %132, double %135)
%137 = fmul double %136, 2.000000e+00
%138 = load double, double* %16
%139 = fmul double %137, %138
%140 = load double, double* %16
%141 = fmul double 2.000000e+00, %140
%142 = load double, double* %18
%143 = fmul double %141, %142
%144 = call double @Sinc(double %143)
%145 = fmul double %139, %144
%146 = load i32, i32* %5
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 %147
%149 = load i32, i32* %6
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %148, i64 0, i64 %150
%152 = load i32, i32* %12
%153 = load i32, i32* %7
%154 = add nsw i32 %152, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [24 x double], [24 x double]* %151, i64 0, i64 %155
store double %145, double* %156
br label %157
157: ; preds = %127
%158 = load i32, i32* %7
%159 = add nsw i32 %158, 1
store i32 %159, i32* %7
br label %123
160: ; preds = %123
br label %161
161: ; preds = %160
%162 = load i32, i32* %6
%163 = add nsw i32 %162, 1
store i32 %163, i32* %6
br label %113
164: ; preds = %113
br label %165
165: ; preds = %164
%166 = load i32, i32* %5
%167 = add nsw i32 %166, 1
store i32 %167, i32* %5
br label %81
168: ; preds = %81
store i32 0, i32* %5
br label %169
169: ; preds = %234, %168
%170 = load i32, i32* %5
%171 = icmp slt i32 %170, 15
br i1 %171, label %172, label %237
172: ; preds = %169
%173 = load i32, i32* %5
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %174
%176 = load i32, i32* %175
store i32 %176, i32* %19
%177 = load i32, i32* %19
%178 = sdiv i32 %177, 2
%179 = sub nsw i32 12, %178
store i32 %179, i32* %20
store i32 0, i32* %6
br label %180
180: ; preds = %230, %172
%181 = load i32, i32* %6
%182 = icmp slt i32 %181, 16
br i1 %182, label %183, label %233
183: ; preds = %180
store i32 0, i32* %7
br label %184
184: ; preds = %226, %183
%185 = load i32, i32* %7
%186 = load i32, i32* %19
%187 = icmp slt i32 %185, %186
br i1 %187, label %188, label %229
188: ; preds = %184
%189 = load i32, i32* %5
%190 = add nsw i32 %189, 1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 %191
%193 = load i32, i32* %6
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %192, i64 0, i64 %194
%196 = load i32, i32* %20
%197 = load i32, i32* %7
%198 = add nsw i32 %196, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [24 x double], [24 x double]* %195, i64 0, i64 %199
%201 = load double, double* %200
%202 = load i32, i32* %5
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 %203
%205 = load i32, i32* %6
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %204, i64 0, i64 %206
%208 = load i32, i32* %20
%209 = load i32, i32* %7
%210 = add nsw i32 %208, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [24 x double], [24 x double]* %207, i64 0, i64 %211
%213 = load double, double* %212
%214 = fsub double %201, %213
%215 = load i32, i32* %5
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [15 x [16 x [24 x double]]], [15 x [16 x [24 x double]]]* @BsiGenerateTables.scDeltas, i64 0, i64 %216
%218 = load i32, i32* %6
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [16 x [24 x double]], [16 x [24 x double]]* %217, i64 0, i64 %219
%221 = load i32, i32* %20
%222 = load i32, i32* %7
%223 = add nsw i32 %221, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [24 x double], [24 x double]* %220, i64 0, i64 %224
store double %214, double* %225
br label %226
226: ; preds = %188
%227 = load i32, i32* %7
%228 = add nsw i32 %227, 1
store i32 %228, i32* %7
br label %184
229: ; preds = %184
br label %230
230: ; preds = %229
%231 = load i32, i32* %6
%232 = add nsw i32 %231, 1
store i32 %232, i32* %6
br label %180
233: ; preds = %180
br label %234
234: ; preds = %233
%235 = load i32, i32* %5
%236 = add nsw i32 %235, 1
store i32 %236, i32* %5
br label %169
237: ; preds = %169
store i32 0, i32* %5
br label %238
238: ; preds = %303, %237
%239 = load i32, i32* %5
%240 = icmp slt i32 %239, 16
br i1 %240, label %241, label %306
241: ; preds = %238
%242 = load i32, i32* %5
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %243
%245 = load i32, i32* %244
store i32 %245, i32* %21
%246 = load i32, i32* %21
%247 = sdiv i32 %246, 2
%248 = sub nsw i32 12, %247
store i32 %248, i32* %22
store i32 0, i32* %6
br label %249
249: ; preds = %299, %241
%250 = load i32, i32* %6
%251 = icmp slt i32 %250, 16
br i1 %251, label %252, label %302
252: ; preds = %249
store i32 0, i32* %7
br label %253
253: ; preds = %295, %252
%254 = load i32, i32* %7
%255 = load i32, i32* %21
%256 = icmp slt i32 %254, %255
br i1 %256, label %257, label %298
257: ; preds = %253
%258 = load i32, i32* %5
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 %259
%261 = load i32, i32* %6
%262 = add nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %260, i64 0, i64 %263
%265 = load i32, i32* %22
%266 = load i32, i32* %7
%267 = add nsw i32 %265, %266
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds [24 x double], [24 x double]* %264, i64 0, i64 %268
%270 = load double, double* %269
%271 = load i32, i32* %5
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 %272
%274 = load i32, i32* %6
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %273, i64 0, i64 %275
%277 = load i32, i32* %22
%278 = load i32, i32* %7
%279 = add nsw i32 %277, %278
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds [24 x double], [24 x double]* %276, i64 0, i64 %280
%282 = load double, double* %281
%283 = fsub double %270, %282
%284 = load i32, i32* %5
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.phDeltas, i64 0, i64 %285
%287 = load i32, i32* %6
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %286, i64 0, i64 %288
%290 = load i32, i32* %22
%291 = load i32, i32* %7
%292 = add nsw i32 %290, %291
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [24 x double], [24 x double]* %289, i64 0, i64 %293
store double %283, double* %294
br label %295
295: ; preds = %257
%296 = load i32, i32* %7
%297 = add nsw i32 %296, 1
store i32 %297, i32* %7
br label %253
298: ; preds = %253
br label %299
299: ; preds = %298
%300 = load i32, i32* %6
%301 = add nsw i32 %300, 1
store i32 %301, i32* %6
br label %249
302: ; preds = %249
br label %303
303: ; preds = %302
%304 = load i32, i32* %5
%305 = add nsw i32 %304, 1
store i32 %305, i32* %5
br label %238
306: ; preds = %238
store i32 0, i32* %5
br label %307
307: ; preds = %372, %306
%308 = load i32, i32* %5
%309 = icmp slt i32 %308, 15
br i1 %309, label %310, label %375
310: ; preds = %307
%311 = load i32, i32* %5
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %312
%314 = load i32, i32* %313
store i32 %314, i32* %23
%315 = load i32, i32* %23
%316 = sdiv i32 %315, 2
%317 = sub nsw i32 12, %316
store i32 %317, i32* %24
store i32 0, i32* %6
br label %318
318: ; preds = %368, %310
%319 = load i32, i32* %6
%320 = icmp slt i32 %319, 16
br i1 %320, label %321, label %371
321: ; preds = %318
store i32 0, i32* %7
br label %322
322: ; preds = %364, %321
%323 = load i32, i32* %7
%324 = load i32, i32* %23
%325 = icmp slt i32 %323, %324
br i1 %325, label %326, label %367
326: ; preds = %322
%327 = load i32, i32* %5
%328 = add nsw i32 %327, 1
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.phDeltas, i64 0, i64 %329
%331 = load i32, i32* %6
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %330, i64 0, i64 %332
%334 = load i32, i32* %24
%335 = load i32, i32* %7
%336 = add nsw i32 %334, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [24 x double], [24 x double]* %333, i64 0, i64 %337
%339 = load double, double* %338
%340 = load i32, i32* %5
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.phDeltas, i64 0, i64 %341
%343 = load i32, i32* %6
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %342, i64 0, i64 %344
%346 = load i32, i32* %24
%347 = load i32, i32* %7
%348 = add nsw i32 %346, %347
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [24 x double], [24 x double]* %345, i64 0, i64 %349
%351 = load double, double* %350
%352 = fsub double %339, %351
%353 = load i32, i32* %5
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds [15 x [16 x [24 x double]]], [15 x [16 x [24 x double]]]* @BsiGenerateTables.spDeltas, i64 0, i64 %354
%356 = load i32, i32* %6
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [16 x [24 x double]], [16 x [24 x double]]* %355, i64 0, i64 %357
%359 = load i32, i32* %24
%360 = load i32, i32* %7
%361 = add nsw i32 %359, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [24 x double], [24 x double]* %358, i64 0, i64 %362
store double %352, double* %363
br label %364
364: ; preds = %326
%365 = load i32, i32* %7
%366 = add nsw i32 %365, 1
store i32 %366, i32* %7
br label %322
367: ; preds = %322
br label %368
368: ; preds = %367
%369 = load i32, i32* %6
%370 = add nsw i32 %369, 1
store i32 %370, i32* %6
br label %318
371: ; preds = %318
br label %372
372: ; preds = %371
%373 = load i32, i32* %5
%374 = add nsw i32 %373, 1
store i32 %374, i32* %5
br label %307
375: ; preds = %307
%376 = load i32, i32* getelementptr inbounds ([16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 0)
store i32 %376, i32* %7
store i32 1, i32* %5
br label %377
377: ; preds = %388, %375
%378 = load i32, i32* %5
%379 = icmp slt i32 %378, 16
br i1 %379, label %380, label %391
380: ; preds = %377
%381 = load i32, i32* %5
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %382
%384 = load i32, i32* %383
%385 = mul nsw i32 16, %384
%386 = load i32, i32* %7
%387 = add nsw i32 %386, %385
store i32 %387, i32* %7
br label %388
388: ; preds = %380
%389 = load i32, i32* %5
%390 = add nsw i32 %389, 1
store i32 %390, i32* %5
br label %377
391: ; preds = %377
store i32 0, i32* %5
br label %392
392: ; preds = %403, %391
%393 = load i32, i32* %5
%394 = icmp slt i32 %393, 15
br i1 %394, label %395, label %406
395: ; preds = %392
%396 = load i32, i32* %5
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %397
%399 = load i32, i32* %398
%400 = mul nsw i32 32, %399
%401 = load i32, i32* %7
%402 = add nsw i32 %401, %400
store i32 %402, i32* %7
br label %403
403: ; preds = %395
%404 = load i32, i32* %5
%405 = add nsw i32 %404, 1
store i32 %405, i32* %5
br label %392
406: ; preds = %392
store i32 1, i32* %5
br label %407
407: ; preds = %418, %406
%408 = load i32, i32* %5
%409 = icmp slt i32 %408, 16
br i1 %409, label %410, label %421
410: ; preds = %407
%411 = load i32, i32* %5
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %412
%414 = load i32, i32* %413
%415 = mul nsw i32 16, %414
%416 = load i32, i32* %7
%417 = add nsw i32 %416, %415
store i32 %417, i32* %7
br label %418
418: ; preds = %410
%419 = load i32, i32* %5
%420 = add nsw i32 %419, 1
store i32 %420, i32* %5
br label %407
421: ; preds = %407
%422 = load i32, i32* @stdout
%423 = load i32, i32* %7
%424 = call i32 (i32, i8*, ...) @fprintf(i32 %422, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i32 %423)
%425 = load i32, i32* @stdout
%426 = load i32, i32* getelementptr inbounds ([16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 0)
%427 = call i32 (i32, i8*, ...) @fprintf(i32 %425, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %426, i32 0)
store i32 0, i32* %7
br label %428
428: ; preds = %439, %421
%429 = load i32, i32* %7
%430 = load i32, i32* getelementptr inbounds ([16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 0)
%431 = icmp slt i32 %429, %430
br i1 %431, label %432, label %442
432: ; preds = %428
%433 = load i32, i32* @stdout
%434 = load i32, i32* %7
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds [24 x double], [24 x double]* getelementptr inbounds ([16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 0, i64 0), i64 0, i64 %435
%437 = load double, double* %436
%438 = call i32 (i32, i8*, ...) @fprintf(i32 %433, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), double %437)
br label %439
439: ; preds = %432
%440 = load i32, i32* %7
%441 = add nsw i32 %440, 1
store i32 %441, i32* %7
br label %428
442: ; preds = %428
%443 = load i32, i32* @stdout
%444 = call i32 (i32, i8*, ...) @fprintf(i32 %443, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %5
br label %445
445: ; preds = %493, %442
%446 = load i32, i32* %5
%447 = icmp slt i32 %446, 16
br i1 %447, label %448, label %496
448: ; preds = %445
%449 = load i32, i32* %5
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %450
%452 = load i32, i32* %451
store i32 %452, i32* %25
%453 = load i32, i32* %25
%454 = sdiv i32 %453, 2
%455 = sub nsw i32 12, %454
store i32 %455, i32* %26
store i32 0, i32* %6
br label %456
456: ; preds = %489, %448
%457 = load i32, i32* %6
%458 = icmp slt i32 %457, 16
br i1 %458, label %459, label %492
459: ; preds = %456
%460 = load i32, i32* @stdout
%461 = load i32, i32* %25
%462 = load i32, i32* %6
%463 = call i32 (i32, i8*, ...) @fprintf(i32 %460, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %461, i32 %462)
store i32 0, i32* %7
br label %464
464: ; preds = %483, %459
%465 = load i32, i32* %7
%466 = load i32, i32* %25
%467 = icmp slt i32 %465, %466
br i1 %467, label %468, label %486
468: ; preds = %464
%469 = load i32, i32* @stdout
%470 = load i32, i32* %5
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.filter, i64 0, i64 %471
%473 = load i32, i32* %6
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %472, i64 0, i64 %474
%476 = load i32, i32* %26
%477 = load i32, i32* %7
%478 = add nsw i32 %476, %477
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds [24 x double], [24 x double]* %475, i64 0, i64 %479
%481 = load double, double* %480
%482 = call i32 (i32, i8*, ...) @fprintf(i32 %469, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), double %481)
br label %483
483: ; preds = %468
%484 = load i32, i32* %7
%485 = add nsw i32 %484, 1
store i32 %485, i32* %7
br label %464
486: ; preds = %464
%487 = load i32, i32* @stdout
%488 = call i32 (i32, i8*, ...) @fprintf(i32 %487, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %489
489: ; preds = %486
%490 = load i32, i32* %6
%491 = add nsw i32 %490, 1
store i32 %491, i32* %6
br label %456
492: ; preds = %456
br label %493
493: ; preds = %492
%494 = load i32, i32* %5
%495 = add nsw i32 %494, 1
store i32 %495, i32* %5
br label %445
496: ; preds = %445
%497 = load i32, i32* @stdout
%498 = call i32 (i32, i8*, ...) @fprintf(i32 %497, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %5
br label %499
499: ; preds = %547, %496
%500 = load i32, i32* %5
%501 = icmp slt i32 %500, 15
br i1 %501, label %502, label %550
502: ; preds = %499
%503 = load i32, i32* %5
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %504
%506 = load i32, i32* %505
store i32 %506, i32* %27
%507 = load i32, i32* %27
%508 = sdiv i32 %507, 2
%509 = sub nsw i32 12, %508
store i32 %509, i32* %28
store i32 0, i32* %6
br label %510
510: ; preds = %543, %502
%511 = load i32, i32* %6
%512 = icmp slt i32 %511, 16
br i1 %512, label %513, label %546
513: ; preds = %510
%514 = load i32, i32* @stdout
%515 = load i32, i32* %27
%516 = load i32, i32* %6
%517 = call i32 (i32, i8*, ...) @fprintf(i32 %514, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %515, i32 %516)
store i32 0, i32* %7
br label %518
518: ; preds = %537, %513
%519 = load i32, i32* %7
%520 = load i32, i32* %27
%521 = icmp slt i32 %519, %520
br i1 %521, label %522, label %540
522: ; preds = %518
%523 = load i32, i32* @stdout
%524 = load i32, i32* %5
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [15 x [16 x [24 x double]]], [15 x [16 x [24 x double]]]* @BsiGenerateTables.scDeltas, i64 0, i64 %525
%527 = load i32, i32* %6
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds [16 x [24 x double]], [16 x [24 x double]]* %526, i64 0, i64 %528
%530 = load i32, i32* %28
%531 = load i32, i32* %7
%532 = add nsw i32 %530, %531
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds [24 x double], [24 x double]* %529, i64 0, i64 %533
%535 = load double, double* %534
%536 = call i32 (i32, i8*, ...) @fprintf(i32 %523, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), double %535)
br label %537
537: ; preds = %522
%538 = load i32, i32* %7
%539 = add nsw i32 %538, 1
store i32 %539, i32* %7
br label %518
540: ; preds = %518
%541 = load i32, i32* @stdout
%542 = call i32 (i32, i8*, ...) @fprintf(i32 %541, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %543
543: ; preds = %540
%544 = load i32, i32* %6
%545 = add nsw i32 %544, 1
store i32 %545, i32* %6
br label %510
546: ; preds = %510
br label %547
547: ; preds = %546
%548 = load i32, i32* %5
%549 = add nsw i32 %548, 1
store i32 %549, i32* %5
br label %499
550: ; preds = %499
%551 = load i32, i32* @stdout
%552 = call i32 (i32, i8*, ...) @fprintf(i32 %551, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32 1, i32* %5
br label %553
553: ; preds = %601, %550
%554 = load i32, i32* %5
%555 = icmp slt i32 %554, 16
br i1 %555, label %556, label %604
556: ; preds = %553
%557 = load i32, i32* %5
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %558
%560 = load i32, i32* %559
store i32 %560, i32* %29
%561 = load i32, i32* %29
%562 = sdiv i32 %561, 2
%563 = sub nsw i32 12, %562
store i32 %563, i32* %30
store i32 0, i32* %6
br label %564
564: ; preds = %597, %556
%565 = load i32, i32* %6
%566 = icmp slt i32 %565, 16
br i1 %566, label %567, label %600
567: ; preds = %564
%568 = load i32, i32* @stdout
%569 = load i32, i32* %29
%570 = load i32, i32* %6
%571 = call i32 (i32, i8*, ...) @fprintf(i32 %568, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %569, i32 %570)
store i32 0, i32* %7
br label %572
572: ; preds = %591, %567
%573 = load i32, i32* %7
%574 = load i32, i32* %29
%575 = icmp slt i32 %573, %574
br i1 %575, label %576, label %594
576: ; preds = %572
%577 = load i32, i32* @stdout
%578 = load i32, i32* %5
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds [16 x [17 x [24 x double]]], [16 x [17 x [24 x double]]]* @BsiGenerateTables.phDeltas, i64 0, i64 %579
%581 = load i32, i32* %6
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds [17 x [24 x double]], [17 x [24 x double]]* %580, i64 0, i64 %582
%584 = load i32, i32* %30
%585 = load i32, i32* %7
%586 = add nsw i32 %584, %585
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds [24 x double], [24 x double]* %583, i64 0, i64 %587
%589 = load double, double* %588
%590 = call i32 (i32, i8*, ...) @fprintf(i32 %577, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), double %589)
br label %591
591: ; preds = %576
%592 = load i32, i32* %7
%593 = add nsw i32 %592, 1
store i32 %593, i32* %7
br label %572
594: ; preds = %572
%595 = load i32, i32* @stdout
%596 = call i32 (i32, i8*, ...) @fprintf(i32 %595, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %597
597: ; preds = %594
%598 = load i32, i32* %6
%599 = add nsw i32 %598, 1
store i32 %599, i32* %6
br label %564
600: ; preds = %564
br label %601
601: ; preds = %600
%602 = load i32, i32* %5
%603 = add nsw i32 %602, 1
store i32 %603, i32* %5
br label %553
604: ; preds = %553
%605 = load i32, i32* @stdout
%606 = call i32 (i32, i8*, ...) @fprintf(i32 %605, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %5
br label %607
607: ; preds = %655, %604
%608 = load i32, i32* %5
%609 = icmp slt i32 %608, 15
br i1 %609, label %610, label %658
610: ; preds = %607
%611 = load i32, i32* %5
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %612
%614 = load i32, i32* %613
store i32 %614, i32* %31
%615 = load i32, i32* %31
%616 = sdiv i32 %615, 2
%617 = sub nsw i32 12, %616
store i32 %617, i32* %32
store i32 0, i32* %6
br label %618
618: ; preds = %651, %610
%619 = load i32, i32* %6
%620 = icmp slt i32 %619, 16
br i1 %620, label %621, label %654
621: ; preds = %618
%622 = load i32, i32* @stdout
%623 = load i32, i32* %31
%624 = load i32, i32* %6
%625 = call i32 (i32, i8*, ...) @fprintf(i32 %622, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i32 %623, i32 %624)
store i32 0, i32* %7
br label %626
626: ; preds = %645, %621
%627 = load i32, i32* %7
%628 = load i32, i32* %31
%629 = icmp slt i32 %627, %628
br i1 %629, label %630, label %648
630: ; preds = %626
%631 = load i32, i32* @stdout
%632 = load i32, i32* %5
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds [15 x [16 x [24 x double]]], [15 x [16 x [24 x double]]]* @BsiGenerateTables.spDeltas, i64 0, i64 %633
%635 = load i32, i32* %6
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds [16 x [24 x double]], [16 x [24 x double]]* %634, i64 0, i64 %636
%638 = load i32, i32* %32
%639 = load i32, i32* %7
%640 = add nsw i32 %638, %639
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds [24 x double], [24 x double]* %637, i64 0, i64 %641
%643 = load double, double* %642
%644 = call i32 (i32, i8*, ...) @fprintf(i32 %631, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), double %643)
br label %645
645: ; preds = %630
%646 = load i32, i32* %7
%647 = add nsw i32 %646, 1
store i32 %647, i32* %7
br label %626
648: ; preds = %626
%649 = load i32, i32* @stdout
%650 = call i32 (i32, i8*, ...) @fprintf(i32 %649, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %651
651: ; preds = %648
%652 = load i32, i32* %6
%653 = add nsw i32 %652, 1
store i32 %653, i32* %6
br label %618
654: ; preds = %618
br label %655
655: ; preds = %654
%656 = load i32, i32* %5
%657 = add nsw i32 %656, 1
store i32 %657, i32* %5
br label %607
658: ; preds = %607
%659 = load i32, i32* @stdout
%660 = call i32 (i32, i8*, ...) @fprintf(i32 %659, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%661 = load i32, i32* @stdout
%662 = load double, double* %3
%663 = load double, double* %4
%664 = fdiv double 1.000000e+00, %663
%665 = call i32 (i32, i8*, ...) @fprintf(i32 %661, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.6, i64 0, i64 0), double %662, double %664)
%666 = load i32, i32* @stdout
%667 = call i32 (i32, i8*, ...) @fprintf(i32 %666, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.7, i64 0, i64 0))
%668 = load i32, i32* @stdout
%669 = load i32, i32* getelementptr inbounds ([16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 0)
%670 = call i32 (i32, i8*, ...) @fprintf(i32 %668, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i32 %669)
store i32 1, i32* %5
br label %671
671: ; preds = %681, %658
%672 = load i32, i32* %5
%673 = icmp slt i32 %672, 16
br i1 %673, label %674, label %684
674: ; preds = %671
%675 = load i32, i32* @stdout
%676 = load i32, i32* %5
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %677
%679 = load i32, i32* %678
%680 = call i32 (i32, i8*, ...) @fprintf(i32 %675, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %679)
br label %681
681: ; preds = %674
%682 = load i32, i32* %5
%683 = add nsw i32 %682, 1
store i32 %683, i32* %5
br label %671
684: ; preds = %671
%685 = load i32, i32* @stdout
%686 = call i32 (i32, i8*, ...) @fprintf(i32 %685, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%687 = load i32, i32* @stdout
%688 = call i32 (i32, i8*, ...) @fprintf(i32 %687, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.11, i64 0, i64 0))
%689 = load i32, i32* getelementptr inbounds ([16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 0)
store i32 %689, i32* %7
store i32 1, i32* %5
br label %690
690: ; preds = %704, %684
%691 = load i32, i32* %5
%692 = icmp slt i32 %691, 16
br i1 %692, label %693, label %707
693: ; preds = %690
%694 = load i32, i32* @stdout
%695 = load i32, i32* %7
%696 = call i32 (i32, i8*, ...) @fprintf(i32 %694, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %695)
%697 = load i32, i32* %5
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %698
%700 = load i32, i32* %699
%701 = mul nsw i32 16, %700
%702 = load i32, i32* %7
%703 = add nsw i32 %702, %701
store i32 %703, i32* %7
br label %704
704: ; preds = %693
%705 = load i32, i32* %5
%706 = add nsw i32 %705, 1
store i32 %706, i32* %5
br label %690
707: ; preds = %690
%708 = load i32, i32* @stdout
%709 = call i32 (i32, i8*, ...) @fprintf(i32 %708, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %5
br label %710
710: ; preds = %724, %707
%711 = load i32, i32* %5
%712 = icmp slt i32 %711, 15
br i1 %712, label %713, label %727
713: ; preds = %710
%714 = load i32, i32* @stdout
%715 = load i32, i32* %7
%716 = call i32 (i32, i8*, ...) @fprintf(i32 %714, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i32 %715)
%717 = load i32, i32* %5
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %718
%720 = load i32, i32* %719
%721 = mul nsw i32 16, %720
%722 = load i32, i32* %7
%723 = add nsw i32 %722, %721
store i32 %723, i32* %7
br label %724
724: ; preds = %713
%725 = load i32, i32* %5
%726 = add nsw i32 %725, 1
store i32 %726, i32* %5
br label %710
727: ; preds = %710
%728 = load i32, i32* @stdout
%729 = call i32 (i32, i8*, ...) @fprintf(i32 %728, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.14, i64 0, i64 0))
store i32 1, i32* %5
br label %730
730: ; preds = %744, %727
%731 = load i32, i32* %5
%732 = icmp slt i32 %731, 16
br i1 %732, label %733, label %747
733: ; preds = %730
%734 = load i32, i32* @stdout
%735 = load i32, i32* %7
%736 = call i32 (i32, i8*, ...) @fprintf(i32 %734, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %735)
%737 = load i32, i32* %5
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %738
%740 = load i32, i32* %739
%741 = mul nsw i32 16, %740
%742 = load i32, i32* %7
%743 = add nsw i32 %742, %741
store i32 %743, i32* %7
br label %744
744: ; preds = %733
%745 = load i32, i32* %5
%746 = add nsw i32 %745, 1
store i32 %746, i32* %5
br label %730
747: ; preds = %730
%748 = load i32, i32* @stdout
%749 = call i32 (i32, i8*, ...) @fprintf(i32 %748, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %5
br label %750
750: ; preds = %764, %747
%751 = load i32, i32* %5
%752 = icmp slt i32 %751, 15
br i1 %752, label %753, label %767
753: ; preds = %750
%754 = load i32, i32* @stdout
%755 = load i32, i32* %7
%756 = call i32 (i32, i8*, ...) @fprintf(i32 %754, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i32 %755)
%757 = load i32, i32* %5
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %758
%760 = load i32, i32* %759
%761 = mul nsw i32 16, %760
%762 = load i32, i32* %7
%763 = add nsw i32 %762, %761
store i32 %763, i32* %7
br label %764
764: ; preds = %753
%765 = load i32, i32* %5
%766 = add nsw i32 %765, 1
store i32 %766, i32* %5
br label %750
767: ; preds = %750
%768 = load i32, i32* @stdout
%769 = call i32 (i32, i8*, ...) @fprintf(i32 %768, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i64 0, i64 0))
%770 = load i32, i32* @stdout
%771 = call i32 (i32, i8*, ...) @fprintf(i32 %770, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.16, i64 0, i64 0))
store i32 1, i32* %5
br label %772
772: ; preds = %782, %767
%773 = load i32, i32* %5
%774 = icmp slt i32 %773, 16
br i1 %774, label %775, label %785
775: ; preds = %772
%776 = load i32, i32* @stdout
%777 = load i32, i32* %5
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %778
%780 = load i32, i32* %779
%781 = call i32 (i32, i8*, ...) @fprintf(i32 %776, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i32 %780)
br label %782
782: ; preds = %775
%783 = load i32, i32* %5
%784 = add nsw i32 %783, 1
store i32 %784, i32* %5
br label %772
785: ; preds = %772
%786 = load i32, i32* @stdout
%787 = call i32 (i32, i8*, ...) @fprintf(i32 %786, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
store i32 0, i32* %5
br label %788
788: ; preds = %798, %785
%789 = load i32, i32* %5
%790 = icmp slt i32 %789, 15
br i1 %790, label %791, label %801
791: ; preds = %788
%792 = load i32, i32* @stdout
%793 = load i32, i32* %5
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds [16 x i32], [16 x i32]* @BsiGenerateTables.mt, i64 0, i64 %794
%796 = load i32, i32* %795
%797 = call i32 (i32, i8*, ...) @fprintf(i32 %792, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.13, i64 0, i64 0), i32 %796)
br label %798
798: ; preds = %791
%799 = load i32, i32* %5
%800 = add nsw i32 %799, 1
store i32 %800, i32* %5
br label %788
801: ; preds = %788
%802 = load i32, i32* @stdout
%803 = call i32 (i32, i8*, ...) @fprintf(i32 %802, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.17, i64 0, i64 0))
ret void
}

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