#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*/ printf(char *, ...);
void print_help(char *exec) {
  printf("Usage: %s [OPTION...] [FILE...]\n\n", exec);
  printf("Reads a coherent theory given in the format supported by John "
         "Fisher's geolog prover <http://johnrfisher.net/GeologUI/index.html> "
         "or in the format supported by Marc Bezem and Dimitri Hendriks CL.pl "
         "<http://www.few.vu.nl/~diem/research/ht/#tool>. The strategy "
         "information in the latter format is not used, only the axioms. ");
  printf("The program searches for a model of the given theory, or a proof "
         "that there is no finite model of the theory. ");
  printf("If no file name is given, a single theory is read from standard "
         "input. ");
  printf("Several file names can be given, each will then be parsed as a "
         "single theory and a proof search done for each of them.\n\n");
  printf(" Explanation of options:\n");
  printf("\t-p, --proof\t\tOutput a proof if one is found\n");
  printf("\t-g, --debug \t\tGives (lots of) extra output useful for debugging "
         "or understanding the prover\n");
  printf("\t-x, --text\t\tGives output of proof in separate text file. Same "
         "prefix of name as input file, but with .out as suffix. \n");
  printf("\t-v, --verbose\t\tGives extra output about the proving process\n");
  printf("\t-V, --version\t\tSome info about the program, including copyright "
         "and license\n");
  printf("\t-e, --eager\t\tUses the eager version of RETE. This is probably "
         "always slower.\n");
  printf("\t-q, --coq\t\tOutputs coq format proof to a file in the current "
         "working directory.\n");
  printf("\t-d, --depth-first\t\tUses a depth-first strategy, similar to in "
         "CL.pl. \n");
  printf("\t-f, --factset_lhs\t\tUses standard fact-set method to determine "
         "whether the lhs of an instance is satisified. The default is to use "
         "rete. Implies -n|--not. Work in progress.\n");
  printf("\t-P, --print=TPTP|Geolog|CL.pl\t\tOnly outputs the theory in the "
         "chosen format.\n");
  printf("\t-o, --print_model\t\tPrints the model in the case that there is no "
         "proof of contradiction. (Implied by factset_lhs.)\n");
  printf("\t-D, --dry-run\t\tPrevents running the prover proper. Only parses "
         "and constructs rete net, possibly outputs theory.\n");
  printf("\t-m, --max=LIMIT\t\tMaximum number of inference steps in the "
         "proving process. 0 sets no limit\n");
  printf("\t-C, --CL.pl\t\tParses the input file as in CL.pl. This is the "
         "default.\n");
  printf(
      "\t-G, --geolog\t\tParses the input file as in Fisher's geolog.See "
      "http://johnrfisher.net/GeologUI/index.html#geolog for a description\n");
  printf("\t-T, --TPTP\t\tParses the input as TPTP simple, and translates to "
         "CL. See http://www.cs.miami.edu/~tptp/. Not finished. \n");
  printf("\t-M, --multithreaded\t\tUses a multithreaded algorithm. Should "
         "probably be used with -a|--all-disjuncts.\n");
  printf("\t-t, --cpu_timer=LIMIT\t\tSets a limit to total number of seconds "
         "of CPU time spent.\n");
  printf("\t-S, --single-threaded-rete\t\tPrevents the multithreaded rete "
         "implementation to run. Probably only interesting for testing.\n");
  printf("\t-w, --wallclocktimer=LIMIT\t\tSets a limit to total number of "
         "seconds that may elapse before prover exits.\n");
  printf("\t-a, --all-disjuncts\t\tAlways treats all disjuncts of all treated "
         "disjuncts.\n");
  printf("\t-n, --no-beta-not\t\tPrevents construction of beta-not rete nodes "
         "for the rhs of rules. \n");
  printf("\t-s, --substitution_store\t\tTries to avoid all single mallocs for "
         "each substitution. (Enables substitution_memory.c) \n");
  printf("\nReport bugs to <hovlanddag@gmail.com>\n");
}


