#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 A\": compute marginal ancestral states on a "
         "ROOTED reference tree provided with \"t\"\n");
  printf("              \"-f b\": draw bipartition information on a tree "
         "provided with \"-t\" based on multiple trees\n");
  printf("                      (e.g., from a bootstrap) in a file specified "
         "by \"-z\"\n");
  printf("              \"-f B\": optimize br-len scaler and other model "
         "parameters (GTR, alpha, etc.) on a tree provided with \"-t\".\n");
  printf("                      The tree needs to contain branch lengths. The "
         "branch lengths will not be optimized, just scaled by a single common "
         "value.\n");
  printf("              \"-f c\": check if the alignment can be properly read "
         "by RAxML\n");
  printf("              \"-f C\": ancestral sequence test for Jiajie, users "
         "will also need to provide a list of taxon names via -Y separated by "
         "whitespaces\n");
  printf("              \"-f d\": new rapid hill-climbing \n");
  printf("                      DEFAULT: ON\n");
  printf("              \"-f D\": rapid hill-climbing with RELL bootstraps\n");
  printf("              \"-f e\": optimize model+branch lengths for given "
         "input tree under GAMMA/GAMMAI only\n");
  printf("              \"-f E\": execute very fast experimental tree search, "
         "at present only for testing\n");
  printf("              \"-f F\": execute fast experimental tree search, at "
         "present only for testing\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("                      The model parameters will be estimated on the "
         "first tree 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("                      The model parameters will be re-estimated for "
         "each tree\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("                      The model parameters will be estimated on the "
         "first tree only!\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("                      The model parameters will be re-estimated for "
         "each tree\n");
  printf(
      "              \"-f i\": calculate IC and TC scores (Salichos and Rokas "
      "2013) on a tree provided with \"-t\" based on multiple trees\n");
  printf("                      (e.g., from a bootstrap) in a file specified "
         "by \"-z\"\n");
  printf("              \"-f I\": a simple tree rooting algorithm for unrooted "
         "trees.\n");
  printf("                      It roots the tree by rooting it at the branch "
         "that best balances the subtree lengths\n");
  printf("                      (sum over branches in the subtrees) of the "
         "left and right subtree.\n");
  printf("                      A branch with an optimal balance does not "
         "always exist!\n");
  printf("                      You need to specify the tree you want to root "
         "via \"-t\".\n");
  printf("              \"-f j\": generate a bunch of bootstrapped alignment "
         "files from an original alignemnt file.\n");
  printf("                      You need to specify a seed with \"-b\" and the "
         "number of replicates with \"-#\" \n");
  printf("              \"-f J\": Compute SH-like support values on a given "
         "tree passed via \"-t\".\n");
  printf("              \"-f k\": Predict missing sequence data in a "
         "partitioned multi-gene alignment for a given tree.\n");
  printf("                      Only works in conjunction with \"-t\", \"-M\", "
         "and \"-q\".\n");
  printf("                      This option is in an early experimental state, "
         "use at your own risk!\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("                      The model parameters will be estimated on the "
         "first tree only!\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("                      The model parameters will be re-estimated for "
         "each tree\n");
  printf("              \"-f o\": old and slower rapid hill-climbing without "
         "heuristic cutoff\n");
  printf("              \"-f p\": perform pure stepwise MP addition of new "
         "sequences to an incomplete starting tree and exit\n");
  printf("              \"-f q\": fast quartet calculator\n");
  printf(
      "              \"-f r\": compute pairwise Robinson-Foulds (RF) distances "
      "between all pairs of trees in a tree file passed via \"-z\" \n");
  printf(
      "                      if the trees have node labales represented as "
      "integer support values the program will also compute two flavors of\n");
  printf("                      the weighted Robinson-Foulds (WRF) distance\n");
  printf("              \"-f R\": compute all pairwise Robinson-Foulds (RF) "
         "distances between a large reference tree  passed via \"-t\" \n");
  printf("                      and many smaller trees (that must have a "
         "subset of the taxa of the large tree) passed via \"-z\".\n");
  printf("                      This option is intended for checking the "
         "plausibility of very large phylogenies that can not be inspected\n");
  printf("                      visually any more.\n");
  printf("              \"-f s\": split up a multi-gene partitioned alignment "
         "into the respective subalignments \n");
  printf(
      "              \"-f S\": compute site-specific placement bias using a "
      "leave one out test inspired by the evolutionary placement algorithm\n");
  printf("              \"-f t\": do randomized tree searches on one fixed "
         "starting tree\n");
  printf("              \"-f T\": do final thorough optimization of ML tree "
         "from rapid bootstrap search in stand-alone mode\n");
  printf("              \"-f u\": execute morphological weight calibration "
         "using maximum likelihood, this will return a weight vector.\n");
  printf("                      you need to provide a morphological alignment "
         "and a reference tree via \"-t\" \n");
  printf("              \"-f v\": classify a bunch of environmental sequences "
         "into a reference tree using thorough read insertions\n");
  printf("                      you will need to start RAxML with a "
         "non-comprehensive reference tree and an alignment containing all "
         "sequences (reference + query)\n");
  printf("              \"-f V\": classify a bunch of environmental sequences "
         "into a reference tree using thorough read insertions\n");
  printf("                      you will need to start RAxML with a "
         "non-comprehensive reference tree and an alignment containing all "
         "sequences (reference + query)\n");
  printf("                      WARNING: this is a test implementation for "
         "more efficient handling of multi-gene/whole-genome datasets!\n");
  printf("              \"-f w\": compute ELW test on a bunch of trees passed "
         "via \"-z\" \n");
  printf("                      The model parameters will be estimated on the "
         "first tree only!\n");
  printf("              \"-f W\": compute ELW test on a bunch of trees passed "
         "via \"-z\" \n");
  printf("                      The model parameters will be re-estimated for "
         "each tree\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("              \"-f y\": classify a bunch of environmental sequences "
         "into a reference tree using parsimony\n");
  printf("                      you will need to start RAxML with a "
         "non-comprehensive reference tree and an alignment containing all "
         "sequences (reference + query)\n");
  printf("\n");
  printf("              DEFAULT for \"-f\": new rapid hill climbing\n");
  printf("\n");
}


