#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;
int best_usage() {
  fprintf(stderr, "\n");
  fprintf(stderr, "Usage  : treebest best [options] <CDS_alignment>\n\n");
  fprintf(stderr, "General Options:\n\n");
  fprintf(stderr, "         -P          skip PHYML\n");
  fprintf(stderr, "         -S          ignore the prob. of gene evolution "
                  "(NOT recommended)\n");
  fprintf(stderr, "         -A          apply constraint to PHYML\n");
  fprintf(stderr, "         -C FILE     constraining tree                      "
                  "         [null]\n");
  fprintf(stderr, "         -f FILE     species tree                           "
                  "      [default]\n");
  fprintf(stderr,
          "         -r          discard species that do not appear at all\n\n");
  fprintf(stderr, "         -I          skip the mmerge step and use the "
                  "constraining tree instead\n\n");
  fprintf(stderr, "Output Options:\n\n");
  fprintf(stderr, "         -D          output some debug information\n");
  fprintf(stderr, "         -q          suppress part of PHYML warnings\n");
  fprintf(stderr, "         -p STR      prefix of intermediate trees           "
                  "         [null]\n");
  fprintf(stderr, "         -o FILE     output tree                            "
                  "         [null]\n\n");
  fprintf(stderr, "Alignment Preprocessing Options:\n\n");
  fprintf(stderr, "         -s          only build tree for genes from "
                  "sequenced species\n");
  fprintf(stderr, "         -g          collapse alternative splicing forms\n");
  fprintf(stderr, "         -N          do not mask low-scoring segments\n");
  fprintf(stderr, "         -F INT      quality cut-off                        "
                  "           [11]\n\n");
  fprintf(stderr, "PHYML Related Options:\n\n");
  fprintf(stderr, "         -c INT      number of rate categories for "
                  "PHYML-HKY            [2]\n");
  fprintf(stderr, "         -k FLOAT|e  tv/ts ratio (kappa), 'e' for "
                  "estimatinig           [e]\n");
  fprintf(stderr, "         -a FLOAT|e  alpha parameter for Gamma distribution "
                  "          [1.0]\n");
  fprintf(stderr, "         -d FLOAT    duplication probability                "
                  "         [0.15]\n");
  fprintf(stderr, "         -l FLOAT    probability of a loss following a "
                  "speciation    [0.10]\n");
  fprintf(stderr, "         -L FLOAT    probability of a loss following a "
                  "duplication   [0.20]\n");
  fprintf(stderr, "         -b FLOAT    prob. of the presence of an "
                  "inconsistent branch [0.01]\n\n");
  fprintf(stderr,
          "Note:    If you use this module in your work, please cite:\n\n");
  fprintf(stderr, "         Guindon S. and Gascuel O. (2003) A simple, fast, "
                  "and accurate\n");
  fprintf(stderr, "           algorithm to estimate large phylogenies by "
                  "maximum likelihood.\n");
  fprintf(stderr, "           Syst Biol, 52(5), 696-704\n\n");
  return 1;
}


