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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stderr;
void usage(char *fname) {
  char *funcname;
  funcname = "usage";
  fprintf(stderr, "usage: %s [options]\n", fname);
  fprintf(stderr, "Where at least one option is required, and\n");
  fprintf(stderr, "where options can be any of the following:\n");
  fprintf(stderr, "\t -O for online processing [FALSE]\n");
  fprintf(stderr, "\t -d for debug output [FALSE]\n");
  fprintf(stderr,
          "\t -M adds a small constant to the power spectrum [FALSE]\n");
  fprintf(stderr, "\t\tequivalent to one bit of random noise on the input.\n");
  fprintf(stderr,
          "\t\tThis helps to avoid the numerical problems that occur\n");
  fprintf(stderr, "\t\twhen there are long stretches of zeros in the data\n");
  fprintf(stderr, "\t -F highpass filter on waveform (in case of DC offset "
                  "problems) [FALSE]\n");
  fprintf(stderr, "\t -i input file name [stdin]\n");
  fprintf(stderr, "\t -o output file name [stdout]\n");
  fprintf(stderr, "\t -a for input file ascii rather than shorts [FALSE]\n");
  fprintf(stderr, "\t\tNote that default input is binary shorts\n");
  fprintf(stderr, "\t -A for output file ascii rather than floats [FALSE]\n");
  fprintf(stderr, "\t\tNote that default output is binary floats\n");
  fprintf(stderr, "\t -e for input files ESPS format[FALSE]\n");
  fprintf(stderr, "\t\tNote that default input is binary shorts\n");
  fprintf(stderr, "\t -E for output files ESPS format[FALSE]\n");
  fprintf(stderr, "\t\tNote that default output is binary floats\n");
  fprintf(stderr, "\t -b for input files MAT format[FALSE]\n");
  fprintf(stderr, "\t\tNote that default input is binary shorts\n");
  fprintf(stderr, "\t -B for output files MAT format[FALSE]\n");
  fprintf(stderr, "\t\tNote that default output is binary floats\n");
  fprintf(stderr, "\t -z for input files SPHERE format[FALSE]\n");
  fprintf(stderr, "\t\tNote that default input is binary shorts\n");
  fprintf(stderr, "\t -k for Abbot I/O [FALSE]\n");
  fprintf(stderr, "\t\tNote that the default I/O format is binary shorts\n");
  fprintf(stderr, "\t -T for little-endian input. [FALSE]\n");
  fprintf(stderr, "\t\tThis option only applies to raw binary input.\n");
  fprintf(stderr, "\t -U for little-endian output. [FALSE]\n");
  fprintf(stderr, "\t\tThis option only applies to raw binary output.\n");
  fprintf(stderr, "\t -y for padded input. [FALSE]\n");
  fprintf(stderr, "\t\tIf there are M points per step and L input points,\n");
  fprintf(stderr,
          "\t\tproduce L/M frames, where the ((n + 0.5) * M)-th point\n");
  fprintf(stderr, "\t\tis centered in the n-th frame.\n");
  fprintf(stderr,
          "\t\tThere must be at least one window of data to produce output.\n");
  fprintf(stderr, "\t -J for JAH rasta [FALSE]\n");
  fprintf(stderr, "\t -C for constant JAH.  This option should [FALSE]\n");
  fprintf(stderr, "\t\tgenerally be used during recognizer training.\n");
  fprintf(stderr, "\t\tDefault is adapting JAH according to noisepower\n");
  fprintf(stderr, "\t\tOnly use option -C when -J is used\n");
  fprintf(stderr, "\t -f for JAH Rasta mapping coefficients input text file\n");
  fprintf(stderr, "\t -L for log rasta [FALSE]\n");
  fprintf(stderr, "\t -R for getting critical band values as output(ASCII)\n");
  fprintf(stderr, "\t\tinstead of cepstral coefficients [FALSE]\n");
  fprintf(stderr,
          "\t\tNote: This is useful for users who would like to find\n");
  fprintf(stderr, "\t\t      their own spectral mapping coefficients.\n");
  fprintf(stderr, "\t\tNote: This overrules the -P option.\n");
  fprintf(stderr, "\t -P for getting cube root compressed and equalized\n");
  fprintf(stderr, "\t\t critical band values as output instead of cepstral\n");
  fprintf(stderr, "\t\t coefficients [FALSE]\n");
  fprintf(stderr, "\t -r for partially rasta, partially plp\n");
  fprintf(
      stderr,
      "\t    e.g. -r 1.0 => no mixing, -r 0.8 => 80%% rasta 20%% PLP  [1.0]\n");
  fprintf(stderr, "\t -w analysis window size (in milliseconds) [%d]\n", 20);
  fprintf(stderr, "\t -W windowing constant [%f]\n", .54);
  fprintf(stderr, "\t -s window step size (in milliseconds) [%d]\n", 10);
  fprintf(stderr, "\t -S Sampling frequency (in Hertz) [%d]\n", 8000);
  fprintf(stderr, "\t -l liftering exponent [%f]\n", 0.6);
  fprintf(stderr, "\t -p pole position [%f]\n", .94);
  fprintf(stderr, "\t -m model order [%d]\n", 8);
  fprintf(stderr, "\t -n number of output parameters \n");
  fprintf(stderr, "\t\twhere default is model order plus 1 (log gain) \n");
  fprintf(stderr, "\t\tand log gain is given first\n");
  fprintf(stderr, "\t -c num of crit band filters order \n");
  fprintf(stderr, "\t\twhere default depends on sampling freq, but ");
  fprintf(stderr, "is 17 for 8000 Hz\n");
  fprintf(stderr, "\t -v (if you want triangular filters)[trapezoidal]\n");
  fprintf(stderr, "\t -g (if you don't want gain computed)[compute gain]\n");
  fprintf(stderr, "\t -N numerator rastafilt file \n");
  fprintf(stderr, "\t\t (currently unimplemented)\n");
  fprintf(stderr, "\t -D denominator rastafilt file \n");
  fprintf(stderr, "\t\t (currently unimplemented)\n");
  fprintf(stderr, "\t -j Constant J [%e] depends on the noise level,\n",
          1.0e-6);
  fprintf(stderr, "\t\t( smaller for more noisy speech)\n");
  fprintf(stderr, "\t\tNote: Only use option -j when -C is used\n");
  fprintf(stderr, "\t -h use stored noise level estimation and RASTA filter\n");
  fprintf(stderr, "\t\thistory for initialization (if history file is\n");
  fprintf(stderr, "\t\tavailable, otherwise use normal initialization)\n");
  fprintf(stderr, "\t -H history filename [history.out]\n\n");
  exit(0);
}