x86 assembly (clang, -O0):
<printMinusFUsage>:
push   %rbp
mov    %rsp,%rbp
lea    0x19f3(%rip),%rdi
call   1030 <printf@plt>
lea    0xed9(%rip),%rdi
call   1030 <printf@plt>
lea    0xf34(%rip),%rdi
call   1030 <printf@plt>
lea    0xf8e(%rip),%rdi
call   1030 <printf@plt>
lea    0xfeb(%rip),%rdi
call   1030 <printf@plt>
lea    0x102b(%rip),%rdi
call   1030 <printf@plt>
lea    0x1099(%rip),%rdi
call   1030 <printf@plt>
lea    0x111e(%rip),%rdi
call   1030 <printf@plt>
lea    0x115e(%rip),%rdi
call   1030 <printf@plt>
lea    0x11e3(%rip),%rdi
call   1030 <printf@plt>
lea    0x1207(%rip),%rdi
call   1030 <printf@plt>
lea    0x121e(%rip),%rdi
call   1030 <printf@plt>
lea    0x1252(%rip),%rdi
call   1030 <printf@plt>
lea    0x12a8(%rip),%rdi
call   1030 <printf@plt>
lea    0x12fb(%rip),%rdi
call   1030 <printf@plt>
lea    0x1349(%rip),%rdi
call   1030 <printf@plt>
lea    0x1397(%rip),%rdi
call   1030 <printf@plt>
lea    0x13db(%rip),%rdi
call   1030 <printf@plt>
lea    0x1425(%rip),%rdi
call   1030 <printf@plt>
lea    0x1473(%rip),%rdi
call   1030 <printf@plt>
lea    0x14b8(%rip),%rdi
call   1030 <printf@plt>
lea    0x14fb(%rip),%rdi
call   1030 <printf@plt>
lea    0x154e(%rip),%rdi
call   1030 <printf@plt>
lea    0x1393(%rip),%rdi
call   1030 <printf@plt>
lea    0x1579(%rip),%rdi
call   1030 <printf@plt>
lea    0x152a(%rip),%rdi
call   1030 <printf@plt>
lea    0x1470(%rip),%rdi
call   1030 <printf@plt>
lea    0x15b4(%rip),%rdi
call   1030 <printf@plt>
lea    0xecb(%rip),%rdi
call   1030 <printf@plt>
lea    0x161d(%rip),%rdi
call   1030 <printf@plt>
lea    0x165c(%rip),%rdi
call   1030 <printf@plt>
lea    0x16bc(%rip),%rdi
call   1030 <printf@plt>
lea    0x170a(%rip),%rdi
call   1030 <printf@plt>
lea    0x174d(%rip),%rdi
call   1030 <printf@plt>
lea    0x1790(%rip),%rdi
call   1030 <printf@plt>
lea    0x17ed(%rip),%rdi
call   1030 <printf@plt>
lea    0x1845(%rip),%rdi
call   1030 <printf@plt>
lea    0x1890(%rip),%rdi
call   1030 <printf@plt>
lea    0x18f1(%rip),%rdi
call   1030 <printf@plt>
lea    0x1931(%rip),%rdi
call   1030 <printf@plt>
lea    0x1981(%rip),%rdi
call   1030 <printf@plt>
lea    0x19d8(%rip),%rdi
call   1030 <printf@plt>
lea    0x1a39(%rip),%rdi
call   1030 <printf@plt>
lea    0x1a94(%rip),%rdi
call   1030 <printf@plt>
lea    0x1af3(%rip),%rdi
call   1030 <printf@plt>
lea    0x1b51(%rip),%rdi
call   1030 <printf@plt>
lea    0x127f(%rip),%rdi
call   1030 <printf@plt>
lea    0x1b72(%rip),%rdi
call   1030 <printf@plt>
lea    0x1b2d(%rip),%rdi
call   1030 <printf@plt>
lea    0x135c(%rip),%rdi
call   1030 <printf@plt>
lea    0x1bb8(%rip),%rdi
call   1030 <printf@plt>
lea    0x1bff(%rip),%rdi
call   1030 <printf@plt>
lea    0x1c65(%rip),%rdi
call   1030 <printf@plt>
lea    0x1c88(%rip),%rdi
call   1030 <printf@plt>
lea    0x1cfe(%rip),%rdi
call   1030 <printf@plt>
lea    0x1d7b(%rip),%rdi
call   1030 <printf@plt>
lea    0x1db2(%rip),%rdi
call   1030 <printf@plt>
lea    0x1e22(%rip),%rdi
call   1030 <printf@plt>
lea    0x1e8d(%rip),%rdi
call   1030 <printf@plt>
lea    0x1f02(%rip),%rdi
call   1030 <printf@plt>
lea    0x1f20(%rip),%rdi
call   1030 <printf@plt>
lea    0x1f7a(%rip),%rdi
call   1030 <printf@plt>
lea    0x1ff6(%rip),%rdi
call   1030 <printf@plt>
lea    0x2038(%rip),%rdi
call   1030 <printf@plt>
lea    0x209d(%rip),%rdi
call   1030 <printf@plt>
lea    0x210d(%rip),%rdi
call   1030 <printf@plt>
lea    0x2165(%rip),%rdi
call   1030 <printf@plt>
lea    0x21d1(%rip),%rdi
call   1030 <printf@plt>
lea    0x225f(%rip),%rdi
call   1030 <printf@plt>
lea    0x21b9(%rip),%rdi
call   1030 <printf@plt>
lea    0x22bf(%rip),%rdi
call   1030 <printf@plt>
lea    0x2332(%rip),%rdi
call   1030 <printf@plt>
lea    0x1147(%rip),%rdi
call   1030 <printf@plt>
lea    0x2367(%rip),%rdi
call   1030 <printf@plt>
lea    0x1230(%rip),%rdi
call   1030 <printf@plt>
lea    0x239c(%rip),%rdi
call   1030 <printf@plt>
lea    0x23f7(%rip),%rdi
call   1030 <printf@plt>
lea    0x2455(%rip),%rdi
call   1030 <printf@plt>
lea    0x247d(%rip),%rdi
call   1030 <printf@plt>
lea    0x2141(%rip),%rdi
call   1030 <printf@plt>
lea    0x1633(%rip),%rdi
call   1030 <printf@plt>
lea    0x24c2(%rip),%rdi
call   1030 <printf@plt>
lea    0x161b(%rip),%rdi
call   1030 <printf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<printMinusFUsage>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xec7(%rip),%rdi
call   1040 <puts@plt>
lea    0xf21(%rip),%rdi
call   1040 <puts@plt>
lea    0xf7a(%rip),%rdi
call   1040 <puts@plt>
lea    0x1631(%rip),%r12
mov    %r12,%rdi
call   1040 <puts@plt>
lea    0xfc7(%rip),%rdi
call   1040 <puts@plt>
lea    0x1034(%rip),%rdi
call   1040 <puts@plt>
lea    0x10b8(%rip),%rdi
call   1040 <puts@plt>
lea    0x10f7(%rip),%rdi
call   1040 <puts@plt>
lea    0x117b(%rip),%rdi
call   1040 <puts@plt>
lea    0x119e(%rip),%rdi
call   1040 <puts@plt>
lea    0x11b4(%rip),%rdi
call   1040 <puts@plt>
lea    0x11e7(%rip),%rdi
call   1040 <puts@plt>
lea    0x123c(%rip),%rdi
call   1040 <puts@plt>
lea    0x128e(%rip),%rdi
call   1040 <puts@plt>
lea    0x12db(%rip),%rdi
call   1040 <puts@plt>
lea    0x1328(%rip),%rdi
call   1040 <puts@plt>
lea    0x2477(%rip),%r14
mov    %r14,%rdi
call   1040 <puts@plt>
lea    0x135c(%rip),%rdi
call   1040 <puts@plt>
lea    0x13a9(%rip),%rdi
call   1040 <puts@plt>
lea    0x24f1(%rip),%r15
mov    %r15,%rdi
call   1040 <puts@plt>
lea    0x13de(%rip),%rdi
call   1040 <puts@plt>
lea    0x148e(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
lea    0x1419(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    %r15,%rdi
call   1040 <puts@plt>
lea    0x149d(%rip),%rdi
call   1040 <puts@plt>
mov    %r12,%rdi
call   1040 <puts@plt>
lea    0x1554(%rip),%rdi
call   1040 <puts@plt>
lea    0x1592(%rip),%rdi
call   1040 <puts@plt>
lea    0x15f1(%rip),%rdi
call   1040 <puts@plt>
lea    0x163e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1680(%rip),%rdi
call   1040 <puts@plt>
lea    0x16c2(%rip),%rdi
call   1040 <puts@plt>
lea    0x171e(%rip),%rdi
call   1040 <puts@plt>
lea    0x1775(%rip),%rdi
call   1040 <puts@plt>
lea    0x17bf(%rip),%rdi
call   1040 <puts@plt>
lea    0x181f(%rip),%rdi
call   1040 <puts@plt>
lea    0x185e(%rip),%rdi
call   1040 <puts@plt>
lea    0x18ad(%rip),%rdi
call   1040 <puts@plt>
lea    0x1903(%rip),%rdi
call   1040 <puts@plt>
lea    0x1963(%rip),%rdi
call   1040 <puts@plt>
lea    0x19bd(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a1b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ae1(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
lea    0x1a61(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    %r15,%rdi
call   1040 <puts@plt>
lea    0x1ae6(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b2c(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b91(%rip),%rdi
call   1040 <puts@plt>
lea    0x1bb3(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c28(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ca4(%rip),%rdi
call   1040 <puts@plt>
lea    0x1cda(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d49(%rip),%rdi
call   1040 <puts@plt>
lea    0x1db3(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e27(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e44(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e9d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f18(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f59(%rip),%rdi
call   1040 <puts@plt>
lea    0x1fbd(%rip),%rdi
call   1040 <puts@plt>
lea    0x202c(%rip),%rdi
call   1040 <puts@plt>
lea    0x2083(%rip),%rdi
call   1040 <puts@plt>
lea    0x2488(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0x20df(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
lea    0x2142(%rip),%rdi
call   1040 <puts@plt>
lea    0x21b4(%rip),%rdi
call   1040 <puts@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
lea    0x2241(%rip),%rdi
call   1040 <puts@plt>
mov    %r15,%rdi
call   1040 <puts@plt>
lea    0x22c7(%rip),%rdi
call   1040 <puts@plt>
lea    0x2321(%rip),%rdi
call   1040 <puts@plt>
lea    0x237e(%rip),%rdi
call   1040 <puts@plt>
lea    0x23a5(%rip),%rdi
call   1040 <puts@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2488(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
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 = [102 x i8] c" \22-f A\22: compute marginal ancestral states on a ROOTED reference tree provided with \22t\22\0A\00"
@.str.3 = [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.4 = [76 x i8] c" (e.g., from a bootstrap) in a file specified by \22-z\22\0A\00"
@.str.5 = [122 x i8] c" \22-f B\22: optimize br-len scaler and other model parameters (GTR, alpha, etc.) on a tree provided with \22-t\22.\0A\00"
@.str.6 = [145 x i8] c" The tree needs to contain branch lengths. The branch lengths will not be optimized, just scaled by a single common value.\0A\00"
@.str.7 = [76 x i8] c" \22-f c\22: check if the alignment can be properly read by RAxML\0A\00"
@.str.8 = [145 x i8] c" \22-f C\22: ancestral sequence test for Jiajie, users will also need to provide a list of taxon names via -Y separated by whitespaces\0A\00"
@.str.9 = [48 x i8] c" \22-f d\22: new rapid hill-climbing \0A\00"
@.str.10 = [35 x i8] c" DEFAULT: ON\0A\00"
@.str.11 = [64 x i8] c" \22-f D\22: rapid hill-climbing with RELL bootstraps\0A\00"
@.str.12 = [98 x i8] c" \22-f e\22: optimize model+branch lengths for given input tree under GAMMA/GAMMAI only\0A\00"
@.str.13 = [95 x i8] c" \22-f E\22: execute very fast experimental tree search, at present only for testing\0A\00"
@.str.14 = [90 x i8] c" \22-f F\22: execute fast experimental tree search, at present only for testing\0A\00"
@.str.15 = [90 x i8] c" \22-f g\22: compute per site log Likelihoods for one ore more trees passed via\0A\00"
@.str.16 = [80 x i8] c" \22-z\22 and write them to a file that can be read by CONSEL\0A\00"
@.str.17 = [86 x i8] c" The model parameters will be estimated on the first tree only!\0A\00"
@.str.18 = [90 x i8] c" \22-f G\22: compute per site log Likelihoods for one ore more trees passed via\0A\00"
@.str.19 = [81 x i8] c" \22-z\22 and write them to a file that can be read by CONSEL.\0A\00"
@.str.20 = [79 x i8] c" The model parameters will be re-estimated for each tree\0A\00"
@.str.21 = [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.22 = [67 x i8] c" and a bunch of other trees passed via \22-z\22 \0A\00"
@.str.23 = [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.24 = [129 x i8] c" \22-f i\22: calculate IC and TC scores (Salichos and Rokas 2013) on a tree provided with \22-t\22 based on multiple trees\0A\00"
@.str.25 = [75 x i8] c" \22-f I\22: a simple tree rooting algorithm for unrooted trees.\0A\00"
@.str.26 = [108 x i8] c" It roots the tree by rooting it at the branch that best balances the subtree lengths\0A\00"
@.str.27 = [90 x i8] c" (sum over branches in the subtrees) of the left and right subtree.\0A\00"
@.str.28 = [79 x i8] c" A branch with an optimal balance does not always exist!\0A\00"
@.str.29 = [79 x i8] c" You need to specify the tree you want to root via \22-t\22.\0A\00"
@.str.30 = [105 x i8] c" \22-f j\22: generate a bunch of bootstrapped alignment files from an original alignemnt file.\0A\00"
@.str.31 = [100 x i8] c" You need to specify a seed with \22-b\22 and the number of replicates with \22-#\22 \0A\00"
@.str.32 = [87 x i8] c" \22-f J\22: Compute SH-like support values on a given tree passed via \22-t\22.\0A\00"
@.str.33 = [109 x i8] c" \22-f k\22: Predict missing sequence data in a partitioned multi-gene alignment for a given tree.\0A\00"
@.str.34 = [76 x i8] c" Only works in conjunction with \22-t\22, \22-M\22, and \22-q\22.\0A\00"
@.str.35 = [92 x i8] c" This option is in an early experimental state, use at your own risk!\0A\00"
@.str.36 = [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.37 = [109 x i8] c" respectively. This will return the Pearson correlation between all bipartitions found\0A\00"
@.str.38 = [103 x i8] c" in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName\0A\00"
@.str.39 = [107 x i8] c" will be printed that contains the pair-wise bipartition frequencies of the two sets\0A\00"
@.str.40 = [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.41 = [57 x i8] c" \22-z\22 under GAMMA or GAMMA+P-Invar\0A\00"
@.str.42 = [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.43 = [83 x i8] c" \22-f o\22: old and slower rapid hill-climbing without heuristic cutoff\0A\00"
@.str.44 = [114 x i8] c" \22-f p\22: perform pure stepwise MP addition of new sequences to an incomplete starting tree and exit\0A\00"
@.str.45 = [47 x i8] c" \22-f q\22: fast quartet calculator\0A\00"
@.str.46 = [130 x i8] c" \22-f r\22: compute pairwise Robinson-Foulds (RF) distances between all pairs of trees in a tree file passed via \22-z\22 \0A\00"
@.str.47 = [137 x i8] c" if the trees have node labales represented as integer support values the program will also compute two flavors of\0A\00"
@.str.48 = [67 x i8] c" the weighted Robinson-Foulds (WRF) distance\0A\00"
@.str.49 = [124 x i8] c" \22-f R\22: compute all pairwise Robinson-Foulds (RF) distances between a large reference tree passed via \22-t\22 \0A\00"
@.str.50 = [119 x i8] c" and many smaller trees (that must have a subset of the taxa of the large tree) passed via \22-z\22.\0A\00"
@.str.51 = [129 x i8] c" This option is intended for checking the plausibility of very large phylogenies that can not be inspected\0A\00"
@.str.52 = [42 x i8] c" visually any more.\0A\00"
@.str.53 = [102 x i8] c" \22-f s\22: split up a multi-gene partitioned alignment into the respective subalignments \0A\00"
@.str.54 = [136 x i8] c" \22-f S\22: compute site-specific placement bias using a leave one out test inspired by the evolutionary placement algorithm\0A\00"
@.str.55 = [78 x i8] c" \22-f t\22: do randomized tree searches on one fixed starting tree\0A\00"
@.str.56 = [113 x i8] c" \22-f T\22: do final thorough optimization of ML tree from rapid bootstrap search in stand-alone mode\0A\00"
@.str.57 = [124 x i8] c" \22-f u\22: execute morphological weight calibration using maximum likelihood, this will return a weight vector.\0A\00"
@.str.58 = [100 x i8] c" you need to provide a morphological alignment and a reference tree via \22-t\22 \0A\00"
@.str.59 = [120 x i8] c" \22-f v\22: classify a bunch of environmental sequences into a reference tree using thorough read insertions\0A\00"
@.str.60 = [154 x i8] c" you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)\0A\00"
@.str.61 = [120 x i8] c" \22-f V\22: classify a bunch of environmental sequences into a reference tree using thorough read insertions\0A\00"
@.str.62 = [127 x i8] c" WARNING: this is a test implementation for more efficient handling of multi-gene/whole-genome datasets!\0A\00"
@.str.63 = [77 x i8] c" \22-f w\22: compute ELW test on a bunch of trees passed via \22-z\22 \0A\00"
@.str.64 = [77 x i8] c" \22-f W\22: compute ELW test on a bunch of trees passed via \22-z\22 \0A\00"
@.str.65 = [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.66 = [106 x i8] c" starting tree or a user-defined tree passed via \22-t\22, only allowed for GAMMA-based\0A\00"
@.str.67 = [52 x i8] c" models of rate heterogeneity\0A\00"
@.str.68 = [105 x i8] c" \22-f y\22: classify a bunch of environmental sequences into a reference tree using parsimony\0A\00"
@.str.69 = [57 x i8] c" DEFAULT for \22-f\22: 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 ([102 x i8], [102 x i8]* @.str.2, i64 0, i64 0))
%4 = call i32 @printf(i8* getelementptr inbounds ([105 x i8], [105 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 ([122 x i8], [122 x i8]* @.str.5, i64 0, i64 0))
%7 = call i32 @printf(i8* getelementptr inbounds ([145 x i8], [145 x i8]* @.str.6, i64 0, i64 0))
%8 = call i32 @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.7, i64 0, i64 0))
%9 = call i32 @printf(i8* getelementptr inbounds ([145 x i8], [145 x i8]* @.str.8, i64 0, i64 0))
%10 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.9, i64 0, i64 0))
%11 = call i32 @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.10, i64 0, i64 0))
%12 = call i32 @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.11, i64 0, i64 0))
%13 = call i32 @printf(i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.12, i64 0, i64 0))
%14 = call i32 @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.13, i64 0, i64 0))
%15 = call i32 @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.14, i64 0, i64 0))
%16 = call i32 @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.15, i64 0, i64 0))
%17 = call i32 @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.16, i64 0, i64 0))
%18 = call i32 @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.17, i64 0, i64 0))
%19 = call i32 @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.18, i64 0, i64 0))
%20 = call i32 @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.19, i64 0, i64 0))
%21 = call i32 @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%22 = call i32 @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.21, i64 0, i64 0))
%23 = call i32 @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.22, i64 0, i64 0))
%24 = call i32 @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.17, i64 0, i64 0))
%25 = call i32 @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.23, i64 0, i64 0))
%26 = call i32 @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.22, i64 0, i64 0))
%27 = call i32 @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%28 = call i32 @printf(i8* getelementptr inbounds ([129 x i8], [129 x i8]* @.str.24, i64 0, i64 0))
%29 = call i32 @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.4, i64 0, i64 0))
%30 = call i32 @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.25, i64 0, i64 0))
%31 = call i32 @printf(i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.26, i64 0, i64 0))
%32 = call i32 @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.27, i64 0, i64 0))
%33 = call i32 @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.28, i64 0, i64 0))
%34 = call i32 @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.29, i64 0, i64 0))
%35 = call i32 @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.30, i64 0, i64 0))
%36 = call i32 @printf(i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.31, i64 0, i64 0))
%37 = call i32 @printf(i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.32, i64 0, i64 0))
%38 = call i32 @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.33, i64 0, i64 0))
%39 = call i32 @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.34, i64 0, i64 0))
%40 = call i32 @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.35, i64 0, i64 0))
%41 = call i32 @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.36, i64 0, i64 0))
%42 = call i32 @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.37, i64 0, i64 0))
%43 = call i32 @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.38, i64 0, i64 0))
%44 = call i32 @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.39, i64 0, i64 0))
%45 = call i32 @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.40, i64 0, i64 0))
%46 = call i32 @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.41, i64 0, i64 0))
%47 = call i32 @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.17, i64 0, i64 0))
%48 = call i32 @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.42, i64 0, i64 0))
%49 = call i32 @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.41, i64 0, i64 0))
%50 = call i32 @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%51 = call i32 @printf(i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.43, i64 0, i64 0))
%52 = call i32 @printf(i8* getelementptr inbounds ([114 x i8], [114 x i8]* @.str.44, i64 0, i64 0))
%53 = call i32 @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.45, i64 0, i64 0))
%54 = call i32 @printf(i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str.46, i64 0, i64 0))
%55 = call i32 @printf(i8* getelementptr inbounds ([137 x i8], [137 x i8]* @.str.47, i64 0, i64 0))
%56 = call i32 @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.48, i64 0, i64 0))
%57 = call i32 @printf(i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.49, i64 0, i64 0))
%58 = call i32 @printf(i8* getelementptr inbounds ([119 x i8], [119 x i8]* @.str.50, i64 0, i64 0))
%59 = call i32 @printf(i8* getelementptr inbounds ([129 x i8], [129 x i8]* @.str.51, i64 0, i64 0))
%60 = call i32 @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.52, i64 0, i64 0))
%61 = call i32 @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.53, i64 0, i64 0))
%62 = call i32 @printf(i8* getelementptr inbounds ([136 x i8], [136 x i8]* @.str.54, i64 0, i64 0))
%63 = call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.55, i64 0, i64 0))
%64 = call i32 @printf(i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.56, i64 0, i64 0))
%65 = call i32 @printf(i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.57, i64 0, i64 0))
%66 = call i32 @printf(i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.58, i64 0, i64 0))
%67 = call i32 @printf(i8* getelementptr inbounds ([120 x i8], [120 x i8]* @.str.59, i64 0, i64 0))
%68 = call i32 @printf(i8* getelementptr inbounds ([154 x i8], [154 x i8]* @.str.60, i64 0, i64 0))
%69 = call i32 @printf(i8* getelementptr inbounds ([120 x i8], [120 x i8]* @.str.61, i64 0, i64 0))
%70 = call i32 @printf(i8* getelementptr inbounds ([154 x i8], [154 x i8]* @.str.60, i64 0, i64 0))
%71 = call i32 @printf(i8* getelementptr inbounds ([127 x i8], [127 x i8]* @.str.62, i64 0, i64 0))
%72 = call i32 @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.63, i64 0, i64 0))
%73 = call i32 @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.17, i64 0, i64 0))
%74 = call i32 @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.64, i64 0, i64 0))
%75 = call i32 @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%76 = call i32 @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.65, i64 0, i64 0))
%77 = call i32 @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.66, i64 0, i64 0))
%78 = call i32 @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.67, i64 0, i64 0))
%79 = call i32 @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.68, i64 0, i64 0))
%80 = call i32 @printf(i8* getelementptr inbounds ([154 x i8], [154 x i8]* @.str.60, i64 0, i64 0))
%81 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%82 = call i32 @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.69, i64 0, i64 0))
%83 = 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.70 = [101 x i8] c" \22-f A\22: compute marginal ancestral states on a ROOTED reference tree provided with \22t\22\00"
@str.71 = [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.73 = [121 x i8] c" \22-f B\22: optimize br-len scaler and other model parameters (GTR, alpha, etc.) on a tree provided with \22-t\22.\00"
@str.74 = [144 x i8] c" The tree needs to contain branch lengths. The branch lengths will not be optimized, just scaled by a single common value.\00"
@str.75 = [75 x i8] c" \22-f c\22: check if the alignment can be properly read by RAxML\00"
@str.76 = [144 x i8] c" \22-f C\22: ancestral sequence test for Jiajie, users will also need to provide a list of taxon names via -Y separated by whitespaces\00"
@str.77 = [47 x i8] c" \22-f d\22: new rapid hill-climbing \00"
@str.78 = [34 x i8] c" DEFAULT: ON\00"
@str.79 = [63 x i8] c" \22-f D\22: rapid hill-climbing with RELL bootstraps\00"
@str.80 = [97 x i8] c" \22-f e\22: optimize model+branch lengths for given input tree under GAMMA/GAMMAI only\00"
@str.81 = [94 x i8] c" \22-f E\22: execute very fast experimental tree search, at present only for testing\00"
@str.82 = [89 x i8] c" \22-f F\22: execute fast experimental tree search, at present only for testing\00"
@str.83 = [89 x i8] c" \22-f g\22: compute per site log Likelihoods for one ore more trees passed via\00"
@str.84 = [79 x i8] c" \22-z\22 and write them to a file that can be read by CONSEL\00"
@str.86 = [89 x i8] c" \22-f G\22: compute per site log Likelihoods for one ore more trees passed via\00"
@str.87 = [80 x i8] c" \22-z\22 and write them to a file that can be read by CONSEL.\00"
@str.89 = [94 x i8] c" \22-f h\22: compute log likelihood test (SH-test) between best tree passed via \22-t\22\00"
@str.92 = [94 x i8] c" \22-f H\22: compute log likelihood test (SH-test) between best tree passed via \22-t\22\00"
@str.93 = [66 x i8] c" and a bunch of other trees passed via \22-z\22 \00"
@str.95 = [128 x i8] c" \22-f i\22: calculate IC and TC scores (Salichos and Rokas 2013) on a tree provided with \22-t\22 based on multiple trees\00"
@str.96 = [75 x i8] c" (e.g., from a bootstrap) in a file specified by \22-z\22\00"
@str.97 = [74 x i8] c" \22-f I\22: a simple tree rooting algorithm for unrooted trees.\00"
@str.98 = [107 x i8] c" It roots the tree by rooting it at the branch that best balances the subtree lengths\00"
@str.99 = [89 x i8] c" (sum over branches in the subtrees) of the left and right subtree.\00"
@str.100 = [78 x i8] c" A branch with an optimal balance does not always exist!\00"
@str.101 = [78 x i8] c" You need to specify the tree you want to root via \22-t\22.\00"
@str.102 = [104 x i8] c" \22-f j\22: generate a bunch of bootstrapped alignment files from an original alignemnt file.\00"
@str.103 = [99 x i8] c" You need to specify a seed with \22-b\22 and the number of replicates with \22-#\22 \00"
@str.104 = [86 x i8] c" \22-f J\22: Compute SH-like support values on a given tree passed via \22-t\22.\00"
@str.105 = [108 x i8] c" \22-f k\22: Predict missing sequence data in a partitioned multi-gene alignment for a given tree.\00"
@str.106 = [75 x i8] c" Only works in conjunction with \22-t\22, \22-M\22, and \22-q\22.\00"
@str.107 = [91 x i8] c" This option is in an early experimental state, use at your own risk!\00"
@str.108 = [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.109 = [108 x i8] c" respectively. This will return the Pearson correlation between all bipartitions found\00"
@str.110 = [102 x i8] c" in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName\00"
@str.111 = [106 x i8] c" will be printed that contains the pair-wise bipartition frequencies of the two sets\00"
@str.112 = [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.115 = [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.116 = [56 x i8] c" \22-z\22 under GAMMA or GAMMA+P-Invar\00"
@str.118 = [82 x i8] c" \22-f o\22: old and slower rapid hill-climbing without heuristic cutoff\00"
@str.119 = [113 x i8] c" \22-f p\22: perform pure stepwise MP addition of new sequences to an incomplete starting tree and exit\00"
@str.120 = [46 x i8] c" \22-f q\22: fast quartet calculator\00"
@str.121 = [129 x i8] c" \22-f r\22: compute pairwise Robinson-Foulds (RF) distances between all pairs of trees in a tree file passed via \22-z\22 \00"
@str.122 = [136 x i8] c" if the trees have node labales represented as integer support values the program will also compute two flavors of\00"
@str.123 = [66 x i8] c" the weighted Robinson-Foulds (WRF) distance\00"
@str.124 = [123 x i8] c" \22-f R\22: compute all pairwise Robinson-Foulds (RF) distances between a large reference tree passed via \22-t\22 \00"
@str.125 = [118 x i8] c" and many smaller trees (that must have a subset of the taxa of the large tree) passed via \22-z\22.\00"
@str.126 = [128 x i8] c" This option is intended for checking the plausibility of very large phylogenies that can not be inspected\00"
@str.127 = [41 x i8] c" visually any more.\00"
@str.128 = [101 x i8] c" \22-f s\22: split up a multi-gene partitioned alignment into the respective subalignments \00"
@str.129 = [135 x i8] c" \22-f S\22: compute site-specific placement bias using a leave one out test inspired by the evolutionary placement algorithm\00"
@str.130 = [77 x i8] c" \22-f t\22: do randomized tree searches on one fixed starting tree\00"
@str.131 = [112 x i8] c" \22-f T\22: do final thorough optimization of ML tree from rapid bootstrap search in stand-alone mode\00"
@str.132 = [123 x i8] c" \22-f u\22: execute morphological weight calibration using maximum likelihood, this will return a weight vector.\00"
@str.133 = [99 x i8] c" you need to provide a morphological alignment and a reference tree via \22-t\22 \00"
@str.134 = [119 x i8] c" \22-f v\22: classify a bunch of environmental sequences into a reference tree using thorough read insertions\00"
@str.136 = [119 x i8] c" \22-f V\22: classify a bunch of environmental sequences into a reference tree using thorough read insertions\00"
@str.138 = [126 x i8] c" WARNING: this is a test implementation for more efficient handling of multi-gene/whole-genome datasets!\00"
@str.139 = [76 x i8] c" \22-f w\22: compute ELW test on a bunch of trees passed via \22-z\22 \00"
@str.140 = [85 x i8] c" The model parameters will be estimated on the first tree only!\00"
@str.141 = [76 x i8] c" \22-f W\22: compute ELW test on a bunch of trees passed via \22-z\22 \00"
@str.142 = [78 x i8] c" The model parameters will be re-estimated for each tree\00"
@str.143 = [102 x i8] c" \22-f x\22: compute pair-wise ML distances, ML model parameters will be estimated on an MP \00"
@str.144 = [105 x i8] c" starting tree or a user-defined tree passed via \22-t\22, only allowed for GAMMA-based\00"
@str.145 = [51 x i8] c" models of rate heterogeneity\00"
@str.146 = [104 x i8] c" \22-f y\22: classify a bunch of environmental sequences into a reference tree using parsimony\00"
@str.147 = [153 x i8] c" you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)\00"
@str.148 = [56 x i8] c" DEFAULT for \22-f\22: 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 ([101 x i8], [101 x i8]* @str.70, i64 0, i64 0))
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.71, i64 0, i64 0))
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.96, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([121 x i8], [121 x i8]* @str.73, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([144 x i8], [144 x i8]* @str.74, i64 0, i64 0))
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.75, i64 0, i64 0))
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([144 x i8], [144 x i8]* @str.76, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.77, i64 0, i64 0))
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.78, i64 0, i64 0))
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.79, i64 0, i64 0))
%13 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @str.80, i64 0, i64 0))
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.81, i64 0, i64 0))
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.82, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.83, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.84, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([85 x i8], [85 x i8]* @str.140, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.86, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.87, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.142, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.89, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str.93, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([85 x i8], [85 x i8]* @str.140, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.92, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str.93, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.142, i64 0, i64 0))
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([128 x i8], [128 x i8]* @str.95, i64 0, i64 0))
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.96, i64 0, i64 0))
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.97, i64 0, i64 0))
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([107 x i8], [107 x i8]* @str.98, i64 0, i64 0))
%32 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.99, i64 0, i64 0))
%33 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.100, i64 0, i64 0))
%34 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.101, i64 0, i64 0))
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.102, i64 0, i64 0))
%36 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @str.103, i64 0, i64 0))
%37 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([86 x i8], [86 x i8]* @str.104, i64 0, i64 0))
%38 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.105, i64 0, i64 0))
%39 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.106, i64 0, i64 0))
%40 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.107, i64 0, i64 0))
%41 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([98 x i8], [98 x i8]* @str.108, i64 0, i64 0))
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.109, i64 0, i64 0))
%43 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str.110, i64 0, i64 0))
%44 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.111, i64 0, i64 0))
%45 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.112, i64 0, i64 0))
%46 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str.116, i64 0, i64 0))
%47 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([85 x i8], [85 x i8]* @str.140, i64 0, i64 0))
%48 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.115, i64 0, i64 0))
%49 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str.116, i64 0, i64 0))
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.142, i64 0, i64 0))
%51 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([82 x i8], [82 x i8]* @str.118, i64 0, i64 0))
%52 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([113 x i8], [113 x i8]* @str.119, i64 0, i64 0))
%53 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.120, i64 0, i64 0))
%54 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([129 x i8], [129 x i8]* @str.121, i64 0, i64 0))
%55 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([136 x i8], [136 x i8]* @str.122, i64 0, i64 0))
%56 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([66 x i8], [66 x i8]* @str.123, i64 0, i64 0))
%57 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([123 x i8], [123 x i8]* @str.124, i64 0, i64 0))
%58 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([118 x i8], [118 x i8]* @str.125, i64 0, i64 0))
%59 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([128 x i8], [128 x i8]* @str.126, i64 0, i64 0))
%60 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.127, i64 0, i64 0))
%61 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.128, i64 0, i64 0))
%62 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([135 x i8], [135 x i8]* @str.129, i64 0, i64 0))
%63 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([77 x i8], [77 x i8]* @str.130, i64 0, i64 0))
%64 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @str.131, i64 0, i64 0))
%65 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([123 x i8], [123 x i8]* @str.132, i64 0, i64 0))
%66 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @str.133, i64 0, i64 0))
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([119 x i8], [119 x i8]* @str.134, i64 0, i64 0))
%68 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([153 x i8], [153 x i8]* @str.147, i64 0, i64 0))
%69 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([119 x i8], [119 x i8]* @str.136, i64 0, i64 0))
%70 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([153 x i8], [153 x i8]* @str.147, i64 0, i64 0))
%71 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([126 x i8], [126 x i8]* @str.138, i64 0, i64 0))
%72 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.139, i64 0, i64 0))
%73 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([85 x i8], [85 x i8]* @str.140, i64 0, i64 0))
%74 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.141, i64 0, i64 0))
%75 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([78 x i8], [78 x i8]* @str.142, i64 0, i64 0))
%76 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str.143, i64 0, i64 0))
%77 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.144, i64 0, i64 0))
%78 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.145, i64 0, i64 0))
%79 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.146, i64 0, i64 0))
%80 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([153 x i8], [153 x i8]* @str.147, i64 0, i64 0))
%81 = tail call i32 @putchar(i32 10)
%82 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str.148, i64 0, i64 0))
%83 = tail call i32 @putchar(i32 10)
ret void
}