x86 assembly (clang, -O0):
<print_help>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rsi
lea    0xed9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeed(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1022(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1083(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10bd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1128(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1134(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1154(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x11a4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x120e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x123e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x127e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x12bf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1303(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x133d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13dd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x141e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1485(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x14ea(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1539(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1572(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x15e8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1652(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16ac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16f2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1760(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x17bd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x17fc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1847(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x18af(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_help>:
push   %rax
mov    %rdi,%rsi
lea    0xed5(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xee9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x101e(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x107f(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x10b9(%rip),%rdi
call   1030 <puts@plt>
lea    0x1125(%rip),%rdi
call   1030 <puts@plt>
lea    0x1132(%rip),%rdi
call   1030 <puts@plt>
lea    0x1153(%rip),%rdi
call   1030 <puts@plt>
lea    0x11a4(%rip),%rdi
call   1030 <puts@plt>
lea    0x120f(%rip),%rdi
call   1030 <puts@plt>
lea    0x1240(%rip),%rdi
call   1030 <puts@plt>
lea    0x1281(%rip),%rdi
call   1030 <puts@plt>
lea    0x12c3(%rip),%rdi
call   1030 <puts@plt>
lea    0x1308(%rip),%rdi
call   1030 <puts@plt>
lea    0x1343(%rip),%rdi
call   1030 <puts@plt>
lea    0x13e4(%rip),%rdi
call   1030 <puts@plt>
lea    0x1426(%rip),%rdi
call   1030 <puts@plt>
lea    0x148e(%rip),%rdi
call   1030 <puts@plt>
lea    0x14f4(%rip),%rdi
call   1030 <puts@plt>
lea    0x1544(%rip),%rdi
call   1030 <puts@plt>
lea    0x157e(%rip),%rdi
call   1030 <puts@plt>
lea    0x15f5(%rip),%rdi
call   1030 <puts@plt>
lea    0x1660(%rip),%rdi
call   1030 <puts@plt>
lea    0x16bb(%rip),%rdi
call   1030 <puts@plt>
lea    0x1702(%rip),%rdi
call   1030 <puts@plt>
lea    0x1771(%rip),%rdi
call   1030 <puts@plt>
lea    0x17cf(%rip),%rdi
call   1030 <puts@plt>
lea    0x180f(%rip),%rdi
call   1030 <puts@plt>
lea    0x185b(%rip),%rdi
call   1030 <puts@plt>
lea    0x18c4(%rip),%rdi
pop    %rax
jmp    1030 <puts@plt>

LLVM IR (-O0):
@.str = [34 x i8] c"Usage: %s [OPTION...] [FILE...]\0A\0A\00"
@.str.1 = [323 x i8] c"Reads a coherent theory given in the format supported by John Fisher's geolog prover <http://johnrfisher.net/GeologUI/index.html> or in the format supported by Marc Bezem and Dimitri Hendriks CL.pl <http://www.few.vu.nl/~diem/research/ht/#tool>. The strategy information in the latter format is not used, only the axioms. \00"
@.str.2 = [111 x i8] c"The program searches for a model of the given theory, or a proof that there is no finite model of the theory. \00"
@.str.3 = [72 x i8] c"If no file name is given, a single theory is read from standard input. \00"
@.str.4 = [121 x i8] c"Several file names can be given, each will then be parsed as a single theory and a proof search done for each of them.\0A\0A\00"
@.str.5 = [26 x i8] c" Explanation of options:\0A\00"
@.str.6 = [46 x i8] c"\09-p, --proof\09\09Output a proof if one is found\0A\00"
@.str.7 = [94 x i8] c"\09-g, --debug \09\09Gives (lots of) extra output useful for debugging or understanding the prover\0A\00"
@.str.8 = [120 x i8] c"\09-x, --text\09\09Gives output of proof in separate text file. Same prefix of name as input file, but with .out as suffix. \0A\00"
@.str.9 = [62 x i8] c"\09-v, --verbose\09\09Gives extra output about the proving process\0A\00"
@.str.10 = [78 x i8] c"\09-V, --version\09\09Some info about the program, including copyright and license\0A\00"
@.str.11 = [79 x i8] c"\09-e, --eager\09\09Uses the eager version of RETE. This is probably always slower.\0A\00"
@.str.12 = [82 x i8] c"\09-q, --coq\09\09Outputs coq format proof to a file in the current working directory.\0A\00"
@.str.13 = [72 x i8] c"\09-d, --depth-first\09\09Uses a depth-first strategy, similar to in CL.pl. \0A\00"
@.str.14 = [174 x i8] c"\09-f, --factset_lhs\09\09Uses standard fact-set method to determine whether the lhs of an instance is satisified. The default is to use rete. Implies -n|--not. Work in progress.\0A\00"
@.str.15 = [79 x i8] c"\09-P, --print=TPTP|Geolog|CL.pl\09\09Only outputs the theory in the chosen format.\0A\00"
@.str.16 = [117 x i8] c"\09-o, --print_model\09\09Prints the model in the case that there is no proof of contradiction. (Implied by factset_lhs.)\0A\00"
@.str.17 = [115 x i8] c"\09-D, --dry-run\09\09Prevents running the prover proper. Only parses and constructs rete net, possibly outputs theory.\0A\00"
@.str.18 = [93 x i8] c"\09-m, --max=LIMIT\09\09Maximum number of inference steps in the proving process. 0 sets no limit\0A\00"
@.str.19 = [71 x i8] c"\09-C, --CL.pl\09\09Parses the input file as in CL.pl. This is the default.\0A\00"
@.str.20 = [132 x i8] c"\09-G, --geolog\09\09Parses the input file as in Fisher's geolog.See http://johnrfisher.net/GeologUI/index.html#geolog for a description\0A\00"
@.str.21 = [120 x i8] c"\09-T, --TPTP\09\09Parses the input as TPTP simple, and translates to CL. See http://www.cs.miami.edu/~tptp/. Not finished. \0A\00"
@.str.22 = [104 x i8] c"\09-M, --multithreaded\09\09Uses a multithreaded algorithm. Should probably be used with -a|--all-disjuncts.\0A\00"
@.str.23 = [84 x i8] c"\09-t, --cpu_timer=LIMIT\09\09Sets a limit to total number of seconds of CPU time spent.\0A\00"
@.str.24 = [124 x i8] c"\09-S, --single-threaded-rete\09\09Prevents the multithreaded rete implementation to run. Probably only interesting for testing.\0A\00"
@.str.25 = [107 x i8] c"\09-w, --wallclocktimer=LIMIT\09\09Sets a limit to total number of seconds that may elapse before prover exits.\0A\00"
@.str.26 = [77 x i8] c"\09-a, --all-disjuncts\09\09Always treats all disjuncts of all treated disjuncts.\0A\00"
@.str.27 = [89 x i8] c"\09-n, --no-beta-not\09\09Prevents construction of beta-not rete nodes for the rhs of rules. \0A\00"
@.str.28 = [118 x i8] c"\09-s, --substitution_store\09\09Tries to avoid all single mallocs for each substitution. (Enables substitution_memory.c) \0A\00"
@.str.29 = [40 x i8] c"\0AReport bugs to <hovlanddag@gmail.com>\0A\00"
define void @print_help(i8* %0) {
%2 = alloca i8*
store i8* %0, i8** %2
%3 = load i8*, i8** %2
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i8* %3)
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([323 x i8], [323 x i8]* @.str.1, i64 0, i64 0))
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.2, i64 0, i64 0))
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.3, i64 0, i64 0))
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([121 x i8], [121 x i8]* @.str.4, i64 0, i64 0))
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.5, i64 0, i64 0))
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.6, i64 0, i64 0))
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.7, i64 0, i64 0))
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([120 x i8], [120 x i8]* @.str.8, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.9, i64 0, i64 0))
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.10, i64 0, i64 0))
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.11, i64 0, i64 0))
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.12, i64 0, i64 0))
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.13, i64 0, i64 0))
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([174 x i8], [174 x i8]* @.str.14, i64 0, i64 0))
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.15, i64 0, i64 0))
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([117 x i8], [117 x i8]* @.str.16, i64 0, i64 0))
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([115 x i8], [115 x i8]* @.str.17, i64 0, i64 0))
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.18, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.19, i64 0, i64 0))
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str.20, i64 0, i64 0))
%25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([120 x i8], [120 x i8]* @.str.21, i64 0, i64 0))
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.22, i64 0, i64 0))
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([84 x i8], [84 x i8]* @.str.23, i64 0, i64 0))
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.24, i64 0, i64 0))
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.25, i64 0, i64 0))
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.26, i64 0, i64 0))
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.27, i64 0, i64 0))
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([118 x i8], [118 x i8]* @.str.28, i64 0, i64 0))
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.29, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [34 x i8] c"Usage: %s [OPTION...] [FILE...]\0A\0A\00"
@.str.1 = [323 x i8] c"Reads a coherent theory given in the format supported by John Fisher's geolog prover <http://johnrfisher.net/GeologUI/index.html> or in the format supported by Marc Bezem and Dimitri Hendriks CL.pl <http://www.few.vu.nl/~diem/research/ht/#tool>. The strategy information in the latter format is not used, only the axioms. \00"
@.str.2 = [111 x i8] c"The program searches for a model of the given theory, or a proof that there is no finite model of the theory. \00"
@.str.3 = [72 x i8] c"If no file name is given, a single theory is read from standard input. \00"
@str = [120 x i8] c"Several file names can be given, each will then be parsed as a single theory and a proof search done for each of them.\0A\00"
@str.30 = [25 x i8] c" Explanation of options:\00"
@str.31 = [45 x i8] c"\09-p, --proof\09\09Output a proof if one is found\00"
@str.32 = [93 x i8] c"\09-g, --debug \09\09Gives (lots of) extra output useful for debugging or understanding the prover\00"
@str.33 = [119 x i8] c"\09-x, --text\09\09Gives output of proof in separate text file. Same prefix of name as input file, but with .out as suffix. \00"
@str.34 = [61 x i8] c"\09-v, --verbose\09\09Gives extra output about the proving process\00"
@str.35 = [77 x i8] c"\09-V, --version\09\09Some info about the program, including copyright and license\00"
@str.36 = [78 x i8] c"\09-e, --eager\09\09Uses the eager version of RETE. This is probably always slower.\00"
@str.37 = [81 x i8] c"\09-q, --coq\09\09Outputs coq format proof to a file in the current working directory.\00"
@str.38 = [71 x i8] c"\09-d, --depth-first\09\09Uses a depth-first strategy, similar to in CL.pl. \00"
@str.39 = [173 x i8] c"\09-f, --factset_lhs\09\09Uses standard fact-set method to determine whether the lhs of an instance is satisified. The default is to use rete. Implies -n|--not. Work in progress.\00"
@str.40 = [78 x i8] c"\09-P, --print=TPTP|Geolog|CL.pl\09\09Only outputs the theory in the chosen format.\00"
@str.41 = [116 x i8] c"\09-o, --print_model\09\09Prints the model in the case that there is no proof of contradiction. (Implied by factset_lhs.)\00"
@str.42 = [114 x i8] c"\09-D, --dry-run\09\09Prevents running the prover proper. Only parses and constructs rete net, possibly outputs theory.\00"
@str.43 = [92 x i8] c"\09-m, --max=LIMIT\09\09Maximum number of inference steps in the proving process. 0 sets no limit\00"
@str.44 = [70 x i8] c"\09-C, --CL.pl\09\09Parses the input file as in CL.pl. This is the default.\00"
@str.45 = [131 x i8] c"\09-G, --geolog\09\09Parses the input file as in Fisher's geolog.See http://johnrfisher.net/GeologUI/index.html#geolog for a description\00"
@str.46 = [119 x i8] c"\09-T, --TPTP\09\09Parses the input as TPTP simple, and translates to CL. See http://www.cs.miami.edu/~tptp/. Not finished. \00"
@str.47 = [103 x i8] c"\09-M, --multithreaded\09\09Uses a multithreaded algorithm. Should probably be used with -a|--all-disjuncts.\00"
@str.48 = [83 x i8] c"\09-t, --cpu_timer=LIMIT\09\09Sets a limit to total number of seconds of CPU time spent.\00"
@str.49 = [123 x i8] c"\09-S, --single-threaded-rete\09\09Prevents the multithreaded rete implementation to run. Probably only interesting for testing.\00"
@str.50 = [106 x i8] c"\09-w, --wallclocktimer=LIMIT\09\09Sets a limit to total number of seconds that may elapse before prover exits.\00"
@str.51 = [76 x i8] c"\09-a, --all-disjuncts\09\09Always treats all disjuncts of all treated disjuncts.\00"
@str.52 = [88 x i8] c"\09-n, --no-beta-not\09\09Prevents construction of beta-not rete nodes for the rhs of rules. \00"
@str.53 = [117 x i8] c"\09-s, --substitution_store\09\09Tries to avoid all single mallocs for each substitution. (Enables substitution_memory.c) \00"
@str.54 = [39 x i8] c"\0AReport bugs to <hovlanddag@gmail.com>\00"
define void @print_help(i8* %0) {
%2 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i8* %0)
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([323 x i8], [323 x i8]* @.str.1, i64 0, i64 0))
%4 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([111 x i8], [111 x i8]* @.str.2, i64 0, i64 0))
%5 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @.str.3, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([120 x i8], [120 x i8]* @str, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.30, i64 0, i64 0))
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @str.31, i64 0, i64 0))
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([93 x i8], [93 x i8]* @str.32, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([119 x i8], [119 x i8]* @str.33, i64 0, i64 0))
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str.34, i64 0, i64 0))
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @str.35, i64 0, i64 0))
%13 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.36, i64 0, i64 0))
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @str.37, i64 0, i64 0))
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.38, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([173 x i8], [173 x i8]* @str.39, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.40, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([116 x i8], [116 x i8]* @str.41, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([114 x i8], [114 x i8]* @str.42, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.43, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.44, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([131 x i8], [131 x i8]* @str.45, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([119 x i8], [119 x i8]* @str.46, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @str.47, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([83 x i8], [83 x i8]* @str.48, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([123 x i8], [123 x i8]* @str.49, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.50, i64 0, i64 0))
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.51, i64 0, i64 0))
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([88 x i8], [88 x i8]* @str.52, i64 0, i64 0))
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([117 x i8], [117 x i8]* @str.53, i64 0, i64 0))
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.54, i64 0, i64 0))
ret void
}