#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 printMinusFUsage(void) {
  printf("\n");
  printf("              \"-f a\": rapid Bootstrap analysis and search for "
         "best-scoring ML tree in one program run\n");
  printf("              \"-f b\": draw bipartition information on a tree "
         "provided with \"-t\" based on multiple trees\n");
  printf("                      (e.g. form a bootstrap) in a file specifed by "
         "\"-z\"\n");
  printf("              \"-f c\": check if the alignment can be properly read "
         "by RAxML\n");
  printf("              \"-f d\": new rapid hill-climbing \n");
  printf("              \"-f e\": optimize model+branch lengths for given "
         "input tree under GAMMA/GAMMAI only\n");
  printf("              \"-f g\": compute per site log Likelihoods for one ore "
         "more trees passed via\n");
  printf("                      \"-z\" and write them to a file that can be "
         "read by CONSEL\n");
  printf("              \"-f h\": compute log likelihood test (SH-test) "
         "between best tree passed via \"-t\"\n");
  printf(
      "                      and a bunch of other trees passed via \"-z\" \n");
  printf("              \"-f i\": perform a really thorough bootstrap, "
         "refinement of final BS tree under GAMMA and a\n");
  printf("                      more exhaustive algorithm\n");
  printf("              \"-f j\": generate a bunch of bootstrapped alignment "
         "files from an original alignemnt file\n");
  printf("              \"-f m\": Compare bipartitions between two bunches of "
         "trees passed via \"-t\" and \"-z\" \n");
  printf("                      respectively. This will return the Pearson "
         "correlation between all bipartitions found\n");
  printf("                      in the two tree files. A file called "
         "RAxML_bipartitionFrequencies.outpuFileName\n");
  printf("                      will be printed that contains the pair-wise "
         "bipartition frequencies of the two sets\n");
  printf("              \"-f n\": Compute the log likelihood score of all "
         "trees contained in a tree file provided by\n");
  printf("                      \"-z\" under GAMMA or GAMMA+P-Invar\n");
  printf("              \"-f o\": old and slower rapid hill-climbing \n");
  printf("              \"-f p\": perform pure stepwise MP addition of new "
         "sequences to an incomplete starting tree\n");
  printf("              \"-f s\": split up a multi-gene partitioned alignment "
         "into the respective subalignments \n");
  printf("              \"-f t\": do randomized tree searches on one fixed "
         "starting tree\n");
  printf("              \"-f w\": compute ELW test on a bunch of trees passed "
         "via \"-z\" \n");
  printf("              \"-f x\": compute pair-wise ML distances, ML model "
         "parameters will be estimated on an MP \n");
  printf("                      starting tree or a user-defined tree passed "
         "via \"-t\", only allowed for GAMMA-based\n");
  printf("                      models of rate heterogeneity\n");
  printf("\n");
  printf("              DEFAULT: new rapid hill climbing\n");
  printf("\n");
}


