void printREADME(void) {
  printVersionInfo();
  printf("\n");
  printf("Please also consult the RAxML-manual\n");
  printf("To report bugs send an email to Alexandros.Stamatakis@epfl.ch\n\n\n");
  printf("raxmlHPC[-MPI|-PTHREADS] -s sequenceFileName -n outputFileName -m "
         "substitutionModel\n");
  printf("                         [-a weightFileName] [-b "
         "bootstrapRandomNumberSeed] [-c numberOfCategories]\n");
  printf("                         [-d] [-e likelihoodEpsilon] [-E "
         "excludeFileName] [-f a|b|c|d|e|g|h|i|j|m|n|o|p|s|t|w|x]\n");
  printf("                         [-g groupingFileName] [-h] [-i "
         "initialRearrangementSetting] [-j] [-k] \n");
  printf("                         [-l sequenceSimilarityThreshold] [-L "
         "sequenceSimilarityThreshold] [-M]\n");
  printf("                         [-o outGroupName1[,outGroupName2[,...]]] "
         "[-p parsimonyRandomSeed] [-P proteinModel]\n");
  printf("                         [-q multipleModelFileName] [-r "
         "binaryConstraintTree] [-t userStartingTree]\n");
  printf("                         [-T numberOfThreads] [-u "
         "multiBootstrapSearches] [-v][-w workingDirectory]\n");
  printf("                         [-x rapidBootstrapRandomNumberSeed][-y][-z "
         "multipleTreesFile] [-#|-N numberOfRuns]\n");
  printf("\n");
  printf("      -a      Specify a column weight file name to assign individual "
         "weights to each column of \n");
  printf("              the alignment. Those weights must be integers "
         "separated by any type and number \n");
  printf("              of whitespaces whithin a separate file, see file "
         "\"example_weights\" for an example.\n");
  printf("\n");
  printf("      -b      Specify an integer number (random seed) and turn on "
         "bootstrapping\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -c      Specify number of distinct rate catgories for RAxML "
         "when modelOfEvolution\n");
  printf("              is set to GTRCAT or GTRMIX\n");
  printf("              Individual per-site rates are categorized into "
         "numberOfCategories rate \n");
  printf("              categories to accelerate computations. \n");
  printf("\n");
  printf("              DEFAULT: 25\n");
  printf("\n");
  printf("      -d      start ML optimization from random starting tree \n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -e      set model optimization precision in log likelihood "
         "units for final\n");
  printf("              optimization of tree topology under MIX/MIXI or "
         "GAMMA/GAMMAI\n");
  printf("\n");
  printf("              DEFAULT: 0.1   for models not using proportion of "
         "invariant sites estimate\n");
  printf("                       0.001 for models using proportion of "
         "invariant sites estimate\n");
  printf("\n");
  printf("      -E      specify an exclude file name, that contains a "
         "specification of alignment positions you wish to exclude.\n");
  printf("              Format is similar to Nexus, the file shall contain "
         "entries like \"100-200 300-400\", to exclude a\n");
  printf("              single column write, e.g., \"100-100\", if you use a "
         "mixed model, an appropriatly adapted model file\n");
  printf("              will be written.\n");
  printf("\n");
  printf("      -f      select algorithm:\n");
  printMinusFUsage();
  printf("\n");
  printf("      -g      specify the file name of a multifurcating constraint "
         "tree\n");
  printf("              this tree does not need to be comprehensive, i.e. must "
         "not contain all taxa\n");
  printf("\n");
  printf("      -h      Display this help message.\n");
  printf("\n");
  printf("      -i      Initial rearrangement setting for the subsequent "
         "application of topological \n");
  printf("              changes phase\n");
  printf("\n");
  printf("              DEFAULT: determined by program\n");
  printf("\n");
  printf("      -j      Specifies if checkpoints will be written by the "
         "program. If checkpoints \n");
  printf("              (intermediate tree topologies) shall be written by the "
         "program specify \"-j\"\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -k      Specifies that bootstrapped trees should be printed "
         "with branch lengths.\n");
  printf("              The bootstraps will run a bit longer, because model "
         "parameters will be optimized\n");
  printf("              at the end of each run. Use with CATMIX/PROTMIX or "
         "GAMMA/GAMMAI.\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -l      Specify a threshold for sequence similarity "
         "clustering. RAxML will then print out an alignment\n");
  printf("              to a file called sequenceFileName.reducedBy.threshold "
         "that only contains sequences <= the\n");
  printf("              specified thresold that must be between  0.0 and 1.0. "
         "RAxML uses the QT-clustering algorithm \n");
  printf("              to perform this task. In addition, a file called "
         "RAxML_reducedList.outputFileName will be written\n");
  printf("              that contains clustering information.\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -L      Same functionality as \"-l\" above, but uses a less "
         "exhasutive and thus faster clustering algorithm\n");
  printf("              This is intended for very large datasets with more "
         "than 20,000-30,000 sequences\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -m      Model of Nucleotide or Amino Acid Substitution: \n");
  printf("\n");
  printf("              NUCLEOTIDES:\n\n");
  printf("                \"-m GTRCAT\"        : GTR + Optimization of "
         "substitution rates + Optimization of site-specific\n");
  printf("                                     evolutionary rates which are "
         "categorized into numberOfCategories distinct \n");
  printf("                                     rate categories for greater "
         "computational efficiency\n");
  printf("                                     if you do a multiple analysis "
         "with  \"-#\" or \"-N\" but without bootstrapping the program\n");
  printf("                                     will use GTRMIX instead\n");
  printf("                \"-m GTRGAMMA\"      : GTR + Optimization of "
         "substitution rates + GAMMA model of rate \n");
  printf("                                     heterogeneity (alpha parameter "
         "will be estimated)\n");
  printf("                \"-m GTRMIX\"        : Inference of the tree under "
         "GTRCAT\n");
  printf("                                     and thereafter evaluation of "
         "the final tree topology under GTRGAMMA\n");
  printf("                \"-m GTRCAT_GAMMA\"  : Inference of the tree with "
         "site-specific evolutionary rates.\n");
  printf("                                     However, here rates are "
         "categorized using the 4 discrete GAMMA rates.\n");
  printf("                                     Evaluation of the final tree "
         "topology under GTRGAMMA\n");
  printf("                \"-m GTRGAMMAI\"     : Same as GTRGAMMA, but with "
         "estimate of proportion of invariable sites \n");
  printf("                \"-m GTRMIXI\"       : Same as GTRMIX, but with "
         "estimate of proportion of invariable sites \n");
  printf("                \"-m GTRCAT_GAMMAI\" : Same as GTRCAT_GAMMA, but "
         "with estimate of proportion of invariable sites \n");
  printf("\n");
  printf("              AMINO ACIDS:\n\n");
  printf("                \"-m PROTCATmatrixName[F]\"        : specified AA "
         "matrix + Optimization of substitution rates + Optimization of "
         "site-specific\n");
  printf("                                                   evolutionary "
         "rates which are categorized into numberOfCategories distinct \n");
  printf("                                                   rate categories "
         "for greater computational efficiency\n");
  printf("                                                   if you do a "
         "multiple analysis with  \"-#\" or \"-N\" but without bootstrapping "
         "the program\n");
  printf("                                                   will use "
         "PROTMIX... instead\n");
  printf(
      "                \"-m PROTGAMMAmatrixName[F]\"      : specified AA "
      "matrix + Optimization of substitution rates + GAMMA model of rate \n");
  printf("                                                   heterogeneity "
         "(alpha parameter will be estimated)\n");
  printf("                \"-m PROTMIXmatrixName[F]\"        : Inference of "
         "the tree under specified AA matrix + CAT\n");
  printf("                                                   and thereafter "
         "evaluation of the final tree topology under specified AA matrix + "
         "GAMMA\n");
  printf(
      "                \"-m PROTCAT_GAMMAmatrixName[F]\"  : Inference of the "
      "tree under specified AA matrix and site-specific evolutionary rates.\n");
  printf("                                                   However, here "
         "rates are categorized using the 4 discrete GAMMA rates.\n");
  printf("                                                   Evaluation of the "
         "final tree topology under specified AA matrix + GAMMA\n");
  printf("                \"-m PROTGAMMAImatrixName[F]\"     : Same as "
         "PROTGAMMAmatrixName[F], but with estimate of proportion of "
         "invariable sites \n");
  printf("                \"-m PROTMIXImatrixName[F]\"       : Same as "
         "PROTMIXmatrixName[F], but with estimate of proportion of invariable "
         "sites \n");
  printf("                \"-m PROTCAT_GAMMAImatrixName[F]\" : Same as "
         "PROTCAT_GAMMAmatrixName[F], but with estimate of proportion of "
         "invariable sites \n");
  printf("\n");
  printf("                Available AA substitution models: DAYHOFF, DCMUT, "
         "JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR\n");
  printf("                With the optional \"F\" appendix you can specify if "
         "you want to use empirical base frequencies\n");
  printf("                Please not that for mixed models you can in addition "
         "specify the per-gene AA model in\n");
  printf("                the mixed model file (see manual for details)\n");
  printf("\n");
  printf(
      "      -M      Switch on estimation of individual per-partition branch "
      "lengths. Only has effect when used in combination with \"-q\"\n");
  printf("              Branch lengths for individual partitions will be "
         "printed to separate files\n");
  printf("              A weighted average of the branch lengths is computed "
         "by using the respective partition lengths\n");
  printf("\n"), printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -n      Specifies the name of the output file.\n");
  printf("\n");
  printf("      -o      Specify the name of a single outgrpoup or a "
         "comma-separated list of outgroups, eg \"-o Rat\" \n");
  printf("              or \"-o Rat,Mouse\", in case that multiple outgroups "
         "are not monophyletic the first name \n");
  printf("              in the list will be selected as outgroup, don't leave "
         "spaces between taxon names!\n");
  printf("\n");
  printf("      -q      Specify the file name which contains the assignment of "
         "models to alignment\n");
  printf("              partitions for multiple models of substitution. For "
         "the syntax of this file\n");
  printf("              please consult the manual.\n");
  printf("\n");
  printf("      -p      Specify a random number seed for the parsimony "
         "inferences. This allows you to reproduce your results\n");
  printf("              and will help me debug the program. This option HAS NO "
         "EFFECT in the parallel MPI version\n");
  printf("\n");
  printf("      -P      Specify the file name of a user-defined AA (Protein) "
         "substitution model. This file must contain\n");
  printf("              420 entries, the first 400 being the AA substitution "
         "rates (this must be a symmetric matrix) and the\n");
  printf("              last 20 are the empirical base frequencies\n");
  printf("\n");
  printf("      -r      Specify the file name of a binary constraint tree.\n");
  printf("              this tree does not need to be comprehensive, i.e. must "
         "not contain all taxa\n");
  printf("\n");
  printf("      -s      Specify the name of the alignment data file in PHYLIP "
         "format\n");
  printf("\n");
  printf("      -t      Specify a user starting tree file name in Newick "
         "format\n");
  printf("\n");
  printf("      -T      PTHREADS VERSION ONLY! Specify the number of threads "
         "you want to run.\n");
  printf("              Make sure to set \"-T\" to at most the number of CPUs "
         "you have on your machine,\n");
  printf(
      "              otherwise, there will be a huge performance decrease!\n");
  printf("\n");
  printf("      -u      Specify the number of multiple BS searches per "
         "replicate\n");
  printf("              to obtain better ML trees for each replicate\n");
  printf("\n");
  printf("              DEFAULT: One ML search per BS replicate\n");
  printf("\n");
  printf("      -v      Display version information\n");
  printf("\n");
  printf("      -w      Name of the working directory where RAxML will write "
         "its output files\n");
  printf("\n");
  printf("              DEFAULT: current directory\n");
  printf("\n");
  printf("      -x      Specify an integer number (random seed) and turn on "
         "rapid bootstrapping\n");
  printf("\n");
  printf("      -y      If you want to only compute a parsimony starting tree "
         "with RAxML specify \"-y\",\n");
  printf("              the program will exit after computation of the "
         "starting tree\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -z      Specify the file name of a file containing multiple "
         "trees e.g. from a bootstrap\n");
  printf("              that shall be used to draw bipartition values onto a "
         "tree provided with \"-t\",\n");
  printf("              It can also be used to compute per site log "
         "likelihoods in combination with \"-f g\"\n");
  printf("              and to read a bunch of trees for a couple of other "
         "options (\"-f h\", \"-f m\", \"-f n\").\n");
  printf("\n");
  printf("      -#|-N   Specify the number of alternative runs on distinct "
         "starting trees\n");
  printf("              In combination with the \"-b\" option, this will "
         "invoke a multiple boostrap analysis\n");
  printf("              Note that \"-N\" has been added as an alternative "
         "since \"-#\" sometimes caused problems\n");
  printf("              with certain MPI job submission systems, since \"-#\" "
         "is often used to start comments\n");
  printf("\n");
  printf("              DEFAULT: 1 single analysis\n");
  printf("\n\n\n\n");
}