x86 assembly (clang, -O0):
<best_usage>:
push   %rbp
mov    %rsp,%rbp
mov    0x2ec5(%rip),%rax
mov    (%rax),%edi
lea    0x1655(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2eb0(%rip),%rax
mov    (%rax),%edi
lea    0xec7(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e9b(%rip),%rax
mov    (%rax),%edi
lea    0xee5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e86(%rip),%rax
mov    (%rax),%edi
lea    0xee3(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e71(%rip),%rax
mov    (%rax),%edi
lea    0xeef(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e5c(%rip),%rax
mov    (%rax),%edi
lea    0xf25(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e47(%rip),%rax
mov    (%rax),%edi
lea    0xf40(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e32(%rip),%rax
mov    (%rax),%edi
lea    0xf78(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e1d(%rip),%rax
mov    (%rax),%edi
lea    0xfb0(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2e08(%rip),%rax
mov    (%rax),%edi
lea    0xfdc(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2df3(%rip),%rax
mov    (%rax),%edi
lea    0x1019(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2dde(%rip),%rax
mov    (%rax),%edi
lea    0x1016(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2dc9(%rip),%rax
mov    (%rax),%edi
lea    0x1035(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2db4(%rip),%rax
mov    (%rax),%edi
lea    0x1056(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d9f(%rip),%rax
mov    (%rax),%edi
lea    0x108e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d8a(%rip),%rax
mov    (%rax),%edi
lea    0x10c7(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d75(%rip),%rax
mov    (%rax),%edi
lea    0x10d5(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d60(%rip),%rax
mov    (%rax),%edi
lea    0x1107(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d4b(%rip),%rax
mov    (%rax),%edi
lea    0x112c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d36(%rip),%rax
mov    (%rax),%edi
lea    0x114e(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d21(%rip),%rax
mov    (%rax),%edi
lea    0x1187(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2d0c(%rip),%rax
mov    (%rax),%edi
lea    0x118b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2cf7(%rip),%rax
mov    (%rax),%edi
lea    0x11c3(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2ce2(%rip),%rax
mov    (%rax),%edi
lea    0x11fb(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2ccd(%rip),%rax
mov    (%rax),%edi
lea    0x1233(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2cb8(%rip),%rax
mov    (%rax),%edi
lea    0x126b(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2ca3(%rip),%rax
mov    (%rax),%edi
lea    0x12a3(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2c8e(%rip),%rax
mov    (%rax),%edi
lea    0x12db(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2c79(%rip),%rax
mov    (%rax),%edi
lea    0x1314(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2c64(%rip),%rax
mov    (%rax),%edi
lea    0x133c(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2c4f(%rip),%rax
mov    (%rax),%edi
lea    0x136f(%rip),%rsi
call   1030 <fprintf@plt>
mov    0x2c3a(%rip),%rax
mov    (%rax),%edi
lea    0x13a5(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<best_usage>:
push   %rbx
mov    0x2ec8(%rip),%rbx
mov    (%rbx),%edi
lea    0x1658(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xed1(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xef6(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xefb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf0e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf4b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xf6d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfac(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0xfeb(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x101e(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1062(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1066(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x108c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10b4(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x10f3(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1133(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1148(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1181(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11ad(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x11d6(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1216(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1221(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1260(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x129f(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x12de(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x131d(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x135c(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x139b(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x13db(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x140a(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1444(%rip),%rsi
call   1030 <fprintf@plt>
mov    (%rbx),%edi
lea    0x1481(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%eax
pop    %rbx
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [2 x i8] c"\0A\00"
@.str.1 = [51 x i8] c"Usage : treebest best [options] <CDS_alignment>\0A\0A\00"
@.str.2 = [19 x i8] c"General Options:\0A\0A\00"
@.str.3 = [33 x i8] c" -P skip PHYML\0A\00"
@.str.4 = [75 x i8] c" -S ignore the prob. of gene evolution (NOT recommended)\0A\00"
@.str.5 = [48 x i8] c" -A apply constraint to PHYML\0A\00"
@.str.6 = [77 x i8] c" -C FILE constraining tree [null]\0A\00"
@.str.7 = [77 x i8] c" -f FILE species tree [default]\0A\00"
@.str.8 = [65 x i8] c" -r discard species that do not appear at all\0A\0A\00"
@.str.9 = [82 x i8] c" -I skip the mmerge step and use the constraining tree instead\0A\0A\00"
@.str.10 = [18 x i8] c"Output Options:\0A\0A\00"
@.str.11 = [52 x i8] c" -D output some debug information\0A\00"
@.str.12 = [54 x i8] c" -q suppress part of PHYML warnings\0A\00"
@.str.13 = [77 x i8] c" -p STR prefix of intermediate trees [null]\0A\00"
@.str.14 = [78 x i8] c" -o FILE output tree [null]\0A\0A\00"
@.str.15 = [35 x i8] c"Alignment Preprocessing Options:\0A\0A\00"
@.str.16 = [71 x i8] c" -s only build tree for genes from sequenced species\0A\00"
@.str.17 = [58 x i8] c" -g collapse alternative splicing forms\0A\00"
@.str.18 = [55 x i8] c" -N do not mask low-scoring segments\0A\00"
@.str.19 = [78 x i8] c" -F INT quality cut-off [11]\0A\0A\00"
@.str.20 = [25 x i8] c"PHYML Related Options:\0A\0A\00"
@.str.21 = [77 x i8] c" -c INT number of rate categories for PHYML-HKY [2]\0A\00"
@.str.22 = [77 x i8] c" -k FLOAT|e tv/ts ratio (kappa), 'e' for estimatinig [e]\0A\00"
@.str.23 = [77 x i8] c" -a FLOAT|e alpha parameter for Gamma distribution [1.0]\0A\00"
@.str.24 = [77 x i8] c" -d FLOAT duplication probability [0.15]\0A\00"
@.str.25 = [77 x i8] c" -l FLOAT probability of a loss following a speciation [0.10]\0A\00"
@.str.26 = [77 x i8] c" -L FLOAT probability of a loss following a duplication [0.20]\0A\00"
@.str.27 = [78 x i8] c" -b FLOAT prob. of the presence of an inconsistent branch [0.01]\0A\0A\00"
@.str.28 = [61 x i8] c"Note: If you use this module in your work, please cite:\0A\0A\00"
@.str.29 = [72 x i8] c" Guindon S. and Gascuel O. (2003) A simple, fast, and accurate\0A\00"
@.str.30 = [75 x i8] c" algorithm to estimate large phylogenies by maximum likelihood.\0A\00"
@.str.31 = [39 x i8] c" Syst Biol, 52(5), 696-704\0A\0A\00"
define i32 @best_usage() {
%1 = load i32, i32* @stderr
%2 = call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.5, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.6, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.7, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.8, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.9, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.11, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.12, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.13, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.14, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.15, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.16, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.17, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.18, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.19, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.20, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.21, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.22, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.23, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.24, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.25, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.26, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.27, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.28, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.29, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.30, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.31, i64 0, i64 0))
ret i32 1
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [2 x i8] c"\0A\00"
@.str.1 = [51 x i8] c"Usage : treebest best [options] <CDS_alignment>\0A\0A\00"
@.str.2 = [19 x i8] c"General Options:\0A\0A\00"
@.str.3 = [33 x i8] c" -P skip PHYML\0A\00"
@.str.4 = [75 x i8] c" -S ignore the prob. of gene evolution (NOT recommended)\0A\00"
@.str.5 = [48 x i8] c" -A apply constraint to PHYML\0A\00"
@.str.6 = [77 x i8] c" -C FILE constraining tree [null]\0A\00"
@.str.7 = [77 x i8] c" -f FILE species tree [default]\0A\00"
@.str.8 = [65 x i8] c" -r discard species that do not appear at all\0A\0A\00"
@.str.9 = [82 x i8] c" -I skip the mmerge step and use the constraining tree instead\0A\0A\00"
@.str.10 = [18 x i8] c"Output Options:\0A\0A\00"
@.str.11 = [52 x i8] c" -D output some debug information\0A\00"
@.str.12 = [54 x i8] c" -q suppress part of PHYML warnings\0A\00"
@.str.13 = [77 x i8] c" -p STR prefix of intermediate trees [null]\0A\00"
@.str.14 = [78 x i8] c" -o FILE output tree [null]\0A\0A\00"
@.str.15 = [35 x i8] c"Alignment Preprocessing Options:\0A\0A\00"
@.str.16 = [71 x i8] c" -s only build tree for genes from sequenced species\0A\00"
@.str.17 = [58 x i8] c" -g collapse alternative splicing forms\0A\00"
@.str.18 = [55 x i8] c" -N do not mask low-scoring segments\0A\00"
@.str.19 = [78 x i8] c" -F INT quality cut-off [11]\0A\0A\00"
@.str.20 = [25 x i8] c"PHYML Related Options:\0A\0A\00"
@.str.21 = [77 x i8] c" -c INT number of rate categories for PHYML-HKY [2]\0A\00"
@.str.22 = [77 x i8] c" -k FLOAT|e tv/ts ratio (kappa), 'e' for estimatinig [e]\0A\00"
@.str.23 = [77 x i8] c" -a FLOAT|e alpha parameter for Gamma distribution [1.0]\0A\00"
@.str.24 = [77 x i8] c" -d FLOAT duplication probability [0.15]\0A\00"
@.str.25 = [77 x i8] c" -l FLOAT probability of a loss following a speciation [0.10]\0A\00"
@.str.26 = [77 x i8] c" -L FLOAT probability of a loss following a duplication [0.20]\0A\00"
@.str.27 = [78 x i8] c" -b FLOAT prob. of the presence of an inconsistent branch [0.01]\0A\0A\00"
@.str.28 = [61 x i8] c"Note: If you use this module in your work, please cite:\0A\0A\00"
@.str.29 = [72 x i8] c" Guindon S. and Gascuel O. (2003) A simple, fast, and accurate\0A\00"
@.str.30 = [75 x i8] c" algorithm to estimate large phylogenies by maximum likelihood.\0A\00"
@.str.31 = [39 x i8] c" Syst Biol, 52(5), 696-704\0A\0A\00"
define i32 @best_usage() {
%1 = load i32, i32* @stderr
%2 = tail call i32 @fprintf(i32 %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%3 = load i32, i32* @stderr
%4 = tail call i32 @fprintf(i32 %3, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.1, i64 0, i64 0))
%5 = load i32, i32* @stderr
%6 = tail call i32 @fprintf(i32 %5, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.2, i64 0, i64 0))
%7 = load i32, i32* @stderr
%8 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0))
%9 = load i32, i32* @stderr
%10 = tail call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.4, i64 0, i64 0))
%11 = load i32, i32* @stderr
%12 = tail call i32 @fprintf(i32 %11, i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.5, i64 0, i64 0))
%13 = load i32, i32* @stderr
%14 = tail call i32 @fprintf(i32 %13, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.6, i64 0, i64 0))
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.7, i64 0, i64 0))
%17 = load i32, i32* @stderr
%18 = tail call i32 @fprintf(i32 %17, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.8, i64 0, i64 0))
%19 = load i32, i32* @stderr
%20 = tail call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.9, i64 0, i64 0))
%21 = load i32, i32* @stderr
%22 = tail call i32 @fprintf(i32 %21, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.10, i64 0, i64 0))
%23 = load i32, i32* @stderr
%24 = tail call i32 @fprintf(i32 %23, i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.11, i64 0, i64 0))
%25 = load i32, i32* @stderr
%26 = tail call i32 @fprintf(i32 %25, i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.12, i64 0, i64 0))
%27 = load i32, i32* @stderr
%28 = tail call i32 @fprintf(i32 %27, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.13, i64 0, i64 0))
%29 = load i32, i32* @stderr
%30 = tail call i32 @fprintf(i32 %29, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.14, i64 0, i64 0))
%31 = load i32, i32* @stderr
%32 = tail call i32 @fprintf(i32 %31, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.15, i64 0, i64 0))
%33 = load i32, i32* @stderr
%34 = tail call i32 @fprintf(i32 %33, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.16, i64 0, i64 0))
%35 = load i32, i32* @stderr
%36 = tail call i32 @fprintf(i32 %35, i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.17, i64 0, i64 0))
%37 = load i32, i32* @stderr
%38 = tail call i32 @fprintf(i32 %37, i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.18, i64 0, i64 0))
%39 = load i32, i32* @stderr
%40 = tail call i32 @fprintf(i32 %39, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.19, i64 0, i64 0))
%41 = load i32, i32* @stderr
%42 = tail call i32 @fprintf(i32 %41, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.20, i64 0, i64 0))
%43 = load i32, i32* @stderr
%44 = tail call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.21, i64 0, i64 0))
%45 = load i32, i32* @stderr
%46 = tail call i32 @fprintf(i32 %45, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.22, i64 0, i64 0))
%47 = load i32, i32* @stderr
%48 = tail call i32 @fprintf(i32 %47, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.23, i64 0, i64 0))
%49 = load i32, i32* @stderr
%50 = tail call i32 @fprintf(i32 %49, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.24, i64 0, i64 0))
%51 = load i32, i32* @stderr
%52 = tail call i32 @fprintf(i32 %51, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.25, i64 0, i64 0))
%53 = load i32, i32* @stderr
%54 = tail call i32 @fprintf(i32 %53, i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.26, i64 0, i64 0))
%55 = load i32, i32* @stderr
%56 = tail call i32 @fprintf(i32 %55, i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.27, i64 0, i64 0))
%57 = load i32, i32* @stderr
%58 = tail call i32 @fprintf(i32 %57, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.28, i64 0, i64 0))
%59 = load i32, i32* @stderr
%60 = tail call i32 @fprintf(i32 %59, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.29, i64 0, i64 0))
%61 = load i32, i32* @stderr
%62 = tail call i32 @fprintf(i32 %61, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.30, i64 0, i64 0))
%63 = load i32, i32* @stderr
%64 = tail call i32 @fprintf(i32 %63, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.31, i64 0, i64 0))
ret i32 1
}