#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*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stderr;
void explain_command(char **argv) {
  fprintf(stderr, "Usage: %s [options] <case seq file> <control seq file>\n",
          argv[0]);
  fprintf(stderr, "<case seq file>: a one column file only containing the "
                  "positions of case reads.\n");
  fprintf(stderr, "<control seq file>: a one column file only containing the "
                  "positions of control reads.\n");
  fprintf(stderr, "Options:\n");
  fprintf(stderr, "        -h: print this message.\n");
  fprintf(stderr,
          "        -l: the the penalty parameter lambda; default is 2.\n");
  fprintf(stderr, "        -b <int>: the bin size; default is 100\n");
  fprintf(stderr, "        -q <float>: the quantile used for identification of "
                  "the singular genomic positions; default is 0.95\n");
  fprintf(stderr, "        -w <int>: the window size for calculating the "
                  "quantiles; default is 200\n");
  fprintf(stderr, "        -o <string>: the segmentated output; if "
                  "unspecified, print to the stdout.\n");
  fprintf(stderr, "        -R <string>: Report the outlier position, count and "
                  "the quantile in its local window to a file.\n");
  fprintf(stderr, "        -f <float>: expected number of type I errors in "
                  "merging process\n");
  fprintf(stderr, "        -2: the data is paried-end data\n");
  fprintf(stderr, "        -p <folat>: the overall frequency of tumor reads; "
                  "if specified use resampling procedure for FDR esimate\n");
  fprintf(stderr, "        -B <int>: how many resampling should be performed; "
                  "Default is 0.\n");
  fprintf(stderr,
          "        -I <InsertSize,SDofInsertSize>: if the data is paried-end, "
          "specify its mean insert size and standard deviation; Useful for "
          "resampling procedure; Default <200,20>\n");
  fprintf(stderr, "        --multiplicity <float>: If a genomic position has "
                  "more than multiplicity*quantile number of reads,\n");
  fprintf(stderr, "                        it will be viewed as an outlier\n");
  fprintf(stderr, "                        and the number of reads at this "
                  "position will be set as multiplicity*quantile;\n");
  fprintf(stderr, "                        default is 2.0\n");
  fprintf(stderr, "       --binOut <string>: if specifed, print the binned "
                  "data to this file\n");
  fprintf(stderr, "       --inb <string>: the input is binned data; if this is "
                  "specifed, <case seq file> and <control seq file> will be "
                  "ignored (if also provided)\n");
  fprintf(stderr, "       --perm: if specified,use permutation method for FDR "
                  "estimate(default: use resampling method); Only valid if "
                  "case/control reads are provided\n");
  return;
}