x86 assembly (clang, -O0):
<printMinusFUsage>:
push   %rbp
mov    %rsp,%rbp
lea    0x1714(%rip),%rdi
call   1030 <printf@plt>
lea    0xed9(%rip),%rdi
call   1030 <printf@plt>
lea    0xf34(%rip),%rdi
call   1030 <printf@plt>
lea    0xf91(%rip),%rdi
call   1030 <printf@plt>
lea    0xfcf(%rip),%rdi
call   1030 <printf@plt>
lea    0x100f(%rip),%rdi
call   1030 <printf@plt>
lea    0x1033(%rip),%rdi
call   1030 <printf@plt>
lea    0x1089(%rip),%rdi
call   1030 <printf@plt>
lea    0x10d7(%rip),%rdi
call   1030 <printf@plt>
lea    0x111b(%rip),%rdi
call   1030 <printf@plt>
lea    0x116e(%rip),%rdi
call   1030 <printf@plt>
lea    0x11a5(%rip),%rdi
call   1030 <printf@plt>
lea    0x1203(%rip),%rdi
call   1030 <printf@plt>
lea    0x1228(%rip),%rdi
call   1030 <printf@plt>
lea    0x1284(%rip),%rdi
call   1030 <printf@plt>
lea    0x12db(%rip),%rdi
call   1030 <printf@plt>
lea    0x133c(%rip),%rdi
call   1030 <printf@plt>
lea    0x1397(%rip),%rdi
call   1030 <printf@plt>
lea    0x13f6(%rip),%rdi
call   1030 <printf@plt>
lea    0x1454(%rip),%rdi
call   1030 <printf@plt>
lea    0x1481(%rip),%rdi
call   1030 <printf@plt>
lea    0x14b0(%rip),%rdi
call   1030 <printf@plt>
lea    0x150d(%rip),%rdi
call   1030 <printf@plt>
lea    0x1567(%rip),%rdi
call   1030 <printf@plt>
lea    0x15a9(%rip),%rdi
call   1030 <printf@plt>
lea    0x15ea(%rip),%rdi
call   1030 <printf@plt>
lea    0x1645(%rip),%rdi
call   1030 <printf@plt>
lea    0x16a3(%rip),%rdi
call   1030 <printf@plt>
lea    0x15c4(%rip),%rdi
call   1030 <printf@plt>
lea    0x16bf(%rip),%rdi
call   1030 <printf@plt>
lea    0x15ac(%rip),%rdi
call   1030 <printf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<printMinusFUsage>:
push   %rax
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xece(%rip),%rdi
call   1040 <puts@plt>
lea    0xf28(%rip),%rdi
call   1040 <puts@plt>
lea    0xf84(%rip),%rdi
call   1040 <puts@plt>
lea    0xfc1(%rip),%rdi
call   1040 <puts@plt>
lea    0x1000(%rip),%rdi
call   1040 <puts@plt>
lea    0x1023(%rip),%rdi
call   1040 <puts@plt>
lea    0x1078(%rip),%rdi
call   1040 <puts@plt>
lea    0x10c5(%rip),%rdi
call   1040 <puts@plt>
lea    0x1108(%rip),%rdi
call   1040 <puts@plt>
lea    0x115a(%rip),%rdi
call   1040 <puts@plt>
lea    0x1190(%rip),%rdi
call   1040 <puts@plt>
lea    0x11ed(%rip),%rdi
call   1040 <puts@plt>
lea    0x1211(%rip),%rdi
call   1040 <puts@plt>
lea    0x126c(%rip),%rdi
call   1040 <puts@plt>
lea    0x12c2(%rip),%rdi
call   1040 <puts@plt>
lea    0x1322(%rip),%rdi
call   1040 <puts@plt>
lea    0x137c(%rip),%rdi
call   1040 <puts@plt>
lea    0x13da(%rip),%rdi
call   1040 <puts@plt>
lea    0x1437(%rip),%rdi
call   1040 <puts@plt>
lea    0x1463(%rip),%rdi
call   1040 <puts@plt>
lea    0x1491(%rip),%rdi
call   1040 <puts@plt>
lea    0x14ed(%rip),%rdi
call   1040 <puts@plt>
lea    0x1546(%rip),%rdi
call   1040 <puts@plt>
lea    0x1587(%rip),%rdi
call   1040 <puts@plt>
lea    0x15c7(%rip),%rdi
call   1040 <puts@plt>
lea    0x1621(%rip),%rdi
call   1040 <puts@plt>
lea    0x167e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x169b(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
pop    %rax
jmp    1030 <putchar@plt>

LLVM IR (-O0):
@.str = [2 x i8] c"\0A\00"
@.str.1 = [103 x i8] c" \22-f a\22: rapid Bootstrap analysis and search for best-scoring ML tree in one program run\0A\00"
@.str.2 = [105 x i8] c" \22-f b\22: draw bipartition information on a tree provided with \22-t\22 based on multiple trees\0A\00"
@.str.3 = [74 x i8] c" (e.g. form a bootstrap) in a file specifed by \22-z\22\0A\00"
@.str.4 = [76 x i8] c" \22-f c\22: check if the alignment can be properly read by RAxML\0A\00"
@.str.5 = [48 x i8] c" \22-f d\22: new rapid hill-climbing \0A\00"
@.str.6 = [98 x i8] c" \22-f e\22: optimize model+branch lengths for given input tree under GAMMA/GAMMAI only\0A\00"
@.str.7 = [90 x i8] c" \22-f g\22: compute per site log Likelihoods for one ore more trees passed via\0A\00"
@.str.8 = [80 x i8] c" \22-z\22 and write them to a file that can be read by CONSEL\0A\00"
@.str.9 = [95 x i8] c" \22-f h\22: compute log likelihood test (SH-test) between best tree passed via \22-t\22\0A\00"
@.str.10 = [67 x i8] c" and a bunch of other trees passed via \22-z\22 \0A\00"
@.str.11 = [106 x i8] c" \22-f i\22: perform a really thorough bootstrap, refinement of final BS tree under GAMMA and a\0A\00"
@.str.12 = [49 x i8] c" more exhaustive algorithm\0A\00"
@.str.13 = [104 x i8] c" \22-f j\22: generate a bunch of bootstrapped alignment files from an original alignemnt file\0A\00"
@.str.14 = [99 x i8] c" \22-f m\22: Compare bipartitions between two bunches of trees passed via \22-t\22 and \22-z\22 \0A\00"
@.str.15 = [109 x i8] c" respectively. This will return the Pearson correlation between all bipartitions found\0A\00"
@.str.16 = [103 x i8] c" in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName\0A\00"
@.str.17 = [107 x i8] c" will be printed that contains the pair-wise bipartition frequencies of the two sets\0A\00"
@.str.18 = [106 x i8] c" \22-f n\22: Compute the log likelihood score of all trees contained in a tree file provided by\0A\00"
@.str.19 = [57 x i8] c" \22-z\22 under GAMMA or GAMMA+P-Invar\0A\00"
@.str.20 = [59 x i8] c" \22-f o\22: old and slower rapid hill-climbing \0A\00"
@.str.21 = [105 x i8] c" \22-f p\22: perform pure stepwise MP addition of new sequences to an incomplete starting tree\0A\00"
@.str.22 = [102 x i8] c" \22-f s\22: split up a multi-gene partitioned alignment into the respective subalignments \0A\00"
@.str.23 = [78 x i8] c" \22-f t\22: do randomized tree searches on one fixed starting tree\0A\00"
@.str.24 = [77 x i8] c" \22-f w\22: compute ELW test on a bunch of trees passed via \22-z\22 \0A\00"
@.str.25 = [103 x i8] c" \22-f x\22: compute pair-wise ML distances, ML model parameters will be estimated on an MP \0A\00"
@.str.26 = [106 x i8] c" starting tree or a user-defined tree passed via \22-t\22, only allowed for GAMMA-based\0A\00"
@.str.27 = [52 x i8] c" models of rate heterogeneity\0A\00"
@.str.28 = [48 x i8] c" DEFAULT: new rapid hill climbing\0A\00"
define void @printMinusFUsage() {
%1 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%2 = call i32 @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.1, i64 0, i64 0))
%3 = call i32 @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.2, i64 0, i64 0))
%4 = call i32 @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.3, i64 0, i64 0))
%5 = call i32 @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.4, i64 0, i64 0))
%6 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.5, i64 0, i64 0))
%7 = call i32 @printf(i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.6, i64 0, i64 0))
%8 = call i32 @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.7, i64 0, i64 0))
%9 = call i32 @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.8, i64 0, i64 0))
%10 = call i32 @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.9, i64 0, i64 0))
%11 = call i32 @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.10, i64 0, i64 0))
%12 = call i32 @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.11, i64 0, i64 0))
%13 = call i32 @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.12, i64 0, i64 0))
%14 = call i32 @printf(i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.13, i64 0, i64 0))
%15 = call i32 @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.14, i64 0, i64 0))
%16 = call i32 @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.15, i64 0, i64 0))
%17 = call i32 @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.16, i64 0, i64 0))
%18 = call i32 @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.17, i64 0, i64 0))
%19 = call i32 @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.18, i64 0, i64 0))
%20 = call i32 @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.19, i64 0, i64 0))
%21 = call i32 @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.20, i64 0, i64 0))
%22 = call i32 @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.21, i64 0, i64 0))
%23 = call i32 @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.22, i64 0, i64 0))
%24 = call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.23, i64 0, i64 0))
%25 = call i32 @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.24, i64 0, i64 0))
%26 = call i32 @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.25, i64 0, i64 0))
%27 = call i32 @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.26, i64 0, i64 0))
%28 = call i32 @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.27, i64 0, i64 0))
%29 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%30 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.28, i64 0, i64 0))
%31 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [102 x i8] c" \22-f a\22: rapid Bootstrap analysis and search for best-scoring ML tree in one program run\00"
@str.29 = [104 x i8] c" \22-f b\22: draw bipartition information on a tree provided with \22-t\22 based on multiple trees\00"
@str.30 = [73 x i8] c" (e.g. form a bootstrap) in a file specifed by \22-z\22\00"
@str.31 = [75 x i8] c" \22-f c\22: check if the alignment can be properly read by RAxML\00"
@str.32 = [47 x i8] c" \22-f d\22: new rapid hill-climbing \00"
@str.33 = [97 x i8] c" \22-f e\22: optimize model+branch lengths for given input tree under GAMMA/GAMMAI only\00"
@str.34 = [89 x i8] c" \22-f g\22: compute per site log Likelihoods for one ore more trees passed via\00"
@str.35 = [79 x i8] c" \22-z\22 and write them to a file that can be read by CONSEL\00"
@str.36 = [94 x i8] c" \22-f h\22: compute log likelihood test (SH-test) between best tree passed via \22-t\22\00"
@str.37 = [66 x i8] c" and a bunch of other trees passed via \22-z\22 \00"
@str.38 = [105 x i8] c" \22-f i\22: perform a really thorough bootstrap, refinement of final BS tree under GAMMA and a\00"
@str.39 = [48 x i8] c" more exhaustive algorithm\00"
@str.40 = [103 x i8] c" \22-f j\22: generate a bunch of bootstrapped alignment files from an original alignemnt file\00"
@str.41 = [98 x i8] c" \22-f m\22: Compare bipartitions between two bunches of trees passed via \22-t\22 and \22-z\22 \00"
@str.42 = [108 x i8] c" respectively. This will return the Pearson correlation between all bipartitions found\00"
@str.43 = [102 x i8] c" in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName\00"
@str.44 = [106 x i8] c" will be printed that contains the pair-wise bipartition frequencies of the two sets\00"
@str.45 = [105 x i8] c" \22-f n\22: Compute the log likelihood score of all trees contained in a tree file provided by\00"
@str.46 = [56 x i8] c" \22-z\22 under GAMMA or GAMMA+P-Invar\00"
@str.47 = [58 x i8] c" \22-f o\22: old and slower rapid hill-climbing \00"
@str.48 = [104 x i8] c" \22-f p\22: perform pure stepwise MP addition of new sequences to an incomplete starting tree\00"
@str.49 = [101 x i8] c" \22-f s\22: split up a multi-gene partitioned alignment into the respective subalignments \00"
@str.50 = [77 x i8] c" \22-f t\22: do randomized tree searches on one fixed starting tree\00"
@str.51 = [76 x i8] c" \22-f w\22: compute ELW test on a bunch of trees passed via \22-z\22 \00"
@str.52 = [102 x i8] c" \22-f x\22: compute pair-wise ML distances, ML model parameters will be estimated on an MP \00"
@str.53 = [105 x i8] c" starting tree or a user-defined tree passed via \22-t\22, only allowed for GAMMA-based\00"
@str.54 = [51 x i8] c" models of rate heterogeneity\00"
@str.55 = [47 x i8] c" DEFAULT: new rapid hill climbing\00"
define void @printMinusFUsage() {
%1 = tail call i32 @putchar(i32 10)
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str, i64 0, i64 0))
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.29, i64 0, i64 0))
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @str.30, i64 0, i64 0))
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.31, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.32, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @str.33, i64 0, i64 0))
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.34, i64 0, i64 0))
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.35, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.36, i64 0, i64 0))
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str.37, i64 0, i64 0))
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.38, i64 0, i64 0))
%13 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.39, i64 0, i64 0))
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @str.40, i64 0, i64 0))
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([98 x i8], [98 x i8]* @str.41, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.42, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str.43, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.44, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.45, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str.46, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @str.47, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.48, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.49, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @str.50, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.51, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str.52, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.53, i64 0, i64 0))
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.54, i64 0, i64 0))
%29 = tail call i32 @putchar(i32 10)
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.55, i64 0, i64 0))
%31 = tail call i32 @putchar(i32 10)
ret void
}