x86 assembly (clang, -O0):
<usage>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
lea    0xeed(%rip),%rax
mov    %rax,-0x10(%rbp)
mov    0x2ea2(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rdx
lea    0xedb(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e87(%rip),%rax
mov    (%rax),%edi
lea    0xed9(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e70(%rip),%rax
mov    (%rax),%edi
lea    0xeee(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e59(%rip),%rax
mov    (%rax),%edi
lea    0xf03(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e42(%rip),%rax
mov    (%rax),%edi
lea    0xf10(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e2b(%rip),%rax
mov    (%rax),%edi
lea    0xf18(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e14(%rip),%rax
mov    (%rax),%edi
lea    0xf3b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2dfd(%rip),%rax
mov    (%rax),%edi
lea    0xf5b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2de6(%rip),%rax
mov    (%rax),%edi
lea    0xf7d(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2dcf(%rip),%rax
mov    (%rax),%edi
lea    0xf9c(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2db8(%rip),%rax
mov    (%rax),%edi
lea    0xfcf(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2da1(%rip),%rax
mov    (%rax),%edi
lea    0xfd6(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d8a(%rip),%rax
mov    (%rax),%edi
lea    0xfdf(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d73(%rip),%rax
mov    (%rax),%edi
lea    0xffe(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d5c(%rip),%rax
mov    (%rax),%edi
lea    0x1013(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d45(%rip),%rax
mov    (%rax),%edi
lea    0x1033(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d2e(%rip),%rax
mov    (%rax),%edi
lea    0x1049(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d17(%rip),%rax
mov    (%rax),%edi
lea    0xfa2(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d00(%rip),%rax
mov    (%rax),%edi
lea    0x1044(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ce9(%rip),%rax
mov    (%rax),%edi
lea    0xfd7(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cd2(%rip),%rax
mov    (%rax),%edi
lea    0x1040(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cbb(%rip),%rax
mov    (%rax),%edi
lea    0xf46(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ca4(%rip),%rax
mov    (%rax),%edi
lea    0x103a(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c8d(%rip),%rax
mov    (%rax),%edi
lea    0xf7b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c76(%rip),%rax
mov    (%rax),%edi
lea    0x1035(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c5f(%rip),%rax
mov    (%rax),%edi
lea    0xeea(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c48(%rip),%rax
mov    (%rax),%edi
lea    0x1032(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c31(%rip),%rax
mov    (%rax),%edi
lea    0x1037(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c1a(%rip),%rax
mov    (%rax),%edi
lea    0x1055(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c03(%rip),%rax
mov    (%rax),%edi
lea    0x1065(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2bec(%rip),%rax
mov    (%rax),%edi
lea    0x107f(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2bd5(%rip),%rax
mov    (%rax),%edi
lea    0x1090(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2bbe(%rip),%rax
mov    (%rax),%edi
lea    0x10ab(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ba7(%rip),%rax
mov    (%rax),%edi
lea    0x10b4(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b90(%rip),%rax
mov    (%rax),%edi
lea    0x10d3(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b79(%rip),%rax
mov    (%rax),%edi
lea    0x10f6(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b62(%rip),%rax
mov    (%rax),%edi
lea    0x1101(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b4b(%rip),%rax
mov    (%rax),%edi
lea    0x112a(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b34(%rip),%rax
mov    (%rax),%edi
lea    0x112f(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b1d(%rip),%rax
mov    (%rax),%edi
lea    0x114c(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2b06(%rip),%rax
mov    (%rax),%edi
lea    0x1166(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2aef(%rip),%rax
mov    (%rax),%edi
lea    0x1182(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ad8(%rip),%rax
mov    (%rax),%edi
lea    0x1191(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ac1(%rip),%rax
mov    (%rax),%edi
lea    0x11b3(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2aaa(%rip),%rax
mov    (%rax),%edi
lea    0x11b8(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a93(%rip),%rax
mov    (%rax),%edi
lea    0x11d9(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a7c(%rip),%rax
mov    (%rax),%edi
lea    0x11ee(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a65(%rip),%rax
mov    (%rax),%edi
lea    0x1210(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a4e(%rip),%rax
mov    (%rax),%edi
lea    0x122b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a37(%rip),%rax
mov    (%rax),%edi
lea    0x123b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a20(%rip),%rax
mov    (%rax),%edi
lea    0x1259(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2a09(%rip),%rax
mov    (%rax),%edi
lea    0x1279(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x29f2(%rip),%rax
mov    (%rax),%edi
lea    0x127b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x29db(%rip),%rax
mov    (%rax),%edi
lea    0x128d(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x29c4(%rip),%rax
mov    (%rax),%edi
lea    0x12bb(%rip),%rsi
mov    $0x14,%edx
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x29a8(%rip),%rax
mov    (%rax),%edi
lea    0x12d1(%rip),%rsi
movsd  0x9cf(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    0x2989(%rip),%rax
mov    (%rax),%edi
lea    0x12d0(%rip),%rsi
mov    $0xa,%edx
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x296d(%rip),%rax
mov    (%rax),%edi
lea    0x12e2(%rip),%rsi
mov    $0x1f40,%edx
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2951(%rip),%rax
mov    (%rax),%edi
lea    0x12ef(%rip),%rsi
movsd  0x970(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    0x2932(%rip),%rax
mov    (%rax),%edi
lea    0x12ee(%rip),%rsi
movsd  0x949(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    0x2913(%rip),%rax
mov    (%rax),%edi
lea    0x12e8(%rip),%rsi
mov    $0x8,%edx
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x28f7(%rip),%rax
mov    (%rax),%edi
lea    0x12e3(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x28e0(%rip),%rax
mov    (%rax),%edi
lea    0x12ef(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x28c9(%rip),%rax
mov    (%rax),%edi
lea    0x130b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x28b2(%rip),%rax
mov    (%rax),%edi
lea    0x1313(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x289b(%rip),%rax
mov    (%rax),%edi
lea    0x1322(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2884(%rip),%rax
mov    (%rax),%edi
lea    0x133a(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x286d(%rip),%rax
mov    (%rax),%edi
lea    0x1336(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2856(%rip),%rax
mov    (%rax),%edi
lea    0x1353(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x283f(%rip),%rax
mov    (%rax),%edi
lea    0x1372(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2828(%rip),%rax
mov    (%rax),%edi
lea    0x137b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2811(%rip),%rax
mov    (%rax),%edi
lea    0x1382(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x27fa(%rip),%rax
mov    (%rax),%edi
lea    0x134d(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x27e3(%rip),%rax
mov    (%rax),%edi
lea    0x1376(%rip),%rsi
movsd  0x7f2(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    0x27c4(%rip),%rax
mov    (%rax),%edi
lea    0x1389(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x27ad(%rip),%rax
mov    (%rax),%edi
lea    0x1396(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2796(%rip),%rax
mov    (%rax),%edi
lea    0x13ab(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x277f(%rip),%rax
mov    (%rax),%edi
lea    0x13cd(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2768(%rip),%rax
mov    (%rax),%edi
lea    0x13e8(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2751(%rip),%rax
mov    (%rax),%edi
lea    0x1404(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
xor    %edi,%edi
call   1040 <exit@plt>

x86 assembly (clang, -O2):
<usage>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rdx
mov    0x2eb1(%rip),%rbx
mov    (%rbx),%edi
lea    0xee8(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xeed(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf09(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf25(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf39(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf48(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf72(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf99(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfc2(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfe8(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1022(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1030(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1040(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1066(%rip),%r14
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x107f(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10a6(%rip),%r15
mov    %r15,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10c0(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10cd(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10db(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10e7(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10f4(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1103(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x110f(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1134(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x114b(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x116c(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1184(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11a6(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11b6(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11dc(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1206(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1218(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1248(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1254(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1278(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1299(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12bc(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12d2(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12fb(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1307(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x132f(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x134b(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1374(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1396(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13ad(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13d2(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13f9(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1402(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x141b(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1450(%rip),%rsi
mov    $0x14,%edx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x146d(%rip),%rsi
movsd  0xb59(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1473(%rip),%rsi
mov    $0xa,%edx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x148c(%rip),%rsi
mov    $0x1f40,%edx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14a0(%rip),%rsi
movsd  0xb1f(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14a6(%rip),%rsi
movsd  0xb0f(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14a7(%rip),%rsi
mov    $0x8,%edx
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14a9(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14bc(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14df(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x14ee(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1504(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1523(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1526(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x154a(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1570(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1580(%rip),%r14
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x158b(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1591(%rip),%rsi
movsd  0xa2b(%rip),%xmm0
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x15ab(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x15bf(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x15db(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1604(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1626(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1649(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
xor    %edi,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@.str = [6 x i8] c"usage\00"
@stderr = global i32 0
@.str.1 = [21 x i8] c"usage: %s [options]\0A\00"
@.str.2 = [44 x i8] c"Where at least one option is required, and\0A\00"
@.str.3 = [44 x i8] c"where options can be any of the following:\0A\00"
@.str.4 = [36 x i8] c"\09 -O for online processing [FALSE]\0A\00"
@.str.5 = [31 x i8] c"\09 -d for debug output [FALSE]\0A\00"
@.str.6 = [58 x i8] c"\09 -M adds a small constant to the power spectrum [FALSE]\0A\00"
@.str.7 = [55 x i8] c"\09\09equivalent to one bit of random noise on the input.\0A\00"
@.str.8 = [57 x i8] c"\09\09This helps to avoid the numerical problems that occur\0A\00"
@.str.9 = [54 x i8] c"\09\09when there are long stretches of zeros in the data\0A\00"
@.str.10 = [74 x i8] c"\09 -F highpass filter on waveform (in case of DC offset problems) [FALSE]\0A\00"
@.str.11 = [30 x i8] c"\09 -i input file name [stdin]\0A\00"
@.str.12 = [32 x i8] c"\09 -o output file name [stdout]\0A\00"
@.str.13 = [54 x i8] c"\09 -a for input file ascii rather than shorts [FALSE]\0A\00"
@.str.14 = [44 x i8] c"\09\09Note that default input is binary shorts\0A\00"
@.str.15 = [55 x i8] c"\09 -A for output file ascii rather than floats [FALSE]\0A\00"
@.str.16 = [45 x i8] c"\09\09Note that default output is binary floats\0A\00"
@.str.17 = [41 x i8] c"\09 -e for input files ESPS format[FALSE]\0A\00"
@.str.18 = [42 x i8] c"\09 -E for output files ESPS format[FALSE]\0A\00"
@.str.19 = [40 x i8] c"\09 -b for input files MAT format[FALSE]\0A\00"
@.str.20 = [41 x i8] c"\09 -B for output files MAT format[FALSE]\0A\00"
@.str.21 = [43 x i8] c"\09 -z for input files SPHERE format[FALSE]\0A\00"
@.str.22 = [28 x i8] c"\09 -k for Abbot I/O [FALSE]\0A\00"
@.str.23 = [53 x i8] c"\09\09Note that the default I/O format is binary shorts\0A\00"
@.str.24 = [39 x i8] c"\09 -T for little-endian input. [FALSE]\0A\00"
@.str.25 = [49 x i8] c"\09\09This option only applies to raw binary input.\0A\00"
@.str.26 = [40 x i8] c"\09 -U for little-endian output. [FALSE]\0A\00"
@.str.27 = [50 x i8] c"\09\09This option only applies to raw binary output.\0A\00"
@.str.28 = [32 x i8] c"\09 -y for padded input. [FALSE]\0A\00"
@.str.29 = [54 x i8] c"\09\09If there are M points per step and L input points,\0A\00"
@.str.30 = [58 x i8] c"\09\09produce L/M frames, where the ((n + 0.5) * M)-th point\0A\00"
@.str.31 = [34 x i8] c"\09\09is centered in the n-th frame.\0A\00"
@.str.32 = [64 x i8] c"\09\09There must be at least one window of data to produce output.\0A\00"
@.str.33 = [28 x i8] c"\09 -J for JAH rasta [FALSE]\0A\00"
@.str.34 = [52 x i8] c"\09 -C for constant JAH. This option should [FALSE]\0A\00"
@.str.35 = [49 x i8] c"\09\09generally be used during recognizer training.\0A\00"
@.str.36 = [51 x i8] c"\09\09Default is adapting JAH according to noisepower\0A\00"
@.str.37 = [38 x i8] c"\09\09Only use option -C when -J is used\0A\00"
@.str.38 = [57 x i8] c"\09 -f for JAH Rasta mapping coefficients input text file\0A\00"
@.str.39 = [28 x i8] c"\09 -L for log rasta [FALSE]\0A\00"
@.str.40 = [56 x i8] c"\09 -R for getting critical band values as output(ASCII)\0A\00"
@.str.41 = [44 x i8] c"\09\09instead of cepstral coefficients [FALSE]\0A\00"
@.str.42 = [57 x i8] c"\09\09Note: This is useful for users who would like to find\0A\00"
@.str.43 = [50 x i8] c"\09\09 their own spectral mapping coefficients.\0A\00"
@.str.44 = [39 x i8] c"\09\09Note: This overrules the -P option.\0A\00"
@.str.45 = [53 x i8] c"\09 -P for getting cube root compressed and equalized\0A\00"
@.str.46 = [55 x i8] c"\09\09 critical band values as output instead of cepstral\0A\00"
@.str.47 = [25 x i8] c"\09\09 coefficients [FALSE]\0A\00"
@.str.48 = [41 x i8] c"\09 -r for partially rasta, partially plp\0A\00"
@.str.49 = [69 x i8] c"\09 e.g. -r 1.0 => no mixing, -r 0.8 => 80%% rasta 20%% PLP [1.0]\0A\00"
@.str.50 = [50 x i8] c"\09 -w analysis window size (in milliseconds) [%d]\0A\00"
@.str.51 = [30 x i8] c"\09 -W windowing constant [%f]\0A\00"
@.str.52 = [46 x i8] c"\09 -s window step size (in milliseconds) [%d]\0A\00"
@.str.53 = [41 x i8] c"\09 -S Sampling frequency (in Hertz) [%d]\0A\00"
@.str.54 = [30 x i8] c"\09 -l liftering exponent [%f]\0A\00"
@.str.55 = [25 x i8] c"\09 -p pole position [%f]\0A\00"
@.str.56 = [23 x i8] c"\09 -m model order [%d]\0A\00"
@.str.57 = [35 x i8] c"\09 -n number of output parameters \0A\00"
@.str.58 = [51 x i8] c"\09\09where default is model order plus 1 (log gain) \0A\00"
@.str.59 = [31 x i8] c"\09\09and log gain is given first\0A\00"
@.str.60 = [38 x i8] c"\09 -c num of crit band filters order \0A\00"
@.str.61 = [47 x i8] c"\09\09where default depends on sampling freq, but \00"
@.str.62 = [19 x i8] c"is 17 for 8000 Hz\0A\00"
@.str.63 = [52 x i8] c"\09 -v (if you want triangular filters)[trapezoidal]\0A\00"
@.str.64 = [54 x i8] c"\09 -g (if you don't want gain computed)[compute gain]\0A\00"
@.str.65 = [32 x i8] c"\09 -N numerator rastafilt file \0A\00"
@.str.66 = [30 x i8] c"\09\09 (currently unimplemented)\0A\00"
@.str.67 = [34 x i8] c"\09 -D denominator rastafilt file \0A\00"
@.str.68 = [50 x i8] c"\09 -j Constant J [%e] depends on the noise level,\0A\00"
@.str.69 = [36 x i8] c"\09\09( smaller for more noisy speech)\0A\00"
@.str.70 = [44 x i8] c"\09\09Note: Only use option -j when -C is used\0A\00"
@.str.71 = [57 x i8] c"\09 -h use stored noise level estimation and RASTA filter\0A\00"
@.str.72 = [50 x i8] c"\09\09history for initialization (if history file is\0A\00"
@.str.73 = [51 x i8] c"\09\09available, otherwise use normal initialization)\0A\00"
@.str.74 = [38 x i8] c"\09 -H history filename [history.out]\0A\0A\00"
define void @usage(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
store i8* %0, i8** %2
store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i8** %3
%4 = load i32, i32* @stderr
%5 = load i8*, i8** %2
%6 = call i32 (i32, i8*, ...) @fprintf(i32 %4, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%7 = load i32, i32* @stderr
%8 = call i32 (i32, i8*, ...) @fprintf(i32 %7, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = call i32 (i32, i8*, ...) @fprintf(i32 %9, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.3, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = call i32 (i32, i8*, ...) @fprintf(i32 %11, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.4, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = call i32 (i32, i8*, ...) @fprintf(i32 %13, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = call i32 (i32, i8*, ...) @fprintf(i32 %15, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.6, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = call i32 (i32, i8*, ...) @fprintf(i32 %17, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.7, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = call i32 (i32, i8*, ...) @fprintf(i32 %19, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.8, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = call i32 (i32, i8*, ...) @fprintf(i32 %21, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.9, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = call i32 (i32, i8*, ...) @fprintf(i32 %23, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.10, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = call i32 (i32, i8*, ...) @fprintf(i32 %25, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.11, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = call i32 (i32, i8*, ...) @fprintf(i32 %27, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.12, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = call i32 (i32, i8*, ...) @fprintf(i32 %29, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.13, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = call i32 (i32, i8*, ...) @fprintf(i32 %31, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = call i32 (i32, i8*, ...) @fprintf(i32 %33, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.15, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = call i32 (i32, i8*, ...) @fprintf(i32 %35, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.16, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = call i32 (i32, i8*, ...) @fprintf(i32 %37, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.17, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = call i32 (i32, i8*, ...) @fprintf(i32 %39, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = call i32 (i32, i8*, ...) @fprintf(i32 %41, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.18, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = call i32 (i32, i8*, ...) @fprintf(i32 %43, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.16, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = call i32 (i32, i8*, ...) @fprintf(i32 %45, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.19, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = call i32 (i32, i8*, ...) @fprintf(i32 %47, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = call i32 (i32, i8*, ...) @fprintf(i32 %49, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.20, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = call i32 (i32, i8*, ...) @fprintf(i32 %51, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.16, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = call i32 (i32, i8*, ...) @fprintf(i32 %53, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.21, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = call i32 (i32, i8*, ...) @fprintf(i32 %55, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = call i32 (i32, i8*, ...) @fprintf(i32 %57, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.22, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = call i32 (i32, i8*, ...) @fprintf(i32 %59, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.23, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = call i32 (i32, i8*, ...) @fprintf(i32 %61, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.24, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = call i32 (i32, i8*, ...) @fprintf(i32 %63, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.25, i64 0, i64 0))
%65 = load i32, i32* @stderr
%66 = call i32 (i32, i8*, ...) @fprintf(i32 %65, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.26, i64 0, i64 0))
%67 = load i32, i32* @stderr
%68 = call i32 (i32, i8*, ...) @fprintf(i32 %67, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.27, i64 0, i64 0))
%69 = load i32, i32* @stderr
%70 = call i32 (i32, i8*, ...) @fprintf(i32 %69, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.28, i64 0, i64 0))
%71 = load i32, i32* @stderr
%72 = call i32 (i32, i8*, ...) @fprintf(i32 %71, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.29, i64 0, i64 0))
%73 = load i32, i32* @stderr
%74 = call i32 (i32, i8*, ...) @fprintf(i32 %73, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.30, i64 0, i64 0))
%75 = load i32, i32* @stderr
%76 = call i32 (i32, i8*, ...) @fprintf(i32 %75, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.31, i64 0, i64 0))
%77 = load i32, i32* @stderr
%78 = call i32 (i32, i8*, ...) @fprintf(i32 %77, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.32, i64 0, i64 0))
%79 = load i32, i32* @stderr
%80 = call i32 (i32, i8*, ...) @fprintf(i32 %79, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.33, i64 0, i64 0))
%81 = load i32, i32* @stderr
%82 = call i32 (i32, i8*, ...) @fprintf(i32 %81, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.34, i64 0, i64 0))
%83 = load i32, i32* @stderr
%84 = call i32 (i32, i8*, ...) @fprintf(i32 %83, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.35, i64 0, i64 0))
%85 = load i32, i32* @stderr
%86 = call i32 (i32, i8*, ...) @fprintf(i32 %85, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.36, i64 0, i64 0))
%87 = load i32, i32* @stderr
%88 = call i32 (i32, i8*, ...) @fprintf(i32 %87, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.37, i64 0, i64 0))
%89 = load i32, i32* @stderr
%90 = call i32 (i32, i8*, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.38, i64 0, i64 0))
%91 = load i32, i32* @stderr
%92 = call i32 (i32, i8*, ...) @fprintf(i32 %91, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.39, i64 0, i64 0))
%93 = load i32, i32* @stderr
%94 = call i32 (i32, i8*, ...) @fprintf(i32 %93, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.40, i64 0, i64 0))
%95 = load i32, i32* @stderr
%96 = call i32 (i32, i8*, ...) @fprintf(i32 %95, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.41, i64 0, i64 0))
%97 = load i32, i32* @stderr
%98 = call i32 (i32, i8*, ...) @fprintf(i32 %97, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.42, i64 0, i64 0))
%99 = load i32, i32* @stderr
%100 = call i32 (i32, i8*, ...) @fprintf(i32 %99, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.43, i64 0, i64 0))
%101 = load i32, i32* @stderr
%102 = call i32 (i32, i8*, ...) @fprintf(i32 %101, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.44, i64 0, i64 0))
%103 = load i32, i32* @stderr
%104 = call i32 (i32, i8*, ...) @fprintf(i32 %103, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.45, i64 0, i64 0))
%105 = load i32, i32* @stderr
%106 = call i32 (i32, i8*, ...) @fprintf(i32 %105, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.46, i64 0, i64 0))
%107 = load i32, i32* @stderr
%108 = call i32 (i32, i8*, ...) @fprintf(i32 %107, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.47, i64 0, i64 0))
%109 = load i32, i32* @stderr
%110 = call i32 (i32, i8*, ...) @fprintf(i32 %109, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.48, i64 0, i64 0))
%111 = load i32, i32* @stderr
%112 = call i32 (i32, i8*, ...) @fprintf(i32 %111, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.49, i64 0, i64 0))
%113 = load i32, i32* @stderr
%114 = call i32 (i32, i8*, ...) @fprintf(i32 %113, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.50, i64 0, i64 0), i32 20)
%115 = load i32, i32* @stderr
%116 = call i32 (i32, i8*, ...) @fprintf(i32 %115, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.51, i64 0, i64 0), double 5.400000e-01)
%117 = load i32, i32* @stderr
%118 = call i32 (i32, i8*, ...) @fprintf(i32 %117, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.52, i64 0, i64 0), i32 10)
%119 = load i32, i32* @stderr
%120 = call i32 (i32, i8*, ...) @fprintf(i32 %119, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.53, i64 0, i64 0), i32 8000)
%121 = load i32, i32* @stderr
%122 = call i32 (i32, i8*, ...) @fprintf(i32 %121, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.54, i64 0, i64 0), double 6.000000e-01)
%123 = load i32, i32* @stderr
%124 = call i32 (i32, i8*, ...) @fprintf(i32 %123, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.55, i64 0, i64 0), double 0x3FEE147AE147AE14)
%125 = load i32, i32* @stderr
%126 = call i32 (i32, i8*, ...) @fprintf(i32 %125, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.56, i64 0, i64 0), i32 8)
%127 = load i32, i32* @stderr
%128 = call i32 (i32, i8*, ...) @fprintf(i32 %127, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.57, i64 0, i64 0))
%129 = load i32, i32* @stderr
%130 = call i32 (i32, i8*, ...) @fprintf(i32 %129, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.58, i64 0, i64 0))
%131 = load i32, i32* @stderr
%132 = call i32 (i32, i8*, ...) @fprintf(i32 %131, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.59, i64 0, i64 0))
%133 = load i32, i32* @stderr
%134 = call i32 (i32, i8*, ...) @fprintf(i32 %133, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.60, i64 0, i64 0))
%135 = load i32, i32* @stderr
%136 = call i32 (i32, i8*, ...) @fprintf(i32 %135, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.61, i64 0, i64 0))
%137 = load i32, i32* @stderr
%138 = call i32 (i32, i8*, ...) @fprintf(i32 %137, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.62, i64 0, i64 0))
%139 = load i32, i32* @stderr
%140 = call i32 (i32, i8*, ...) @fprintf(i32 %139, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.63, i64 0, i64 0))
%141 = load i32, i32* @stderr
%142 = call i32 (i32, i8*, ...) @fprintf(i32 %141, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.64, i64 0, i64 0))
%143 = load i32, i32* @stderr
%144 = call i32 (i32, i8*, ...) @fprintf(i32 %143, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.65, i64 0, i64 0))
%145 = load i32, i32* @stderr
%146 = call i32 (i32, i8*, ...) @fprintf(i32 %145, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.66, i64 0, i64 0))
%147 = load i32, i32* @stderr
%148 = call i32 (i32, i8*, ...) @fprintf(i32 %147, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.67, i64 0, i64 0))
%149 = load i32, i32* @stderr
%150 = call i32 (i32, i8*, ...) @fprintf(i32 %149, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.66, i64 0, i64 0))
%151 = load i32, i32* @stderr
%152 = call i32 (i32, i8*, ...) @fprintf(i32 %151, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.68, i64 0, i64 0), double 0x3EB0C6F7A0B5ED8D)
%153 = load i32, i32* @stderr
%154 = call i32 (i32, i8*, ...) @fprintf(i32 %153, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.69, i64 0, i64 0))
%155 = load i32, i32* @stderr
%156 = call i32 (i32, i8*, ...) @fprintf(i32 %155, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.70, i64 0, i64 0))
%157 = load i32, i32* @stderr
%158 = call i32 (i32, i8*, ...) @fprintf(i32 %157, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.71, i64 0, i64 0))
%159 = load i32, i32* @stderr
%160 = call i32 (i32, i8*, ...) @fprintf(i32 %159, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.72, i64 0, i64 0))
%161 = load i32, i32* @stderr
%162 = call i32 (i32, i8*, ...) @fprintf(i32 %161, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.73, i64 0, i64 0))
%163 = load i32, i32* @stderr
%164 = call i32 (i32, i8*, ...) @fprintf(i32 %163, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.74, i64 0, i64 0))
%165 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
@stderr = global i32 0
@.str.1 = [21 x i8] c"usage: %s [options]\0A\00"
@.str.2 = [44 x i8] c"Where at least one option is required, and\0A\00"
@.str.3 = [44 x i8] c"where options can be any of the following:\0A\00"
@.str.4 = [36 x i8] c"\09 -O for online processing [FALSE]\0A\00"
@.str.5 = [31 x i8] c"\09 -d for debug output [FALSE]\0A\00"
@.str.6 = [58 x i8] c"\09 -M adds a small constant to the power spectrum [FALSE]\0A\00"
@.str.7 = [55 x i8] c"\09\09equivalent to one bit of random noise on the input.\0A\00"
@.str.8 = [57 x i8] c"\09\09This helps to avoid the numerical problems that occur\0A\00"
@.str.9 = [54 x i8] c"\09\09when there are long stretches of zeros in the data\0A\00"
@.str.10 = [74 x i8] c"\09 -F highpass filter on waveform (in case of DC offset problems) [FALSE]\0A\00"
@.str.11 = [30 x i8] c"\09 -i input file name [stdin]\0A\00"
@.str.12 = [32 x i8] c"\09 -o output file name [stdout]\0A\00"
@.str.13 = [54 x i8] c"\09 -a for input file ascii rather than shorts [FALSE]\0A\00"
@.str.14 = [44 x i8] c"\09\09Note that default input is binary shorts\0A\00"
@.str.15 = [55 x i8] c"\09 -A for output file ascii rather than floats [FALSE]\0A\00"
@.str.16 = [45 x i8] c"\09\09Note that default output is binary floats\0A\00"
@.str.17 = [41 x i8] c"\09 -e for input files ESPS format[FALSE]\0A\00"
@.str.18 = [42 x i8] c"\09 -E for output files ESPS format[FALSE]\0A\00"
@.str.19 = [40 x i8] c"\09 -b for input files MAT format[FALSE]\0A\00"
@.str.20 = [41 x i8] c"\09 -B for output files MAT format[FALSE]\0A\00"
@.str.21 = [43 x i8] c"\09 -z for input files SPHERE format[FALSE]\0A\00"
@.str.22 = [28 x i8] c"\09 -k for Abbot I/O [FALSE]\0A\00"
@.str.23 = [53 x i8] c"\09\09Note that the default I/O format is binary shorts\0A\00"
@.str.24 = [39 x i8] c"\09 -T for little-endian input. [FALSE]\0A\00"
@.str.25 = [49 x i8] c"\09\09This option only applies to raw binary input.\0A\00"
@.str.26 = [40 x i8] c"\09 -U for little-endian output. [FALSE]\0A\00"
@.str.27 = [50 x i8] c"\09\09This option only applies to raw binary output.\0A\00"
@.str.28 = [32 x i8] c"\09 -y for padded input. [FALSE]\0A\00"
@.str.29 = [54 x i8] c"\09\09If there are M points per step and L input points,\0A\00"
@.str.30 = [58 x i8] c"\09\09produce L/M frames, where the ((n + 0.5) * M)-th point\0A\00"
@.str.31 = [34 x i8] c"\09\09is centered in the n-th frame.\0A\00"
@.str.32 = [64 x i8] c"\09\09There must be at least one window of data to produce output.\0A\00"
@.str.33 = [28 x i8] c"\09 -J for JAH rasta [FALSE]\0A\00"
@.str.34 = [52 x i8] c"\09 -C for constant JAH. This option should [FALSE]\0A\00"
@.str.35 = [49 x i8] c"\09\09generally be used during recognizer training.\0A\00"
@.str.36 = [51 x i8] c"\09\09Default is adapting JAH according to noisepower\0A\00"
@.str.37 = [38 x i8] c"\09\09Only use option -C when -J is used\0A\00"
@.str.38 = [57 x i8] c"\09 -f for JAH Rasta mapping coefficients input text file\0A\00"
@.str.39 = [28 x i8] c"\09 -L for log rasta [FALSE]\0A\00"
@.str.40 = [56 x i8] c"\09 -R for getting critical band values as output(ASCII)\0A\00"
@.str.41 = [44 x i8] c"\09\09instead of cepstral coefficients [FALSE]\0A\00"
@.str.42 = [57 x i8] c"\09\09Note: This is useful for users who would like to find\0A\00"
@.str.43 = [50 x i8] c"\09\09 their own spectral mapping coefficients.\0A\00"
@.str.44 = [39 x i8] c"\09\09Note: This overrules the -P option.\0A\00"
@.str.45 = [53 x i8] c"\09 -P for getting cube root compressed and equalized\0A\00"
@.str.46 = [55 x i8] c"\09\09 critical band values as output instead of cepstral\0A\00"
@.str.47 = [25 x i8] c"\09\09 coefficients [FALSE]\0A\00"
@.str.48 = [41 x i8] c"\09 -r for partially rasta, partially plp\0A\00"
@.str.49 = [69 x i8] c"\09 e.g. -r 1.0 => no mixing, -r 0.8 => 80%% rasta 20%% PLP [1.0]\0A\00"
@.str.50 = [50 x i8] c"\09 -w analysis window size (in milliseconds) [%d]\0A\00"
@.str.51 = [30 x i8] c"\09 -W windowing constant [%f]\0A\00"
@.str.52 = [46 x i8] c"\09 -s window step size (in milliseconds) [%d]\0A\00"
@.str.53 = [41 x i8] c"\09 -S Sampling frequency (in Hertz) [%d]\0A\00"
@.str.54 = [30 x i8] c"\09 -l liftering exponent [%f]\0A\00"
@.str.55 = [25 x i8] c"\09 -p pole position [%f]\0A\00"
@.str.56 = [23 x i8] c"\09 -m model order [%d]\0A\00"
@.str.57 = [35 x i8] c"\09 -n number of output parameters \0A\00"
@.str.58 = [51 x i8] c"\09\09where default is model order plus 1 (log gain) \0A\00"
@.str.59 = [31 x i8] c"\09\09and log gain is given first\0A\00"
@.str.60 = [38 x i8] c"\09 -c num of crit band filters order \0A\00"
@.str.61 = [47 x i8] c"\09\09where default depends on sampling freq, but \00"
@.str.62 = [19 x i8] c"is 17 for 8000 Hz\0A\00"
@.str.63 = [52 x i8] c"\09 -v (if you want triangular filters)[trapezoidal]\0A\00"
@.str.64 = [54 x i8] c"\09 -g (if you don't want gain computed)[compute gain]\0A\00"
@.str.65 = [32 x i8] c"\09 -N numerator rastafilt file \0A\00"
@.str.66 = [30 x i8] c"\09\09 (currently unimplemented)\0A\00"
@.str.67 = [34 x i8] c"\09 -D denominator rastafilt file \0A\00"
@.str.68 = [50 x i8] c"\09 -j Constant J [%e] depends on the noise level,\0A\00"
@.str.69 = [36 x i8] c"\09\09( smaller for more noisy speech)\0A\00"
@.str.70 = [44 x i8] c"\09\09Note: Only use option -j when -C is used\0A\00"
@.str.71 = [57 x i8] c"\09 -h use stored noise level estimation and RASTA filter\0A\00"
@.str.72 = [50 x i8] c"\09\09history for initialization (if history file is\0A\00"
@.str.73 = [51 x i8] c"\09\09available, otherwise use normal initialization)\0A\00"
@.str.74 = [38 x i8] c"\09 -H history filename [history.out]\0A\0A\00"
define void @usage(i8* %0) {
%2 = load i32, i32* @stderr
%3 = tail call i32 (i32, i8*, ...) @fprintf(i32 %2, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i8* %0)
%4 = load i32, i32* @stderr
%5 = tail call i32 (i32, i8*, ...) @fprintf(i32 %4, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.2, i64 0, i64 0))
%6 = load i32, i32* @stderr
%7 = tail call i32 (i32, i8*, ...) @fprintf(i32 %6, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.3, i64 0, i64 0))
%8 = load i32, i32* @stderr
%9 = tail call i32 (i32, i8*, ...) @fprintf(i32 %8, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.4, i64 0, i64 0))
%10 = load i32, i32* @stderr
%11 = tail call i32 (i32, i8*, ...) @fprintf(i32 %10, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.5, i64 0, i64 0))
%12 = load i32, i32* @stderr
%13 = tail call i32 (i32, i8*, ...) @fprintf(i32 %12, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.6, i64 0, i64 0))
%14 = load i32, i32* @stderr
%15 = tail call i32 (i32, i8*, ...) @fprintf(i32 %14, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.7, i64 0, i64 0))
%16 = load i32, i32* @stderr
%17 = tail call i32 (i32, i8*, ...) @fprintf(i32 %16, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.8, i64 0, i64 0))
%18 = load i32, i32* @stderr
%19 = tail call i32 (i32, i8*, ...) @fprintf(i32 %18, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.9, i64 0, i64 0))
%20 = load i32, i32* @stderr
%21 = tail call i32 (i32, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.10, i64 0, i64 0))
%22 = load i32, i32* @stderr
%23 = tail call i32 (i32, i8*, ...) @fprintf(i32 %22, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.11, i64 0, i64 0))
%24 = load i32, i32* @stderr
%25 = tail call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.12, i64 0, i64 0))
%26 = load i32, i32* @stderr
%27 = tail call i32 (i32, i8*, ...) @fprintf(i32 %26, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.13, i64 0, i64 0))
%28 = load i32, i32* @stderr
%29 = tail call i32 (i32, i8*, ...) @fprintf(i32 %28, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%30 = load i32, i32* @stderr
%31 = tail call i32 (i32, i8*, ...) @fprintf(i32 %30, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.15, i64 0, i64 0))
%32 = load i32, i32* @stderr
%33 = tail call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.16, i64 0, i64 0))
%34 = load i32, i32* @stderr
%35 = tail call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.17, i64 0, i64 0))
%36 = load i32, i32* @stderr
%37 = tail call i32 (i32, i8*, ...) @fprintf(i32 %36, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%38 = load i32, i32* @stderr
%39 = tail call i32 (i32, i8*, ...) @fprintf(i32 %38, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.18, i64 0, i64 0))
%40 = load i32, i32* @stderr
%41 = tail call i32 (i32, i8*, ...) @fprintf(i32 %40, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.16, i64 0, i64 0))
%42 = load i32, i32* @stderr
%43 = tail call i32 (i32, i8*, ...) @fprintf(i32 %42, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.19, i64 0, i64 0))
%44 = load i32, i32* @stderr
%45 = tail call i32 (i32, i8*, ...) @fprintf(i32 %44, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%46 = load i32, i32* @stderr
%47 = tail call i32 (i32, i8*, ...) @fprintf(i32 %46, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.20, i64 0, i64 0))
%48 = load i32, i32* @stderr
%49 = tail call i32 (i32, i8*, ...) @fprintf(i32 %48, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.16, i64 0, i64 0))
%50 = load i32, i32* @stderr
%51 = tail call i32 (i32, i8*, ...) @fprintf(i32 %50, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.21, i64 0, i64 0))
%52 = load i32, i32* @stderr
%53 = tail call i32 (i32, i8*, ...) @fprintf(i32 %52, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.14, i64 0, i64 0))
%54 = load i32, i32* @stderr
%55 = tail call i32 (i32, i8*, ...) @fprintf(i32 %54, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.22, i64 0, i64 0))
%56 = load i32, i32* @stderr
%57 = tail call i32 (i32, i8*, ...) @fprintf(i32 %56, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.23, i64 0, i64 0))
%58 = load i32, i32* @stderr
%59 = tail call i32 (i32, i8*, ...) @fprintf(i32 %58, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.24, i64 0, i64 0))
%60 = load i32, i32* @stderr
%61 = tail call i32 (i32, i8*, ...) @fprintf(i32 %60, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.25, i64 0, i64 0))
%62 = load i32, i32* @stderr
%63 = tail call i32 (i32, i8*, ...) @fprintf(i32 %62, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.26, i64 0, i64 0))
%64 = load i32, i32* @stderr
%65 = tail call i32 (i32, i8*, ...) @fprintf(i32 %64, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.27, i64 0, i64 0))
%66 = load i32, i32* @stderr
%67 = tail call i32 (i32, i8*, ...) @fprintf(i32 %66, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.28, i64 0, i64 0))
%68 = load i32, i32* @stderr
%69 = tail call i32 (i32, i8*, ...) @fprintf(i32 %68, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.29, i64 0, i64 0))
%70 = load i32, i32* @stderr
%71 = tail call i32 (i32, i8*, ...) @fprintf(i32 %70, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.30, i64 0, i64 0))
%72 = load i32, i32* @stderr
%73 = tail call i32 (i32, i8*, ...) @fprintf(i32 %72, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.31, i64 0, i64 0))
%74 = load i32, i32* @stderr
%75 = tail call i32 (i32, i8*, ...) @fprintf(i32 %74, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.32, i64 0, i64 0))
%76 = load i32, i32* @stderr
%77 = tail call i32 (i32, i8*, ...) @fprintf(i32 %76, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.33, i64 0, i64 0))
%78 = load i32, i32* @stderr
%79 = tail call i32 (i32, i8*, ...) @fprintf(i32 %78, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.34, i64 0, i64 0))
%80 = load i32, i32* @stderr
%81 = tail call i32 (i32, i8*, ...) @fprintf(i32 %80, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.35, i64 0, i64 0))
%82 = load i32, i32* @stderr
%83 = tail call i32 (i32, i8*, ...) @fprintf(i32 %82, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.36, i64 0, i64 0))
%84 = load i32, i32* @stderr
%85 = tail call i32 (i32, i8*, ...) @fprintf(i32 %84, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.37, i64 0, i64 0))
%86 = load i32, i32* @stderr
%87 = tail call i32 (i32, i8*, ...) @fprintf(i32 %86, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.38, i64 0, i64 0))
%88 = load i32, i32* @stderr
%89 = tail call i32 (i32, i8*, ...) @fprintf(i32 %88, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.39, i64 0, i64 0))
%90 = load i32, i32* @stderr
%91 = tail call i32 (i32, i8*, ...) @fprintf(i32 %90, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.40, i64 0, i64 0))
%92 = load i32, i32* @stderr
%93 = tail call i32 (i32, i8*, ...) @fprintf(i32 %92, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.41, i64 0, i64 0))
%94 = load i32, i32* @stderr
%95 = tail call i32 (i32, i8*, ...) @fprintf(i32 %94, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.42, i64 0, i64 0))
%96 = load i32, i32* @stderr
%97 = tail call i32 (i32, i8*, ...) @fprintf(i32 %96, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.43, i64 0, i64 0))
%98 = load i32, i32* @stderr
%99 = tail call i32 (i32, i8*, ...) @fprintf(i32 %98, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.44, i64 0, i64 0))
%100 = load i32, i32* @stderr
%101 = tail call i32 (i32, i8*, ...) @fprintf(i32 %100, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.45, i64 0, i64 0))
%102 = load i32, i32* @stderr
%103 = tail call i32 (i32, i8*, ...) @fprintf(i32 %102, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.46, i64 0, i64 0))
%104 = load i32, i32* @stderr
%105 = tail call i32 (i32, i8*, ...) @fprintf(i32 %104, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.47, i64 0, i64 0))
%106 = load i32, i32* @stderr
%107 = tail call i32 (i32, i8*, ...) @fprintf(i32 %106, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.48, i64 0, i64 0))
%108 = load i32, i32* @stderr
%109 = tail call i32 (i32, i8*, ...) @fprintf(i32 %108, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.49, i64 0, i64 0))
%110 = load i32, i32* @stderr
%111 = tail call i32 (i32, i8*, ...) @fprintf(i32 %110, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.50, i64 0, i64 0), i32 20)
%112 = load i32, i32* @stderr
%113 = tail call i32 (i32, i8*, ...) @fprintf(i32 %112, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.51, i64 0, i64 0), double 5.400000e-01)
%114 = load i32, i32* @stderr
%115 = tail call i32 (i32, i8*, ...) @fprintf(i32 %114, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.52, i64 0, i64 0), i32 10)
%116 = load i32, i32* @stderr
%117 = tail call i32 (i32, i8*, ...) @fprintf(i32 %116, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.53, i64 0, i64 0), i32 8000)
%118 = load i32, i32* @stderr
%119 = tail call i32 (i32, i8*, ...) @fprintf(i32 %118, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.54, i64 0, i64 0), double 6.000000e-01)
%120 = load i32, i32* @stderr
%121 = tail call i32 (i32, i8*, ...) @fprintf(i32 %120, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.55, i64 0, i64 0), double 0x3FEE147AE147AE14)
%122 = load i32, i32* @stderr
%123 = tail call i32 (i32, i8*, ...) @fprintf(i32 %122, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.56, i64 0, i64 0), i32 8)
%124 = load i32, i32* @stderr
%125 = tail call i32 (i32, i8*, ...) @fprintf(i32 %124, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.57, i64 0, i64 0))
%126 = load i32, i32* @stderr
%127 = tail call i32 (i32, i8*, ...) @fprintf(i32 %126, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.58, i64 0, i64 0))
%128 = load i32, i32* @stderr
%129 = tail call i32 (i32, i8*, ...) @fprintf(i32 %128, i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.59, i64 0, i64 0))
%130 = load i32, i32* @stderr
%131 = tail call i32 (i32, i8*, ...) @fprintf(i32 %130, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.60, i64 0, i64 0))
%132 = load i32, i32* @stderr
%133 = tail call i32 (i32, i8*, ...) @fprintf(i32 %132, i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.61, i64 0, i64 0))
%134 = load i32, i32* @stderr
%135 = tail call i32 (i32, i8*, ...) @fprintf(i32 %134, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.62, i64 0, i64 0))
%136 = load i32, i32* @stderr
%137 = tail call i32 (i32, i8*, ...) @fprintf(i32 %136, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.63, i64 0, i64 0))
%138 = load i32, i32* @stderr
%139 = tail call i32 (i32, i8*, ...) @fprintf(i32 %138, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.64, i64 0, i64 0))
%140 = load i32, i32* @stderr
%141 = tail call i32 (i32, i8*, ...) @fprintf(i32 %140, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.65, i64 0, i64 0))
%142 = load i32, i32* @stderr
%143 = tail call i32 (i32, i8*, ...) @fprintf(i32 %142, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.66, i64 0, i64 0))
%144 = load i32, i32* @stderr
%145 = tail call i32 (i32, i8*, ...) @fprintf(i32 %144, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.67, i64 0, i64 0))
%146 = load i32, i32* @stderr
%147 = tail call i32 (i32, i8*, ...) @fprintf(i32 %146, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.66, i64 0, i64 0))
%148 = load i32, i32* @stderr
%149 = tail call i32 (i32, i8*, ...) @fprintf(i32 %148, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.68, i64 0, i64 0), double 0x3EB0C6F7A0B5ED8D)
%150 = load i32, i32* @stderr
%151 = tail call i32 (i32, i8*, ...) @fprintf(i32 %150, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.69, i64 0, i64 0))
%152 = load i32, i32* @stderr
%153 = tail call i32 (i32, i8*, ...) @fprintf(i32 %152, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.70, i64 0, i64 0))
%154 = load i32, i32* @stderr
%155 = tail call i32 (i32, i8*, ...) @fprintf(i32 %154, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.71, i64 0, i64 0))
%156 = load i32, i32* @stderr
%157 = tail call i32 (i32, i8*, ...) @fprintf(i32 %156, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.72, i64 0, i64 0))
%158 = load i32, i32* @stderr
%159 = tail call i32 (i32, i8*, ...) @fprintf(i32 %158, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.73, i64 0, i64 0))
%160 = load i32, i32* @stderr
%161 = tail call i32 (i32, i8*, ...) @fprintf(i32 %160, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.74, i64 0, i64 0))
%162 = tail call i32 @exit(i32 0)
unreachable
}