x86 assembly (clang, -O0):
<explain_command>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    0x2ebd(%rip),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rax
mov    (%rax),%rdx
lea    0xecd(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e9f(%rip),%rax
mov    (%rax),%edi
lea    0xeee(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e88(%rip),%rax
mov    (%rax),%edi
lea    0xf28(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e71(%rip),%rax
mov    (%rax),%edi
lea    0xf68(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e5a(%rip),%rax
mov    (%rax),%edi
lea    0xf5b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e43(%rip),%rax
mov    (%rax),%edi
lea    0xf65(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e2c(%rip),%rax
mov    (%rax),%edi
lea    0xf8b(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e15(%rip),%rax
mov    (%rax),%edi
lea    0xfa4(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2dfe(%rip),%rax
mov    (%rax),%edi
lea    0xffa(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2de7(%rip),%rax
mov    (%rax),%edi
lea    0x1034(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2dd0(%rip),%rax
mov    (%rax),%edi
lea    0x1070(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2db9(%rip),%rax
mov    (%rax),%edi
lea    0x10c2(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2da2(%rip),%rax
mov    (%rax),%edi
lea    0x10f4(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d8b(%rip),%rax
mov    (%rax),%edi
lea    0x1106(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d74(%rip),%rax
mov    (%rax),%edi
lea    0x1160(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d5d(%rip),%rax
mov    (%rax),%edi
lea    0x1193(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d46(%rip),%rax
mov    (%rax),%edi
lea    0x1227(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d2f(%rip),%rax
mov    (%rax),%edi
lea    0x127c(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d18(%rip),%rax
mov    (%rax),%edi
lea    0x129e(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d01(%rip),%rax
mov    (%rax),%edi
lea    0x12ef(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cea(%rip),%rax
mov    (%rax),%edi
lea    0x1300(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cd3(%rip),%rax
mov    (%rax),%edi
lea    0x1334(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cbc(%rip),%rax
mov    (%rax),%edi
lea    0x13ae(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<explain_command>:
push   %rbx
mov    0x2ec8(%rip),%rbx
mov    (%rbx),%eax
mov    (%rdi),%rdx
lea    0xedc(%rip),%rsi
mov    %eax,%edi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf02(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf43(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf8a(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf84(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf95(%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    0xfe2(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x103f(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1080(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10c3(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x111c(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1155(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x116e(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11cf(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1209(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12a4(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1300(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1329(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1381(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1399(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13d4(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1455(%rip),%rsi
xor    %eax,%eax
pop    %rbx
jmp    1030 <fprintf@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [56 x i8] c"Usage: %s [options] <case seq file> <control seq file>\0A\00"
@.str.1 = [81 x i8] c"<case seq file>: a one column file only containing the positions of case reads.\0A\00"
@.str.2 = [87 x i8] c"<control seq file>: a one column file only containing the positions of control reads.\0A\00"
@.str.3 = [10 x i8] c"Options:\0A\00"
@.str.4 = [33 x i8] c" -h: print this message.\0A\00"
@.str.5 = [61 x i8] c" -l: the the penalty parameter lambda; default is 2.\0A\00"
@.str.6 = [48 x i8] c" -b <int>: the bin size; default is 100\0A\00"
@.str.7 = [109 x i8] c" -q <float>: the quantile used for identification of the singular genomic positions; default is 0.95\0A\00"
@.str.8 = [81 x i8] c" -w <int>: the window size for calculating the quantiles; default is 200\0A\00"
@.str.9 = [83 x i8] c" -o <string>: the segmentated output; if unspecified, print to the stdout.\0A\00"
@.str.10 = [105 x i8] c" -R <string>: Report the outlier position, count and the quantile in its local window to a file.\0A\00"
@.str.11 = [73 x i8] c" -f <float>: expected number of type I errors in merging process\0A\00"
@.str.12 = [41 x i8] c" -2: the data is paried-end data\0A\00"
@.str.13 = [113 x i8] c" -p <folat>: the overall frequency of tumor reads; if specified use resampling procedure for FDR esimate\0A\00"
@.str.14 = [74 x i8] c" -B <int>: how many resampling should be performed; Default is 0.\0A\00"
@.str.15 = [171 x i8] c" -I <InsertSize,SDofInsertSize>: if the data is paried-end, specify its mean insert size and standard deviation; Useful for resampling procedure; Default <200,20>\0A\00"
@.str.16 = [108 x i8] c" --multiplicity <float>: If a genomic position has more than multiplicity*quantile number of reads,\0A\00"
@.str.17 = [57 x i8] c" it will be viewed as an outlier\0A\00"
@.str.18 = [104 x i8] c" and the number of reads at this position will be set as multiplicity*quantile;\0A\00"
@.str.19 = [40 x i8] c" default is 2.0\0A\00"
@.str.20 = [75 x i8] c" --binOut <string>: if specifed, print the binned data to this file\0A\00"
@.str.21 = [145 x i8] c" --inb <string>: the input is binned data; if this is specifed, <case seq file> and <control seq file> will be ignored (if also provided)\0A\00"
@.str.22 = [148 x i8] c" --perm: if specified,use permutation method for FDR estimate(default: use resampling method); Only valid if case/control reads are provided\0A\00"
define void @explain_command(i8** %0) {
%2 = alloca i8**
store i8** %0, i8*** %2
%3 = load i32, i32* @stderr
%4 = load i8**, i8*** %2
%5 = getelementptr inbounds i8*, i8** %4, i64 0
%6 = load i8*, i8** %5
%7 = call i32 (i32, i8*, ...) @fprintf(i32 %3, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i8* %6)
%8 = load i32, i32* @stderr
%9 = call i32 (i32, i8*, ...) @fprintf(i32 %8, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.1, i64 0, i64 0))
%10 = load i32, i32* @stderr
%11 = call i32 (i32, i8*, ...) @fprintf(i32 %10, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.2, i64 0, i64 0))
%12 = load i32, i32* @stderr
%13 = call i32 (i32, i8*, ...) @fprintf(i32 %12, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%14 = load i32, i32* @stderr
%15 = call i32 (i32, i8*, ...) @fprintf(i32 %14, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0))
%16 = load i32, i32* @stderr
%17 = call i32 (i32, i8*, ...) @fprintf(i32 %16, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.5, i64 0, i64 0))
%18 = load i32, i32* @stderr
%19 = call i32 (i32, i8*, ...) @fprintf(i32 %18, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.6, i64 0, i64 0))
%20 = load i32, i32* @stderr
%21 = call i32 (i32, i8*, ...) @fprintf(i32 %20, i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.7, i64 0, i64 0))
%22 = load i32, i32* @stderr
%23 = call i32 (i32, i8*, ...) @fprintf(i32 %22, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.8, i64 0, i64 0))
%24 = load i32, i32* @stderr
%25 = call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.9, i64 0, i64 0))
%26 = load i32, i32* @stderr
%27 = call i32 (i32, i8*, ...) @fprintf(i32 %26, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.10, i64 0, i64 0))
%28 = load i32, i32* @stderr
%29 = call i32 (i32, i8*, ...) @fprintf(i32 %28, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.11, i64 0, i64 0))
%30 = load i32, i32* @stderr
%31 = call i32 (i32, i8*, ...) @fprintf(i32 %30, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.12, i64 0, i64 0))
%32 = load i32, i32* @stderr
%33 = call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.13, i64 0, i64 0))
%34 = load i32, i32* @stderr
%35 = call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.14, i64 0, i64 0))
%36 = load i32, i32* @stderr
%37 = call i32 (i32, i8*, ...) @fprintf(i32 %36, i8* getelementptr inbounds ([171 x i8], [171 x i8]* @.str.15, i64 0, i64 0))
%38 = load i32, i32* @stderr
%39 = call i32 (i32, i8*, ...) @fprintf(i32 %38, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.16, i64 0, i64 0))
%40 = load i32, i32* @stderr
%41 = call i32 (i32, i8*, ...) @fprintf(i32 %40, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.17, i64 0, i64 0))
%42 = load i32, i32* @stderr
%43 = call i32 (i32, i8*, ...) @fprintf(i32 %42, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.18, i64 0, i64 0))
%44 = load i32, i32* @stderr
%45 = call i32 (i32, i8*, ...) @fprintf(i32 %44, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.19, i64 0, i64 0))
%46 = load i32, i32* @stderr
%47 = call i32 (i32, i8*, ...) @fprintf(i32 %46, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.20, i64 0, i64 0))
%48 = load i32, i32* @stderr
%49 = call i32 (i32, i8*, ...) @fprintf(i32 %48, i8* getelementptr inbounds ([145 x i8], [145 x i8]* @.str.21, i64 0, i64 0))
%50 = load i32, i32* @stderr
%51 = call i32 (i32, i8*, ...) @fprintf(i32 %50, i8* getelementptr inbounds ([148 x i8], [148 x i8]* @.str.22, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [56 x i8] c"Usage: %s [options] <case seq file> <control seq file>\0A\00"
@.str.1 = [81 x i8] c"<case seq file>: a one column file only containing the positions of case reads.\0A\00"
@.str.2 = [87 x i8] c"<control seq file>: a one column file only containing the positions of control reads.\0A\00"
@.str.3 = [10 x i8] c"Options:\0A\00"
@.str.4 = [33 x i8] c" -h: print this message.\0A\00"
@.str.5 = [61 x i8] c" -l: the the penalty parameter lambda; default is 2.\0A\00"
@.str.6 = [48 x i8] c" -b <int>: the bin size; default is 100\0A\00"
@.str.7 = [109 x i8] c" -q <float>: the quantile used for identification of the singular genomic positions; default is 0.95\0A\00"
@.str.8 = [81 x i8] c" -w <int>: the window size for calculating the quantiles; default is 200\0A\00"
@.str.9 = [83 x i8] c" -o <string>: the segmentated output; if unspecified, print to the stdout.\0A\00"
@.str.10 = [105 x i8] c" -R <string>: Report the outlier position, count and the quantile in its local window to a file.\0A\00"
@.str.11 = [73 x i8] c" -f <float>: expected number of type I errors in merging process\0A\00"
@.str.12 = [41 x i8] c" -2: the data is paried-end data\0A\00"
@.str.13 = [113 x i8] c" -p <folat>: the overall frequency of tumor reads; if specified use resampling procedure for FDR esimate\0A\00"
@.str.14 = [74 x i8] c" -B <int>: how many resampling should be performed; Default is 0.\0A\00"
@.str.15 = [171 x i8] c" -I <InsertSize,SDofInsertSize>: if the data is paried-end, specify its mean insert size and standard deviation; Useful for resampling procedure; Default <200,20>\0A\00"
@.str.16 = [108 x i8] c" --multiplicity <float>: If a genomic position has more than multiplicity*quantile number of reads,\0A\00"
@.str.17 = [57 x i8] c" it will be viewed as an outlier\0A\00"
@.str.18 = [104 x i8] c" and the number of reads at this position will be set as multiplicity*quantile;\0A\00"
@.str.19 = [40 x i8] c" default is 2.0\0A\00"
@.str.20 = [75 x i8] c" --binOut <string>: if specifed, print the binned data to this file\0A\00"
@.str.21 = [145 x i8] c" --inb <string>: the input is binned data; if this is specifed, <case seq file> and <control seq file> will be ignored (if also provided)\0A\00"
@.str.22 = [148 x i8] c" --perm: if specified,use permutation method for FDR estimate(default: use resampling method); Only valid if case/control reads are provided\0A\00"
define void @explain_command(i8** nocapture %0) {
%2 = load i32, i32* @stderr
%3 = load i8*, i8** %0
%4 = tail call i32 (i32, i8*, ...) @fprintf(i32 %2, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0), i8* %3)
%5 = load i32, i32* @stderr
%6 = tail call i32 (i32, i8*, ...) @fprintf(i32 %5, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.1, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = tail call i32 (i32, i8*, ...) @fprintf(i32 %7, i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.2, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = tail call i32 (i32, i8*, ...) @fprintf(i32 %9, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = tail call i32 (i32, i8*, ...) @fprintf(i32 %11, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = tail call i32 (i32, i8*, ...) @fprintf(i32 %13, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.5, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = tail call i32 (i32, i8*, ...) @fprintf(i32 %15, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.6, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = tail call i32 (i32, i8*, ...) @fprintf(i32 %17, i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.7, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = tail call i32 (i32, i8*, ...) @fprintf(i32 %19, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.8, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = tail call i32 (i32, i8*, ...) @fprintf(i32 %21, i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.9, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = tail call i32 (i32, i8*, ...) @fprintf(i32 %23, i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.10, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = tail call i32 (i32, i8*, ...) @fprintf(i32 %25, i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.11, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = tail call i32 (i32, i8*, ...) @fprintf(i32 %27, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.12, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = tail call i32 (i32, i8*, ...) @fprintf(i32 %29, i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.13, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = tail call i32 (i32, i8*, ...) @fprintf(i32 %31, i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.14, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = tail call i32 (i32, i8*, ...) @fprintf(i32 %33, i8* getelementptr inbounds ([171 x i8], [171 x i8]* @.str.15, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = tail call i32 (i32, i8*, ...) @fprintf(i32 %35, i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.16, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = tail call i32 (i32, i8*, ...) @fprintf(i32 %37, i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.17, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = tail call i32 (i32, i8*, ...) @fprintf(i32 %39, i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.18, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = tail call i32 (i32, i8*, ...) @fprintf(i32 %41, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.19, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = tail call i32 (i32, i8*, ...) @fprintf(i32 %43, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.20, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = tail call i32 (i32, i8*, ...) @fprintf(i32 %45, i8* getelementptr inbounds ([145 x i8], [145 x i8]* @.str.21, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = tail call i32 (i32, i8*, ...) @fprintf(i32 %47, i8* getelementptr inbounds ([148 x i8], [148 x i8]* @.str.22, i64 0, i64 0))
ret void
}