x86 assembly (clang, -O0):
<printREADME>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1050 <printVersionInfo@plt>
lea    0x3892(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeb0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xec8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xefb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf42(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf99(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xffd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1050(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10a3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1103(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x115a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x11b1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x37ea(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1202(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1255(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x12a6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x37b2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x12ec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3796(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1321(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x377a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1321(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x136c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1388(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13d1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3734(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13ec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3718(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13eb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x36fc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1287(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x36e0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13f3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1437(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x36b6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1467(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x14b3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x368c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x14ed(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1556(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x15b7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x161b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3646(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x161f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <printMinusFUsage@plt>
lea    0x3623(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x161d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1658(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x35f9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1697(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x35dd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16a5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16f3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x35b3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16f4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3597(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1706(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1750(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x356d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10f8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3551(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1773(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x17bd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x180f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3519(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10a4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x34fd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1827(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1887(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x18e2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1941(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x19a4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x34a9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1034(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x348d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x19a1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a04(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3463(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfee(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3447(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a2b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x342b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a4f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a5e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1ed5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1f46(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1fa1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a95(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1ac5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x20d6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1b0f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1b4a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1ba6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2283(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1bed(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c3a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c99(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1cf6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x333d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d4b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d5a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1dd9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1e4a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1ea5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1f22(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1f64(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1fda(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2032(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x208e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x210b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2187(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x21f3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2261(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x22dc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2355(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x324f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x23c6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2437(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2497(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x24f0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3209(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2513(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2588(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x25d4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x31d1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xd5c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x31b5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x260a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3199(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2624(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2681(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x26da(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3161(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x271f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x276b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x27b8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3129(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x27c6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x282c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x30ff(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2879(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x28da(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2940(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x30c7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x295e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10fc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x309d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2976(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3081(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x29a6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3065(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x29d1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2a18(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2a67(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x302d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2a90(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2aca(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x3003(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2aea(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2fe7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2b05(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2fcb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2b14(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2faf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2b4d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2f93(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2b5b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2f77(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2b96(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2be6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2f4d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xad8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2f31(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2bfa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2c4b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2c9a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2cee(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2eeb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2d36(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2d79(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2dcd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2e23(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2ea5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2e6a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2e86(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
pop    %rbp
ret

x86 assembly (clang, -O2):
<printREADME>:
push   %r14
push   %rbx
push   %rax
xor    %eax,%eax
call   1060 <printVersionInfo@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xea4(%rip),%rdi
call   1040 <puts@plt>
lea    0xebd(%rip),%rdi
call   1040 <puts@plt>
lea    0xef1(%rip),%rdi
call   1040 <puts@plt>
lea    0xf39(%rip),%rdi
call   1040 <puts@plt>
lea    0xf91(%rip),%rdi
call   1040 <puts@plt>
lea    0xff6(%rip),%rdi
call   1040 <puts@plt>
lea    0x104a(%rip),%rdi
call   1040 <puts@plt>
lea    0x109e(%rip),%rdi
call   1040 <puts@plt>
lea    0x10ff(%rip),%rdi
call   1040 <puts@plt>
lea    0x1157(%rip),%rdi
call   1040 <puts@plt>
lea    0x11af(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1205(%rip),%rdi
call   1040 <puts@plt>
lea    0x1259(%rip),%rdi
call   1040 <puts@plt>
lea    0x12ab(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x12f6(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x33f3(%rip),%rbx
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1317(%rip),%rdi
call   1040 <puts@plt>
lea    0x1363(%rip),%rdi
call   1040 <puts@plt>
lea    0x1380(%rip),%rdi
call   1040 <puts@plt>
lea    0x13ca(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x13ea(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x13ee(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1405(%rip),%rdi
call   1040 <puts@plt>
lea    0x144a(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x147f(%rip),%rdi
call   1040 <puts@plt>
lea    0x14cc(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x150b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1575(%rip),%rdi
call   1040 <puts@plt>
lea    0x15d7(%rip),%rdi
call   1040 <puts@plt>
lea    0x163c(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1645(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1050 <printMinusFUsage@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1648(%rip),%rdi
call   1040 <puts@plt>
lea    0x2e7f(%rip),%r14
mov    %r14,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x166b(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x167e(%rip),%rdi
call   1040 <puts@plt>
lea    0x16cd(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x16d3(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x16ea(%rip),%rdi
call   1040 <puts@plt>
lea    0x1735(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1767(%rip),%rdi
call   1040 <puts@plt>
lea    0x17b2(%rip),%rdi
call   1040 <puts@plt>
lea    0x1805(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x182c(%rip),%rdi
call   1040 <puts@plt>
lea    0x188d(%rip),%rdi
call   1040 <puts@plt>
lea    0x18e9(%rip),%rdi
call   1040 <puts@plt>
lea    0x1949(%rip),%rdi
call   1040 <puts@plt>
lea    0x19ad(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x19b9(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a1d(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1a53(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1a7c(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a8c(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ef9(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f6b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1fc7(%rip),%rdi
call   1040 <puts@plt>
lea    0x1aca(%rip),%rdi
call   1040 <puts@plt>
lea    0x1afb(%rip),%rdi
call   1040 <puts@plt>
lea    0x20ff(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b48(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b84(%rip),%rdi
call   1040 <puts@plt>
lea    0x1be1(%rip),%rdi
call   1040 <puts@plt>
lea    0x22b0(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c2b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c79(%rip),%rdi
call   1040 <puts@plt>
lea    0x1cd9(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d37(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1d91(%rip),%rdi
call   1040 <puts@plt>
lea    0x1da1(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e21(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e93(%rip),%rdi
call   1040 <puts@plt>
lea    0x1eef(%rip),%rdi
call   1040 <puts@plt>
lea    0x1f6d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1fb0(%rip),%rdi
call   1040 <puts@plt>
lea    0x2027(%rip),%rdi
call   1040 <puts@plt>
lea    0x2080(%rip),%rdi
call   1040 <puts@plt>
lea    0x20dd(%rip),%rdi
call   1040 <puts@plt>
lea    0x215b(%rip),%rdi
call   1040 <puts@plt>
lea    0x21d8(%rip),%rdi
call   1040 <puts@plt>
lea    0x2245(%rip),%rdi
call   1040 <puts@plt>
lea    0x22b4(%rip),%rdi
call   1040 <puts@plt>
lea    0x2330(%rip),%rdi
call   1040 <puts@plt>
lea    0x23aa(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2420(%rip),%rdi
call   1040 <puts@plt>
lea    0x2492(%rip),%rdi
call   1040 <puts@plt>
lea    0x24f3(%rip),%rdi
call   1040 <puts@plt>
lea    0x254d(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2575(%rip),%rdi
call   1040 <puts@plt>
lea    0x25eb(%rip),%rdi
call   1040 <puts@plt>
lea    0x2638(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x267d(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x269c(%rip),%rdi
call   1040 <puts@plt>
lea    0x26fa(%rip),%rdi
call   1040 <puts@plt>
lea    0x2754(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x279e(%rip),%rdi
call   1040 <puts@plt>
lea    0x27eb(%rip),%rdi
call   1040 <puts@plt>
lea    0x2839(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x284c(%rip),%rdi
call   1040 <puts@plt>
lea    0x28b3(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2905(%rip),%rdi
call   1040 <puts@plt>
lea    0x2967(%rip),%rdi
call   1040 <puts@plt>
lea    0x29ce(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x29f1(%rip),%rdi
call   1040 <puts@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2a6e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2aa3(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2ad3(%rip),%rdi
call   1040 <puts@plt>
lea    0x2b1b(%rip),%rdi
call   1040 <puts@plt>
lea    0x2b6b(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2b99(%rip),%rdi
call   1040 <puts@plt>
lea    0x2bd4(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2bf9(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2c19(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2c2d(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2c6b(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2c7e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2cbe(%rip),%rdi
call   1040 <puts@plt>
lea    0x2d0f(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2d4d(%rip),%rdi
call   1040 <puts@plt>
lea    0x2d9f(%rip),%rdi
call   1040 <puts@plt>
lea    0x2def(%rip),%rdi
call   1040 <puts@plt>
lea    0x2e44(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2e91(%rip),%rdi
call   1040 <puts@plt>
lea    0x2ed5(%rip),%rdi
call   1040 <puts@plt>
lea    0x2f2a(%rip),%rdi
call   1040 <puts@plt>
lea    0x2f81(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2fcd(%rip),%rdi
call   1040 <puts@plt>
lea    0x2fea(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1040 <puts@plt>

LLVM IR (-O0):
@.str = [2 x i8] c"\0A\00"
@.str.1 = [38 x i8] c"Please also consult the RAxML-manual\0A\00"
@.str.2 = [65 x i8] c"To report bugs send an email to Alexandros.Stamatakis@epfl.ch\0A\0A\0A\00"
@.str.3 = [85 x i8] c"raxmlHPC[-MPI|-PTHREADS] -s sequenceFileName -n outputFileName -m substitutionModel\0A\00"
@.str.4 = [101 x i8] c" [-a weightFileName] [-b bootstrapRandomNumberSeed] [-c numberOfCategories]\0A\00"
@.str.5 = [114 x i8] c" [-d] [-e likelihoodEpsilon] [-E excludeFileName] [-f a|b|c|d|e|g|h|i|j|m|n|o|p|s|t|w|x]\0A\00"
@.str.6 = [97 x i8] c" [-g groupingFileName] [-h] [-i initialRearrangementSetting] [-j] [-k] \0A\00"
@.str.7 = [97 x i8] c" [-l sequenceSimilarityThreshold] [-L sequenceSimilarityThreshold] [-M]\0A\00"
@.str.8 = [110 x i8] c" [-o outGroupName1[,outGroupName2[,...]]] [-p parsimonyRandomSeed] [-P proteinModel]\0A\00"
@.str.9 = [101 x i8] c" [-q multipleModelFileName] [-r binaryConstraintTree] [-t userStartingTree]\0A\00"
@.str.10 = [101 x i8] c" [-T numberOfThreads] [-u multiBootstrapSearches] [-v][-w workingDirectory]\0A\00"
@.str.11 = [109 x i8] c" [-x rapidBootstrapRandomNumberSeed][-y][-z multipleTreesFile] [-#|-N numberOfRuns]\0A\00"
@.str.12 = [97 x i8] c" -a Specify a column weight file name to assign individual weights to each column of \0A\00"
@.str.13 = [95 x i8] c" the alignment. Those weights must be integers separated by any type and number \0A\00"
@.str.14 = [98 x i8] c" of whitespaces whithin a separate file, see file \22example_weights\22 for an example.\0A\00"
@.str.15 = [81 x i8] c" -b Specify an integer number (random seed) and turn on bootstrapping\0A\00"
@.str.16 = [28 x i8] c" DEFAULT: OFF\0A\00"
@.str.17 = [89 x i8] c" -c Specify number of distinct rate catgories for RAxML when modelOfEvolution\0A\00"
@.str.18 = [42 x i8] c" is set to GTRCAT or GTRMIX\0A\00"
@.str.19 = [87 x i8] c" Individual per-site rates are categorized into numberOfCategories rate \0A\00"
@.str.20 = [55 x i8] c" categories to accelerate computations. \0A\00"
@.str.21 = [27 x i8] c" DEFAULT: 25\0A\00"
@.str.22 = [64 x i8] c" -d start ML optimization from random starting tree \0A\00"
@.str.23 = [82 x i8] c" -e set model optimization precision in log likelihood units for final\0A\00"
@.str.24 = [76 x i8] c" optimization of tree topology under MIX/MIXI or GAMMA/GAMMAI\0A\00"
@.str.25 = [90 x i8] c" DEFAULT: 0.1 for models not using proportion of invariant sites estimate\0A\00"
@.str.26 = [86 x i8] c" 0.001 for models using proportion of invariant sites estimate\0A\00"
@.str.27 = [119 x i8] c" -E specify an exclude file name, that contains a specification of alignment positions you wish to exclude.\0A\00"
@.str.28 = [111 x i8] c" Format is similar to Nexus, the file shall contain entries like \22100-200 300-400\22, to exclude a\0A\00"
@.str.29 = [114 x i8] c" single column write, e.g., \22100-100\22, if you use a mixed model, an appropriatly adapted model file\0A\00"
@.str.30 = [32 x i8] c" will be written.\0A\00"
@.str.31 = [33 x i8] c" -f select algorithm:\0A\00"
@.str.32 = [73 x i8] c" -g specify the file name of a multifurcating constraint tree\0A\00"
@.str.33 = [91 x i8] c" this tree does not need to be comprehensive, i.e. must not contain all taxa\0A\00"
@.str.34 = [42 x i8] c" -h Display this help message.\0A\00"
@.str.35 = [92 x i8] c" -i Initial rearrangement setting for the subsequent application of topological \0A\00"
@.str.36 = [29 x i8] c" changes phase\0A\00"
@.str.37 = [46 x i8] c" DEFAULT: determined by program\0A\00"
@.str.38 = [88 x i8] c" -j Specifies if checkpoints will be written by the program. If checkpoints \0A\00"
@.str.39 = [91 x i8] c" (intermediate tree topologies) shall be written by the program specify \22-j\22\0A\00"
@.str.40 = [88 x i8] c" -k Specifies that bootstrapped trees should be printed with branch lengths.\0A\00"
@.str.41 = [96 x i8] c" The bootstraps will run a bit longer, because model parameters will be optimized\0A\00"
@.str.42 = [80 x i8] c" at the end of each run. Use with CATMIX/PROTMIX or GAMMA/GAMMAI.\0A\00"
@.str.43 = [110 x i8] c" -l Specify a threshold for sequence similarity clustering. RAxML will then print out an alignment\0A\00"
@.str.44 = [105 x i8] c" to a file called sequenceFileName.reducedBy.threshold that only contains sequences <= the\0A\00"
@.str.45 = [109 x i8] c" specified thresold that must be between 0.0 and 1.0. RAxML uses the QT-clustering algorithm \0A\00"
@.str.46 = [113 x i8] c" to perform this task. In addition, a file called RAxML_reducedList.outputFileName will be written\0A\00"
@.str.47 = [53 x i8] c" that contains clustering information.\0A\00"
@.str.48 = [113 x i8] c" -L Same functionality as \22-l\22 above, but uses a less exhasutive and thus faster clustering algorithm\0A\00"
@.str.49 = [95 x i8] c" This is intended for very large datasets with more than 20,000-30,000 sequences\0A\00"
@.str.50 = [64 x i8] c" -m Model of Nucleotide or Amino Acid Substitution: \0A\00"
@.str.51 = [29 x i8] c" NUCLEOTIDES:\0A\0A\00"
@.str.52 = [111 x i8] c" \22-m GTRCAT\22 : GTR + Optimization of substitution rates + Optimization of site-specific\0A\00"
@.str.53 = [113 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \0A\00"
@.str.54 = [91 x i8] c" rate categories for greater computational efficiency\0A\00"
@.str.55 = [125 x i8] c" if you do a multiple analysis with \22-#\22 or \22-N\22 but without bootstrapping the program\0A\00"
@.str.56 = [62 x i8] c" will use GTRMIX instead\0A\00"
@.str.57 = [102 x i8] c" \22-m GTRGAMMA\22 : GTR + Optimization of substitution rates + GAMMA model of rate \0A\00"
@.str.58 = [88 x i8] c" heterogeneity (alpha parameter will be estimated)\0A\00"
@.str.59 = [73 x i8] c" \22-m GTRMIX\22 : Inference of the tree under GTRCAT\0A\00"
@.str.60 = [106 x i8] c" and thereafter evaluation of the final tree topology under GTRGAMMA\0A\00"
@.str.61 = [99 x i8] c" \22-m GTRCAT_GAMMA\22 : Inference of the tree with site-specific evolutionary rates.\0A\00"
@.str.62 = [108 x i8] c" However, here rates are categorized using the 4 discrete GAMMA rates.\0A\00"
@.str.63 = [91 x i8] c" Evaluation of the final tree topology under GTRGAMMA\0A\00"
@.str.64 = [109 x i8] c" \22-m GTRGAMMAI\22 : Same as GTRGAMMA, but with estimate of proportion of invariable sites \0A\00"
@.str.65 = [107 x i8] c" \22-m GTRMIXI\22 : Same as GTRMIX, but with estimate of proportion of invariable sites \0A\00"
@.str.66 = [113 x i8] c" \22-m GTRCAT_GAMMAI\22 : Same as GTRCAT_GAMMA, but with estimate of proportion of invariable sites \0A\00"
@.str.67 = [29 x i8] c" AMINO ACIDS:\0A\0A\00"
@.str.68 = [141 x i8] c" \22-m PROTCATmatrixName[F]\22 : specified AA matrix + Optimization of substitution rates + Optimization of site-specific\0A\00"
@.str.69 = [127 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \0A\00"
@.str.70 = [105 x i8] c" rate categories for greater computational efficiency\0A\00"
@.str.71 = [139 x i8] c" if you do a multiple analysis with \22-#\22 or \22-N\22 but without bootstrapping the program\0A\00"
@.str.72 = [80 x i8] c" will use PROTMIX... instead\0A\00"
@.str.73 = [132 x i8] c" \22-m PROTGAMMAmatrixName[F]\22 : specified AA matrix + Optimization of substitution rates + GAMMA model of rate \0A\00"
@.str.74 = [102 x i8] c" heterogeneity (alpha parameter will be estimated)\0A\00"
@.str.75 = [106 x i8] c" \22-m PROTMIXmatrixName[F]\22 : Inference of the tree under specified AA matrix + CAT\0A\00"
@.str.76 = [139 x i8] c" and thereafter evaluation of the final tree topology under specified AA matrix + GAMMA\0A\00"
@.str.77 = [138 x i8] c" \22-m PROTCAT_GAMMAmatrixName[F]\22 : Inference of the tree under specified AA matrix and site-specific evolutionary rates.\0A\00"
@.str.78 = [122 x i8] c" However, here rates are categorized using the 4 discrete GAMMA rates.\0A\00"
@.str.79 = [124 x i8] c" Evaluation of the final tree topology under specified AA matrix + GAMMA\0A\00"
@.str.80 = [137 x i8] c" \22-m PROTGAMMAImatrixName[F]\22 : Same as PROTGAMMAmatrixName[F], but with estimate of proportion of invariable sites \0A\00"
@.str.81 = [135 x i8] c" \22-m PROTMIXImatrixName[F]\22 : Same as PROTMIXmatrixName[F], but with estimate of proportion of invariable sites \0A\00"
@.str.82 = [141 x i8] c" \22-m PROTCAT_GAMMAImatrixName[F]\22 : Same as PROTCAT_GAMMAmatrixName[F], but with estimate of proportion of invariable sites \0A\00"
@.str.83 = [127 x i8] c" Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR\0A\00"
@.str.84 = [110 x i8] c" With the optional \22F\22 appendix you can specify if you want to use empirical base frequencies\0A\00"
@.str.85 = [103 x i8] c" Please not that for mixed models you can in addition specify the per-gene AA model in\0A\00"
@.str.86 = [63 x i8] c" the mixed model file (see manual for details)\0A\00"
@.str.87 = [131 x i8] c" -M Switch on estimation of individual per-partition branch lengths. Only has effect when used in combination with \22-q\22\0A\00"
@.str.88 = [90 x i8] c" Branch lengths for individual partitions will be printed to separate files\0A\00"
@.str.89 = [110 x i8] c" A weighted average of the branch lengths is computed by using the respective partition lengths\0A\00"
@.str.90 = [54 x i8] c" -n Specifies the name of the output file.\0A\00"
@.str.91 = [107 x i8] c" -o Specify the name of a single outgrpoup or a comma-separated list of outgroups, eg \22-o Rat\22 \0A\00"
@.str.92 = [103 x i8] c" or \22-o Rat,Mouse\22, in case that multiple outgroups are not monophyletic the first name \0A\00"
@.str.93 = [97 x i8] c" in the list will be selected as outgroup, don't leave spaces between taxon names!\0A\00"
@.str.94 = [90 x i8] c" -q Specify the file name which contains the assignment of models to alignment\0A\00"
@.str.95 = [91 x i8] c" partitions for multiple models of substitution. For the syntax of this file\0A\00"
@.str.96 = [42 x i8] c" please consult the manual.\0A\00"
@.str.97 = [116 x i8] c" -p Specify a random number seed for the parsimony inferences. This allows you to reproduce your results\0A\00"
@.str.98 = [105 x i8] c" and will help me debug the program. This option HAS NO EFFECT in the parallel MPI version\0A\00"
@.str.99 = [111 x i8] c" -P Specify the file name of a user-defined AA (Protein) substitution model. This file must contain\0A\00"
@.str.100 = [116 x i8] c" 420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the\0A\00"
@.str.101 = [58 x i8] c" last 20 are the empirical base frequencies\0A\00"
@.str.102 = [66 x i8] c" -r Specify the file name of a binary constraint tree.\0A\00"
@.str.103 = [76 x i8] c" -s Specify the name of the alignment data file in PHYLIP format\0A\00"
@.str.104 = [71 x i8] c" -t Specify a user starting tree file name in Newick format\0A\00"
@.str.105 = [85 x i8] c" -T PTHREADS VERSION ONLY! Specify the number of threads you want to run.\0A\00"
@.str.106 = [93 x i8] c" Make sure to set \22-T\22 to at most the number of CPUs you have on your machine,\0A\00"
@.str.107 = [69 x i8] c" otherwise, there will be a huge performance decrease!\0A\00"
@.str.108 = [72 x i8] c" -u Specify the number of multiple BS searches per replicate\0A\00"
@.str.109 = [60 x i8] c" to obtain better ML trees for each replicate\0A\00"
@.str.110 = [55 x i8] c" DEFAULT: One ML search per BS replicate\0A\00"
@.str.111 = [43 x i8] c" -v Display version information\0A\00"
@.str.112 = [85 x i8] c" -w Name of the working directory where RAxML will write its output files\0A\00"
@.str.113 = [42 x i8] c" DEFAULT: current directory\0A\00"
@.str.114 = [87 x i8] c" -x Specify an integer number (random seed) and turn on rapid bootstrapping\0A\00"
@.str.115 = [94 x i8] c" -y If you want to only compute a parsimony starting tree with RAxML specify \22-y\22,\0A\00"
@.str.116 = [76 x i8] c" the program will exit after computation of the starting tree\0A\00"
@.str.117 = [95 x i8] c" -z Specify the file name of a file containing multiple trees e.g. from a bootstrap\0A\00"
@.str.118 = [93 x i8] c" that shall be used to draw bipartition values onto a tree provided with \22-t\22,\0A\00"
@.str.119 = [98 x i8] c" It can also be used to compute per site log likelihoods in combination with \22-f g\22\0A\00"
@.str.120 = [100 x i8] c" and to read a bunch of trees for a couple of other options (\22-f h\22, \22-f m\22, \22-f n\22).\0A\00"
@.str.121 = [81 x i8] c" -#|-N Specify the number of alternative runs on distinct starting trees\0A\00"
@.str.122 = [98 x i8] c" In combination with the \22-b\22 option, this will invoke a multiple boostrap analysis\0A\00"
@.str.123 = [100 x i8] c" Note that \22-N\22 has been added as an alternative since \22-#\22 sometimes caused problems\0A\00"
@.str.124 = [99 x i8] c" with certain MPI job submission systems, since \22-#\22 is often used to start comments\0A\00"
@.str.125 = [42 x i8] c" DEFAULT: 1 single analysis\0A\00"
@.str.126 = [5 x i8] c"\0A\0A\0A\0A\00"
define void @printREADME() {
%1 = call i32 (...) @printVersionInfo()
%2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.1, i64 0, i64 0))
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.2, i64 0, i64 0))
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.3, i64 0, i64 0))
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([101 x i8], [101 x i8]* @.str.4, i64 0, i64 0))
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([114 x i8], [114 x i8]* @.str.5, i64 0, i64 0))
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.6, i64 0, i64 0))
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.7, i64 0, i64 0))
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([110 x i8], [110 x i8]* @.str.8, i64 0, i64 0))
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([101 x i8], [101 x i8]* @.str.9, i64 0, i64 0))
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([101 x i8], [101 x i8]* @.str.10, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.11, i64 0, i64 0))
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.12, i64 0, i64 0))
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.13, i64 0, i64 0))
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.14, i64 0, i64 0))
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.15, i64 0, i64 0))
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([89 x i8], [89 x i8]* @.str.17, i64 0, i64 0))
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.18, i64 0, i64 0))
%25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.19, i64 0, i64 0))
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.20, i64 0, i64 0))
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.21, i64 0, i64 0))
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.22, i64 0, i64 0))
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.23, i64 0, i64 0))
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.24, i64 0, i64 0))
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.25, i64 0, i64 0))
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.str.26, i64 0, i64 0))
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([119 x i8], [119 x i8]* @.str.27, i64 0, i64 0))
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.28, i64 0, i64 0))
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([114 x i8], [114 x i8]* @.str.29, i64 0, i64 0))
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.30, i64 0, i64 0))
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.31, i64 0, i64 0))
%46 = call i32 (...) @printMinusFUsage()
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.32, i64 0, i64 0))
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.33, i64 0, i64 0))
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.34, i64 0, i64 0))
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.35, i64 0, i64 0))
%54 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.36, i64 0, i64 0))
%55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.37, i64 0, i64 0))
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.38, i64 0, i64 0))
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.39, i64 0, i64 0))
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.40, i64 0, i64 0))
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([96 x i8], [96 x i8]* @.str.41, i64 0, i64 0))
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.42, i64 0, i64 0))
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%68 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([110 x i8], [110 x i8]* @.str.43, i64 0, i64 0))
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.44, i64 0, i64 0))
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.45, i64 0, i64 0))
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.46, i64 0, i64 0))
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.47, i64 0, i64 0))
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.48, i64 0, i64 0))
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.49, i64 0, i64 0))
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%80 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.50, i64 0, i64 0))
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.51, i64 0, i64 0))
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.52, i64 0, i64 0))
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.53, i64 0, i64 0))
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.54, i64 0, i64 0))
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([125 x i8], [125 x i8]* @.str.55, i64 0, i64 0))
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.56, i64 0, i64 0))
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.57, i64 0, i64 0))
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([88 x i8], [88 x i8]* @.str.58, i64 0, i64 0))
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.59, i64 0, i64 0))
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.60, i64 0, i64 0))
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.61, i64 0, i64 0))
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([108 x i8], [108 x i8]* @.str.62, i64 0, i64 0))
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.63, i64 0, i64 0))
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([109 x i8], [109 x i8]* @.str.64, i64 0, i64 0))
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.65, i64 0, i64 0))
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([113 x i8], [113 x i8]* @.str.66, i64 0, i64 0))
%100 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.67, i64 0, i64 0))
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([141 x i8], [141 x i8]* @.str.68, i64 0, i64 0))
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([127 x i8], [127 x i8]* @.str.69, i64 0, i64 0))
%104 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.70, i64 0, i64 0))
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([139 x i8], [139 x i8]* @.str.71, i64 0, i64 0))
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.72, i64 0, i64 0))
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str.73, i64 0, i64 0))
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.74, i64 0, i64 0))
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([106 x i8], [106 x i8]* @.str.75, i64 0, i64 0))
%110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([139 x i8], [139 x i8]* @.str.76, i64 0, i64 0))
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([138 x i8], [138 x i8]* @.str.77, i64 0, i64 0))
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([122 x i8], [122 x i8]* @.str.78, i64 0, i64 0))
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([124 x i8], [124 x i8]* @.str.79, i64 0, i64 0))
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([137 x i8], [137 x i8]* @.str.80, i64 0, i64 0))
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([135 x i8], [135 x i8]* @.str.81, i64 0, i64 0))
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([141 x i8], [141 x i8]* @.str.82, i64 0, i64 0))
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([127 x i8], [127 x i8]* @.str.83, i64 0, i64 0))
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([110 x i8], [110 x i8]* @.str.84, i64 0, i64 0))
%120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.85, i64 0, i64 0))
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.86, i64 0, i64 0))
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%123 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([131 x i8], [131 x i8]* @.str.87, i64 0, i64 0))
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.88, i64 0, i64 0))
%125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([110 x i8], [110 x i8]* @.str.89, i64 0, i64 0))
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%128 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.90, i64 0, i64 0))
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%131 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.91, i64 0, i64 0))
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.92, i64 0, i64 0))
%133 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.93, i64 0, i64 0))
%134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.94, i64 0, i64 0))
%136 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.95, i64 0, i64 0))
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.96, i64 0, i64 0))
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%139 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([116 x i8], [116 x i8]* @.str.97, i64 0, i64 0))
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.98, i64 0, i64 0))
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.99, i64 0, i64 0))
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([116 x i8], [116 x i8]* @.str.100, i64 0, i64 0))
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.101, i64 0, i64 0))
%145 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.102, i64 0, i64 0))
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.33, i64 0, i64 0))
%148 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.103, i64 0, i64 0))
%150 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.104, i64 0, i64 0))
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.105, i64 0, i64 0))
%154 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.106, i64 0, i64 0))
%155 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.107, i64 0, i64 0))
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.108, i64 0, i64 0))
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.109, i64 0, i64 0))
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.110, i64 0, i64 0))
%161 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%162 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.111, i64 0, i64 0))
%163 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%164 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.112, i64 0, i64 0))
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%166 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.113, i64 0, i64 0))
%167 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.114, i64 0, i64 0))
%169 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%170 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.115, i64 0, i64 0))
%171 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.116, i64 0, i64 0))
%172 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.16, i64 0, i64 0))
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%175 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.117, i64 0, i64 0))
%176 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.118, i64 0, i64 0))
%177 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.119, i64 0, i64 0))
%178 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.120, i64 0, i64 0))
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%180 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.121, i64 0, i64 0))
%181 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([98 x i8], [98 x i8]* @.str.122, i64 0, i64 0))
%182 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([100 x i8], [100 x i8]* @.str.123, i64 0, i64 0))
%183 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.124, i64 0, i64 0))
%184 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%185 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.125, i64 0, i64 0))
%186 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.126, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@str = [37 x i8] c"Please also consult the RAxML-manual\00"
@str.127 = [64 x i8] c"To report bugs send an email to Alexandros.Stamatakis@epfl.ch\0A\0A\00"
@str.128 = [84 x i8] c"raxmlHPC[-MPI|-PTHREADS] -s sequenceFileName -n outputFileName -m substitutionModel\00"
@str.129 = [100 x i8] c" [-a weightFileName] [-b bootstrapRandomNumberSeed] [-c numberOfCategories]\00"
@str.130 = [113 x i8] c" [-d] [-e likelihoodEpsilon] [-E excludeFileName] [-f a|b|c|d|e|g|h|i|j|m|n|o|p|s|t|w|x]\00"
@str.131 = [96 x i8] c" [-g groupingFileName] [-h] [-i initialRearrangementSetting] [-j] [-k] \00"
@str.132 = [96 x i8] c" [-l sequenceSimilarityThreshold] [-L sequenceSimilarityThreshold] [-M]\00"
@str.133 = [109 x i8] c" [-o outGroupName1[,outGroupName2[,...]]] [-p parsimonyRandomSeed] [-P proteinModel]\00"
@str.134 = [100 x i8] c" [-q multipleModelFileName] [-r binaryConstraintTree] [-t userStartingTree]\00"
@str.135 = [100 x i8] c" [-T numberOfThreads] [-u multiBootstrapSearches] [-v][-w workingDirectory]\00"
@str.136 = [108 x i8] c" [-x rapidBootstrapRandomNumberSeed][-y][-z multipleTreesFile] [-#|-N numberOfRuns]\00"
@str.137 = [96 x i8] c" -a Specify a column weight file name to assign individual weights to each column of \00"
@str.138 = [94 x i8] c" the alignment. Those weights must be integers separated by any type and number \00"
@str.139 = [97 x i8] c" of whitespaces whithin a separate file, see file \22example_weights\22 for an example.\00"
@str.140 = [80 x i8] c" -b Specify an integer number (random seed) and turn on bootstrapping\00"
@str.142 = [88 x i8] c" -c Specify number of distinct rate catgories for RAxML when modelOfEvolution\00"
@str.143 = [41 x i8] c" is set to GTRCAT or GTRMIX\00"
@str.144 = [86 x i8] c" Individual per-site rates are categorized into numberOfCategories rate \00"
@str.145 = [54 x i8] c" categories to accelerate computations. \00"
@str.146 = [26 x i8] c" DEFAULT: 25\00"
@str.147 = [63 x i8] c" -d start ML optimization from random starting tree \00"
@str.149 = [81 x i8] c" -e set model optimization precision in log likelihood units for final\00"
@str.150 = [75 x i8] c" optimization of tree topology under MIX/MIXI or GAMMA/GAMMAI\00"
@str.151 = [89 x i8] c" DEFAULT: 0.1 for models not using proportion of invariant sites estimate\00"
@str.152 = [85 x i8] c" 0.001 for models using proportion of invariant sites estimate\00"
@str.153 = [118 x i8] c" -E specify an exclude file name, that contains a specification of alignment positions you wish to exclude.\00"
@str.154 = [110 x i8] c" Format is similar to Nexus, the file shall contain entries like \22100-200 300-400\22, to exclude a\00"
@str.155 = [113 x i8] c" single column write, e.g., \22100-100\22, if you use a mixed model, an appropriatly adapted model file\00"
@str.156 = [31 x i8] c" will be written.\00"
@str.157 = [32 x i8] c" -f select algorithm:\00"
@str.158 = [72 x i8] c" -g specify the file name of a multifurcating constraint tree\00"
@str.160 = [41 x i8] c" -h Display this help message.\00"
@str.161 = [91 x i8] c" -i Initial rearrangement setting for the subsequent application of topological \00"
@str.162 = [28 x i8] c" changes phase\00"
@str.163 = [45 x i8] c" DEFAULT: determined by program\00"
@str.164 = [87 x i8] c" -j Specifies if checkpoints will be written by the program. If checkpoints \00"
@str.165 = [90 x i8] c" (intermediate tree topologies) shall be written by the program specify \22-j\22\00"
@str.167 = [87 x i8] c" -k Specifies that bootstrapped trees should be printed with branch lengths.\00"
@str.168 = [95 x i8] c" The bootstraps will run a bit longer, because model parameters will be optimized\00"
@str.169 = [79 x i8] c" at the end of each run. Use with CATMIX/PROTMIX or GAMMA/GAMMAI.\00"
@str.171 = [109 x i8] c" -l Specify a threshold for sequence similarity clustering. RAxML will then print out an alignment\00"
@str.172 = [104 x i8] c" to a file called sequenceFileName.reducedBy.threshold that only contains sequences <= the\00"
@str.173 = [108 x i8] c" specified thresold that must be between 0.0 and 1.0. RAxML uses the QT-clustering algorithm \00"
@str.174 = [112 x i8] c" to perform this task. In addition, a file called RAxML_reducedList.outputFileName will be written\00"
@str.175 = [52 x i8] c" that contains clustering information.\00"
@str.177 = [112 x i8] c" -L Same functionality as \22-l\22 above, but uses a less exhasutive and thus faster clustering algorithm\00"
@str.178 = [94 x i8] c" This is intended for very large datasets with more than 20,000-30,000 sequences\00"
@str.180 = [63 x i8] c" -m Model of Nucleotide or Amino Acid Substitution: \00"
@str.181 = [28 x i8] c" NUCLEOTIDES:\0A\00"
@str.182 = [110 x i8] c" \22-m GTRCAT\22 : GTR + Optimization of substitution rates + Optimization of site-specific\00"
@str.183 = [112 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \00"
@str.184 = [90 x i8] c" rate categories for greater computational efficiency\00"
@str.185 = [124 x i8] c" if you do a multiple analysis with \22-#\22 or \22-N\22 but without bootstrapping the program\00"
@str.186 = [61 x i8] c" will use GTRMIX instead\00"
@str.187 = [101 x i8] c" \22-m GTRGAMMA\22 : GTR + Optimization of substitution rates + GAMMA model of rate \00"
@str.188 = [87 x i8] c" heterogeneity (alpha parameter will be estimated)\00"
@str.189 = [72 x i8] c" \22-m GTRMIX\22 : Inference of the tree under GTRCAT\00"
@str.190 = [105 x i8] c" and thereafter evaluation of the final tree topology under GTRGAMMA\00"
@str.191 = [98 x i8] c" \22-m GTRCAT_GAMMA\22 : Inference of the tree with site-specific evolutionary rates.\00"
@str.192 = [107 x i8] c" However, here rates are categorized using the 4 discrete GAMMA rates.\00"
@str.193 = [90 x i8] c" Evaluation of the final tree topology under GTRGAMMA\00"
@str.194 = [108 x i8] c" \22-m GTRGAMMAI\22 : Same as GTRGAMMA, but with estimate of proportion of invariable sites \00"
@str.195 = [106 x i8] c" \22-m GTRMIXI\22 : Same as GTRMIX, but with estimate of proportion of invariable sites \00"
@str.196 = [112 x i8] c" \22-m GTRCAT_GAMMAI\22 : Same as GTRCAT_GAMMA, but with estimate of proportion of invariable sites \00"
@str.197 = [28 x i8] c" AMINO ACIDS:\0A\00"
@str.198 = [140 x i8] c" \22-m PROTCATmatrixName[F]\22 : specified AA matrix + Optimization of substitution rates + Optimization of site-specific\00"
@str.199 = [126 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \00"
@str.200 = [104 x i8] c" rate categories for greater computational efficiency\00"
@str.201 = [138 x i8] c" if you do a multiple analysis with \22-#\22 or \22-N\22 but without bootstrapping the program\00"
@str.202 = [79 x i8] c" will use PROTMIX... instead\00"
@str.203 = [131 x i8] c" \22-m PROTGAMMAmatrixName[F]\22 : specified AA matrix + Optimization of substitution rates + GAMMA model of rate \00"
@str.204 = [101 x i8] c" heterogeneity (alpha parameter will be estimated)\00"
@str.205 = [105 x i8] c" \22-m PROTMIXmatrixName[F]\22 : Inference of the tree under specified AA matrix + CAT\00"
@str.206 = [138 x i8] c" and thereafter evaluation of the final tree topology under specified AA matrix + GAMMA\00"
@str.207 = [137 x i8] c" \22-m PROTCAT_GAMMAmatrixName[F]\22 : Inference of the tree under specified AA matrix and site-specific evolutionary rates.\00"
@str.208 = [121 x i8] c" However, here rates are categorized using the 4 discrete GAMMA rates.\00"
@str.209 = [123 x i8] c" Evaluation of the final tree topology under specified AA matrix + GAMMA\00"
@str.210 = [136 x i8] c" \22-m PROTGAMMAImatrixName[F]\22 : Same as PROTGAMMAmatrixName[F], but with estimate of proportion of invariable sites \00"
@str.211 = [134 x i8] c" \22-m PROTMIXImatrixName[F]\22 : Same as PROTMIXmatrixName[F], but with estimate of proportion of invariable sites \00"
@str.212 = [140 x i8] c" \22-m PROTCAT_GAMMAImatrixName[F]\22 : Same as PROTCAT_GAMMAmatrixName[F], but with estimate of proportion of invariable sites \00"
@str.213 = [126 x i8] c" Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, GTR\00"
@str.214 = [109 x i8] c" With the optional \22F\22 appendix you can specify if you want to use empirical base frequencies\00"
@str.215 = [102 x i8] c" Please not that for mixed models you can in addition specify the per-gene AA model in\00"
@str.216 = [62 x i8] c" the mixed model file (see manual for details)\00"
@str.217 = [130 x i8] c" -M Switch on estimation of individual per-partition branch lengths. Only has effect when used in combination with \22-q\22\00"
@str.218 = [89 x i8] c" Branch lengths for individual partitions will be printed to separate files\00"
@str.219 = [109 x i8] c" A weighted average of the branch lengths is computed by using the respective partition lengths\00"
@str.221 = [53 x i8] c" -n Specifies the name of the output file.\00"
@str.222 = [106 x i8] c" -o Specify the name of a single outgrpoup or a comma-separated list of outgroups, eg \22-o Rat\22 \00"
@str.223 = [102 x i8] c" or \22-o Rat,Mouse\22, in case that multiple outgroups are not monophyletic the first name \00"
@str.224 = [96 x i8] c" in the list will be selected as outgroup, don't leave spaces between taxon names!\00"
@str.225 = [89 x i8] c" -q Specify the file name which contains the assignment of models to alignment\00"
@str.226 = [90 x i8] c" partitions for multiple models of substitution. For the syntax of this file\00"
@str.227 = [41 x i8] c" please consult the manual.\00"
@str.228 = [115 x i8] c" -p Specify a random number seed for the parsimony inferences. This allows you to reproduce your results\00"
@str.229 = [104 x i8] c" and will help me debug the program. This option HAS NO EFFECT in the parallel MPI version\00"
@str.230 = [110 x i8] c" -P Specify the file name of a user-defined AA (Protein) substitution model. This file must contain\00"
@str.231 = [115 x i8] c" 420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the\00"
@str.232 = [57 x i8] c" last 20 are the empirical base frequencies\00"
@str.233 = [65 x i8] c" -r Specify the file name of a binary constraint tree.\00"
@str.234 = [90 x i8] c" this tree does not need to be comprehensive, i.e. must not contain all taxa\00"
@str.235 = [75 x i8] c" -s Specify the name of the alignment data file in PHYLIP format\00"
@str.236 = [70 x i8] c" -t Specify a user starting tree file name in Newick format\00"
@str.237 = [84 x i8] c" -T PTHREADS VERSION ONLY! Specify the number of threads you want to run.\00"
@str.238 = [92 x i8] c" Make sure to set \22-T\22 to at most the number of CPUs you have on your machine,\00"
@str.239 = [68 x i8] c" otherwise, there will be a huge performance decrease!\00"
@str.240 = [71 x i8] c" -u Specify the number of multiple BS searches per replicate\00"
@str.241 = [59 x i8] c" to obtain better ML trees for each replicate\00"
@str.242 = [54 x i8] c" DEFAULT: One ML search per BS replicate\00"
@str.243 = [42 x i8] c" -v Display version information\00"
@str.244 = [84 x i8] c" -w Name of the working directory where RAxML will write its output files\00"
@str.245 = [41 x i8] c" DEFAULT: current directory\00"
@str.246 = [86 x i8] c" -x Specify an integer number (random seed) and turn on rapid bootstrapping\00"
@str.247 = [93 x i8] c" -y If you want to only compute a parsimony starting tree with RAxML specify \22-y\22,\00"
@str.248 = [75 x i8] c" the program will exit after computation of the starting tree\00"
@str.249 = [27 x i8] c" DEFAULT: OFF\00"
@str.250 = [94 x i8] c" -z Specify the file name of a file containing multiple trees e.g. from a bootstrap\00"
@str.251 = [92 x i8] c" that shall be used to draw bipartition values onto a tree provided with \22-t\22,\00"
@str.252 = [97 x i8] c" It can also be used to compute per site log likelihoods in combination with \22-f g\22\00"
@str.253 = [99 x i8] c" and to read a bunch of trees for a couple of other options (\22-f h\22, \22-f m\22, \22-f n\22).\00"
@str.254 = [80 x i8] c" -#|-N Specify the number of alternative runs on distinct starting trees\00"
@str.255 = [97 x i8] c" In combination with the \22-b\22 option, this will invoke a multiple boostrap analysis\00"
@str.256 = [99 x i8] c" Note that \22-N\22 has been added as an alternative since \22-#\22 sometimes caused problems\00"
@str.257 = [98 x i8] c" with certain MPI job submission systems, since \22-#\22 is often used to start comments\00"
@str.258 = [41 x i8] c" DEFAULT: 1 single analysis\00"
@str.259 = [4 x i8] c"\0A\0A\0A\00"
define void @printREADME() {
%1 = tail call i32 (...) @printVersionInfo()
%2 = tail call i32 @putchar(i32 10)
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str, i64 0, i64 0))
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.127, i64 0, i64 0))
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([84 x i8], [84 x i8]* @str.128, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @str.129, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([113 x i8], [113 x i8]* @str.130, i64 0, i64 0))
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.131, i64 0, i64 0))
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.132, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([109 x i8], [109 x i8]* @str.133, i64 0, i64 0))
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @str.134, i64 0, i64 0))
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @str.135, i64 0, i64 0))
%13 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.136, i64 0, i64 0))
%14 = tail call i32 @putchar(i32 10)
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.137, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.138, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @str.139, i64 0, i64 0))
%18 = tail call i32 @putchar(i32 10)
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.140, i64 0, i64 0))
%20 = tail call i32 @putchar(i32 10)
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%22 = tail call i32 @putchar(i32 10)
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([88 x i8], [88 x i8]* @str.142, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.143, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([86 x i8], [86 x i8]* @str.144, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str.145, i64 0, i64 0))
%27 = tail call i32 @putchar(i32 10)
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.146, i64 0, i64 0))
%29 = tail call i32 @putchar(i32 10)
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.147, i64 0, i64 0))
%31 = tail call i32 @putchar(i32 10)
%32 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%33 = tail call i32 @putchar(i32 10)
%34 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @str.149, i64 0, i64 0))
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.150, i64 0, i64 0))
%36 = tail call i32 @putchar(i32 10)
%37 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.151, i64 0, i64 0))
%38 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([85 x i8], [85 x i8]* @str.152, i64 0, i64 0))
%39 = tail call i32 @putchar(i32 10)
%40 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([118 x i8], [118 x i8]* @str.153, i64 0, i64 0))
%41 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([110 x i8], [110 x i8]* @str.154, i64 0, i64 0))
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([113 x i8], [113 x i8]* @str.155, i64 0, i64 0))
%43 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.156, i64 0, i64 0))
%44 = tail call i32 @putchar(i32 10)
%45 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.157, i64 0, i64 0))
%46 = tail call i32 (...) @printMinusFUsage()
%47 = tail call i32 @putchar(i32 10)
%48 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.158, i64 0, i64 0))
%49 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.234, i64 0, i64 0))
%50 = tail call i32 @putchar(i32 10)
%51 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.160, i64 0, i64 0))
%52 = tail call i32 @putchar(i32 10)
%53 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.161, i64 0, i64 0))
%54 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.162, i64 0, i64 0))
%55 = tail call i32 @putchar(i32 10)
%56 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @str.163, i64 0, i64 0))
%57 = tail call i32 @putchar(i32 10)
%58 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.164, i64 0, i64 0))
%59 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.165, i64 0, i64 0))
%60 = tail call i32 @putchar(i32 10)
%61 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%62 = tail call i32 @putchar(i32 10)
%63 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.167, i64 0, i64 0))
%64 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([95 x i8], [95 x i8]* @str.168, i64 0, i64 0))
%65 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.169, i64 0, i64 0))
%66 = tail call i32 @putchar(i32 10)
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%68 = tail call i32 @putchar(i32 10)
%69 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([109 x i8], [109 x i8]* @str.171, i64 0, i64 0))
%70 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.172, i64 0, i64 0))
%71 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.173, i64 0, i64 0))
%72 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @str.174, i64 0, i64 0))
%73 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @str.175, i64 0, i64 0))
%74 = tail call i32 @putchar(i32 10)
%75 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%76 = tail call i32 @putchar(i32 10)
%77 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @str.177, i64 0, i64 0))
%78 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.178, i64 0, i64 0))
%79 = tail call i32 @putchar(i32 10)
%80 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%81 = tail call i32 @putchar(i32 10)
%82 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.180, i64 0, i64 0))
%83 = tail call i32 @putchar(i32 10)
%84 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.181, i64 0, i64 0))
%85 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([110 x i8], [110 x i8]* @str.182, i64 0, i64 0))
%86 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @str.183, i64 0, i64 0))
%87 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.184, i64 0, i64 0))
%88 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.185, i64 0, i64 0))
%89 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str.186, i64 0, i64 0))
%90 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.187, i64 0, i64 0))
%91 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([87 x i8], [87 x i8]* @str.188, i64 0, i64 0))
%92 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([72 x i8], [72 x i8]* @str.189, i64 0, i64 0))
%93 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.190, i64 0, i64 0))
%94 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([98 x i8], [98 x i8]* @str.191, i64 0, i64 0))
%95 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([107 x i8], [107 x i8]* @str.192, i64 0, i64 0))
%96 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.193, i64 0, i64 0))
%97 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.194, i64 0, i64 0))
%98 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.195, i64 0, i64 0))
%99 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @str.196, i64 0, i64 0))
%100 = tail call i32 @putchar(i32 10)
%101 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.197, i64 0, i64 0))
%102 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([140 x i8], [140 x i8]* @str.198, i64 0, i64 0))
%103 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([126 x i8], [126 x i8]* @str.199, i64 0, i64 0))
%104 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.200, i64 0, i64 0))
%105 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([138 x i8], [138 x i8]* @str.201, i64 0, i64 0))
%106 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @str.202, i64 0, i64 0))
%107 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([131 x i8], [131 x i8]* @str.203, i64 0, i64 0))
%108 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.204, i64 0, i64 0))
%109 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([105 x i8], [105 x i8]* @str.205, i64 0, i64 0))
%110 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([138 x i8], [138 x i8]* @str.206, i64 0, i64 0))
%111 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([137 x i8], [137 x i8]* @str.207, i64 0, i64 0))
%112 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([121 x i8], [121 x i8]* @str.208, i64 0, i64 0))
%113 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([123 x i8], [123 x i8]* @str.209, i64 0, i64 0))
%114 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([136 x i8], [136 x i8]* @str.210, i64 0, i64 0))
%115 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([134 x i8], [134 x i8]* @str.211, i64 0, i64 0))
%116 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([140 x i8], [140 x i8]* @str.212, i64 0, i64 0))
%117 = tail call i32 @putchar(i32 10)
%118 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([126 x i8], [126 x i8]* @str.213, i64 0, i64 0))
%119 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([109 x i8], [109 x i8]* @str.214, i64 0, i64 0))
%120 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str.215, i64 0, i64 0))
%121 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @str.216, i64 0, i64 0))
%122 = tail call i32 @putchar(i32 10)
%123 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([130 x i8], [130 x i8]* @str.217, i64 0, i64 0))
%124 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.218, i64 0, i64 0))
%125 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([109 x i8], [109 x i8]* @str.219, i64 0, i64 0))
%126 = tail call i32 @putchar(i32 10)
%127 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%128 = tail call i32 @putchar(i32 10)
%129 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.221, i64 0, i64 0))
%130 = tail call i32 @putchar(i32 10)
%131 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.222, i64 0, i64 0))
%132 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @str.223, i64 0, i64 0))
%133 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.224, i64 0, i64 0))
%134 = tail call i32 @putchar(i32 10)
%135 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.225, i64 0, i64 0))
%136 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.226, i64 0, i64 0))
%137 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.227, i64 0, i64 0))
%138 = tail call i32 @putchar(i32 10)
%139 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([115 x i8], [115 x i8]* @str.228, i64 0, i64 0))
%140 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([104 x i8], [104 x i8]* @str.229, i64 0, i64 0))
%141 = tail call i32 @putchar(i32 10)
%142 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([110 x i8], [110 x i8]* @str.230, i64 0, i64 0))
%143 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([115 x i8], [115 x i8]* @str.231, i64 0, i64 0))
%144 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.232, i64 0, i64 0))
%145 = tail call i32 @putchar(i32 10)
%146 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.233, i64 0, i64 0))
%147 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.234, i64 0, i64 0))
%148 = tail call i32 @putchar(i32 10)
%149 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.235, i64 0, i64 0))
%150 = tail call i32 @putchar(i32 10)
%151 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.236, i64 0, i64 0))
%152 = tail call i32 @putchar(i32 10)
%153 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([84 x i8], [84 x i8]* @str.237, i64 0, i64 0))
%154 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.238, i64 0, i64 0))
%155 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.239, i64 0, i64 0))
%156 = tail call i32 @putchar(i32 10)
%157 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.240, i64 0, i64 0))
%158 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @str.241, i64 0, i64 0))
%159 = tail call i32 @putchar(i32 10)
%160 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str.242, i64 0, i64 0))
%161 = tail call i32 @putchar(i32 10)
%162 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.243, i64 0, i64 0))
%163 = tail call i32 @putchar(i32 10)
%164 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([84 x i8], [84 x i8]* @str.244, i64 0, i64 0))
%165 = tail call i32 @putchar(i32 10)
%166 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.245, i64 0, i64 0))
%167 = tail call i32 @putchar(i32 10)
%168 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([86 x i8], [86 x i8]* @str.246, i64 0, i64 0))
%169 = tail call i32 @putchar(i32 10)
%170 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([93 x i8], [93 x i8]* @str.247, i64 0, i64 0))
%171 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([75 x i8], [75 x i8]* @str.248, i64 0, i64 0))
%172 = tail call i32 @putchar(i32 10)
%173 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.249, i64 0, i64 0))
%174 = tail call i32 @putchar(i32 10)
%175 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.250, i64 0, i64 0))
%176 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.251, i64 0, i64 0))
%177 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @str.252, i64 0, i64 0))
%178 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @str.253, i64 0, i64 0))
%179 = tail call i32 @putchar(i32 10)
%180 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.254, i64 0, i64 0))
%181 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([97 x i8], [97 x i8]* @str.255, i64 0, i64 0))
%182 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([99 x i8], [99 x i8]* @str.256, i64 0, i64 0))
%183 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([98 x i8], [98 x i8]* @str.257, i64 0, i64 0))
%184 = tail call i32 @putchar(i32 10)
%185 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.258, i64 0, i64 0))
%186 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.259, i64 0, i64 0))
ret void
}