void printREADME(void) {
  printVersionInfo();
  printf("\n");
  printf("\nTo report bugs send an email to raxml@h-its.org\n");
  printf("Please send me all input files, the exact invocation, details of the "
         "HW and operating system,\n");
  printf("as well as all error messages printed to screen.\n\n\n");
  printf("raxmlLight|raxmlLight-PTHREADS|raxmlLight-MPI\n");
  printf("      -s binarySequenceFile\n");
  printf("      -n outputFileName\n");
  printf("      -m substitutionModel\n");
  printf("      [-a]\n");
  printf("      [-B]\n");
  printf("      [-c numberOfCategories]\n");
  printf("      [-D]\n");
  printf("      [-e likelihoodEpsilon] \n");
  printf("      [-f d|o]\n");
  printf("      [-h] \n");
  printf("      [-i initialRearrangementSetting] \n");
  printf("      [-L maxMemUsageMB] \n");
  printf("      [-M]\n");
  printf("      [-P proteinModel]\n");
  printf("      [-q multipleModelFileName] \n");
  printf("      [-S]\n");
  printf("      [-t userStartingTree| -R binaryCheckpointFile]\n");
  printf("      [-T numberOfThreads]\n");
  printf("      [-v]\n");
  printf("      [-w outputDirectory] \n");
  printf("      [-X]\n");
  printf("\n");
  printf("      -a      use the median for the discrete approximation of the "
         "GAMMA model of rate heterogeneity\n");
  printf("\n");
  printf("              DEFAULT: OFF\n");
  printf("\n");
  printf("      -B      Parse phylip file and conduct pattern compression, "
         "then store the output in a \n");
  printf("              binary file called sequenceFileName.binary that can be "
         "read via the \"-G\" option\n");
  printf("              ATTENTION: the \"-B\" option only works with the "
         "sequential version\n");
  printf("\n");
  printf("      -c      Specify number of distinct rate catgories for RAxML "
         "when modelOfEvolution\n");
  printf("              is set to PSR\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      ML search convergence criterion. This will break off "
         "ML searches if the relative \n");
  printf("              Robinson-Foulds distance between the trees obtained "
         "from two consecutive lazy SPR cycles\n");
  printf("              is smaller or equal to 1%s. Usage recommended for very "
         "large datasets in terms of taxa.\n",
         "%");
  printf("              On trees with more than 500 taxa this will yield "
         "execution time improvements of approximately 50%s\n",
         "%");
  printf("              While yielding only slightly worse trees.\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 model parameters\n");
  printf("\n");
  printf("              DEFAULT: 0.1 \n");
  printf("\n");
  printf("      -f      select algorithm:\n");
  printMinusFUsage();
  printf("\n");
  printf("      -G      Read in a binary alignment file (instead of a "
         "text-based phylip file with \"-s\") that was previsouly\n");
  printf("              generated with the \"-B\" option. This can "
         "substantially save time spent in input parsing \n");
  printf("              for very large parallel runs\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("      -L      Apply inner vector recomputation. Total memory usage "
         "remains under the given size in MB \n");
  printf("\n");
  printf("      -m      Model of  Nucleotide or Amino Acid Substitution: \n");
  printf("\n");
  printf("              NUCLEOTIDES:\n\n");
  printf("                \"-m PSR\"            : 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("                \"-m GAMMA\"          : GTR + GAMMA model of rate "
         "heterogeneity. This uses 4 hard-coded discrete rates\n");
  printf("                                      to discretize the GAMMA "
         "distribution.\n");
  printf("\n");
  printf("              AMINO ACIDS:\n\n");
  printf("                \"-m PROTPSRmatrixName[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("                \"-m PROTGAMMAmatrixName[F]\"       : specified AA "
         "matrix + GAMMA model of rate heterogeneity. This uses 4 hard-coded "
         "discrete rates\n");
  printf("                                                    to discretize "
         "the GAMMA distribution.\n");
  printf("\n");
  printf(
      "                Available AA substitution models: DAYHOFF, DCMUT, JTT, "
      "MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, MTART, MTZOA,\n");
  printf("                PMB, HIVB, HIVW, JTTDCMUT, FLU, AUTO, GTR\n");
  printf("                With the optional \"F\" appendix you can specify if "
         "you want to use empirical base frequencies\n");
  printf("                Please note 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). Also "
         "note that if you estimate AA GTR parameters on a partitioned\n");
  printf("                dataset, they will be linked (estimated jointly) "
         "across all partitions to avoid over-parametrization\n");
  printf("                When AUTO is used RAxML will conduct an ML estimate "
         "of all available pre-defined AA models (excluding GTR) every time "
         "the model parameters\n");
  printf("                are optimized during the tree search.\n");
  printf("                WARNING: we have not figured out yet how to best do "
         "this for partitioned analyses, so don't use AUTO for datasets with "
         "partitions\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      Specify the name of the output file.\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("      -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("\n");
  printf("      -R      read in a binary checkpoint file called "
         "RAxML_binaryCheckpoint.RUN_ID_number\n");
  printf("\n");
  printf("      -s      Specify the binary sequence file name of the alignment "
         "data file created by the parser\n");
  printf("\n");
  printf(
      "      -S      turn on memory saving option for gappy multi-gene "
      "alignments. For large and gappy datasets specify -S to save memory\n");
  printf("              This will produce slightly different likelihood "
         "values, may be a bit slower but can reduce memory consumption\n");
  printf("              from 70GB to 19GB on very large and gappy datasets\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("      -v      Display version information\n");
  printf("\n");
  printf("      -w      FULL (!) path to the directory into which RAxML shall "
         "write its output files\n");
  printf("\n");
  printf("              DEFAULT: current directory\n");
  printf("\n");
  printf("      -X      EXPERIMENTAL OPTION: This option will do a per-site "
         "estimate of protein substitution models\n");
  printf("              by looping over all given, fixed models LG, WAG, JTT, "
         "etc and using their respective base frequencies to independently\n");
  printf("              assign a prot subst. model to each site via ML "
         "optimization\n");
  printf("              At present this option only works with the GTR+GAMMA "
         "model, unpartitioned datasets, and in the sequential\n");
  printf("              version only.\n");
  printf("\n\n\n\n");
}


x86 assembly (clang, -O0):
<printREADME>:
push   %rbp
mov    %rsp,%rbp
mov    $0x0,%al
call   1050 <printVersionInfo@plt>
lea    0x2a05(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeb0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xed4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf25(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf4b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf6c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf7b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf86(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf94(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf92(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf90(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfa1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfb0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfb2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfb1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfcc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfd9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfd7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xfe2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xff7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xff5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x101d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x102b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1029(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1038(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2899(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1028(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x287d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1072(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2861(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1072(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x10c2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1113(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2829(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1148(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1193(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x11a2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x11eb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x27e3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1206(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x27c7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1205(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1258(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x12b2(%rip),%rdi
lea    0x1312(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1306(%rip),%rdi
lea    0x12fd(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1363(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2765(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xf5a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2749(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1364(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13a8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x271f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13bc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2703(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13bd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    $0x0,%al
call   1040 <printMinusFUsage@plt>
lea    0x26e0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x13bb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1420(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x147a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x26a8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x148a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x268c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1498(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x14e6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2662(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x14e7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2646(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1533(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x262a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1558(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1567(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16f8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x176a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x15ad(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x184d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x25c8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x15f9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1608(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1688(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x16fa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1757(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x17dd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2566(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x181c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1897(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x18c4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1924(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x197e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x19f2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1a5a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1ae8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1b11(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x24da(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1b88(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1bfd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c49(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x24a2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xc97(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2486(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x246a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1c97(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1cf8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d5e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2432(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1d7c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1dc8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1e15(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x23fa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x23ec(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1e15(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x23d0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1e55(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x23b4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1e9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1f15(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1f84(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x237c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1faa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2360(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x1fd5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x201c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x206b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2328(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2094(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x230c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x20a3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x22f0(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x20e3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x22d4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x20f1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x214e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x21c6(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x2203(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x226e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x227d(%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   1070 <printVersionInfo@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xf6f(%rip),%rdi
call   1040 <puts@plt>
lea    0xf94(%rip),%rdi
call   1040 <puts@plt>
lea    0xfe6(%rip),%rdi
call   1040 <puts@plt>
lea    0x100d(%rip),%rdi
call   1040 <puts@plt>
lea    0x102f(%rip),%rdi
call   1040 <puts@plt>
lea    0x103f(%rip),%rdi
call   1040 <puts@plt>
lea    0x104b(%rip),%rdi
call   1040 <puts@plt>
lea    0x105a(%rip),%rdi
call   1040 <puts@plt>
lea    0x1059(%rip),%rdi
call   1040 <puts@plt>
lea    0x1058(%rip),%rdi
call   1040 <puts@plt>
lea    0x106a(%rip),%rdi
call   1040 <puts@plt>
lea    0x1069(%rip),%rdi
call   1040 <puts@plt>
lea    0x107b(%rip),%rdi
call   1040 <puts@plt>
lea    0x107e(%rip),%rdi
call   1040 <puts@plt>
lea    0x107e(%rip),%rdi
call   1040 <puts@plt>
lea    0x109a(%rip),%rdi
call   1040 <puts@plt>
lea    0x10a8(%rip),%rdi
call   1040 <puts@plt>
lea    0x10a7(%rip),%rdi
call   1040 <puts@plt>
lea    0x10b3(%rip),%rdi
call   1040 <puts@plt>
lea    0x10c9(%rip),%rdi
call   1040 <puts@plt>
lea    0x10c8(%rip),%rdi
call   1040 <puts@plt>
lea    0x10f1(%rip),%rdi
call   1040 <puts@plt>
lea    0x1100(%rip),%rdi
call   1040 <puts@plt>
lea    0x10ff(%rip),%rdi
call   1040 <puts@plt>
lea    0x110f(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1104(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2034(%rip),%r14
mov    %r14,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x113a(%rip),%rdi
call   1040 <puts@plt>
lea    0x118b(%rip),%rdi
call   1040 <puts@plt>
lea    0x11dd(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1217(%rip),%rdi
call   1040 <puts@plt>
lea    0x1263(%rip),%rdi
call   1040 <puts@plt>
lea    0x1273(%rip),%rdi
call   1040 <puts@plt>
lea    0x12bd(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x12dd(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x12e1(%rip),%rdi
call   1040 <puts@plt>
lea    0x1335(%rip),%rdi
call   1040 <puts@plt>
lea    0xc99(%rip),%rdi
lea    0xcf9(%rip),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xcea(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1367(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1377(%rip),%rdi
call   1040 <puts@plt>
lea    0x13bc(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x13d5(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x13db(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1060 <printMinusFUsage@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x13de(%rip),%rdi
call   1040 <puts@plt>
lea    0x1444(%rip),%rdi
call   1040 <puts@plt>
lea    0x149f(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x14b4(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x14c7(%rip),%rdi
call   1040 <puts@plt>
lea    0x1516(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x151c(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x156d(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1597(%rip),%rdi
call   1040 <puts@plt>
lea    0x15a7(%rip),%rdi
call   1040 <puts@plt>
lea    0x1736(%rip),%rdi
call   1040 <puts@plt>
lea    0x17a9(%rip),%rdi
call   1040 <puts@plt>
lea    0x15f2(%rip),%rdi
call   1040 <puts@plt>
lea    0x188e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1645(%rip),%rdi
call   1040 <puts@plt>
lea    0x1655(%rip),%rdi
call   1040 <puts@plt>
lea    0x16d6(%rip),%rdi
call   1040 <puts@plt>
lea    0x1749(%rip),%rdi
call   1040 <puts@plt>
lea    0x17a7(%rip),%rdi
call   1040 <puts@plt>
lea    0x182e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1872(%rip),%rdi
call   1040 <puts@plt>
lea    0x18ee(%rip),%rdi
call   1040 <puts@plt>
lea    0x191c(%rip),%rdi
call   1040 <puts@plt>
lea    0x197d(%rip),%rdi
call   1040 <puts@plt>
lea    0x19d8(%rip),%rdi
call   1040 <puts@plt>
lea    0x1a4d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1ab6(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b45(%rip),%rdi
call   1040 <puts@plt>
lea    0x1b6f(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1beb(%rip),%rdi
call   1040 <puts@plt>
lea    0x1c61(%rip),%rdi
call   1040 <puts@plt>
lea    0x1cae(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1d0e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1d2b(%rip),%rdi
call   1040 <puts@plt>
lea    0x1d8d(%rip),%rdi
call   1040 <puts@plt>
lea    0x1df4(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1e17(%rip),%rdi
call   1040 <puts@plt>
lea    0x1e64(%rip),%rdi
call   1040 <puts@plt>
lea    0x1eb2(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1ebb(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1f00(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1f4f(%rip),%rdi
call   1040 <puts@plt>
lea    0x1fc6(%rip),%rdi
call   1040 <puts@plt>
lea    0x2036(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2061(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2091(%rip),%rdi
call   1040 <puts@plt>
lea    0x20d9(%rip),%rdi
call   1040 <puts@plt>
lea    0x2129(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x2157(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x216b(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x21b0(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x21c3(%rip),%rdi
call   1040 <puts@plt>
lea    0x2221(%rip),%rdi
call   1040 <puts@plt>
lea    0x229a(%rip),%rdi
call   1040 <puts@plt>
lea    0x22d8(%rip),%rdi
call   1040 <puts@plt>
lea    0x2344(%rip),%rdi
call   1040 <puts@plt>
lea    0x2354(%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 = [50 x i8] c"\0ATo report bugs send an email to raxml@h-its.org\0A\00"
@.str.2 = [95 x i8] c"Please send me all input files, the exact invocation, details of the HW and operating system,\0A\00"
@.str.3 = [52 x i8] c"as well as all error messages printed to screen.\0A\0A\0A\00"
@.str.4 = [47 x i8] c"raxmlLight|raxmlLight-PTHREADS|raxmlLight-MPI\0A\00"
@.str.5 = [29 x i8] c" -s binarySequenceFile\0A\00"
@.str.6 = [25 x i8] c" -n outputFileName\0A\00"
@.str.7 = [28 x i8] c" -m substitutionModel\0A\00"
@.str.8 = [12 x i8] c" [-a]\0A\00"
@.str.9 = [12 x i8] c" [-B]\0A\00"
@.str.10 = [31 x i8] c" [-c numberOfCategories]\0A\00"
@.str.11 = [12 x i8] c" [-D]\0A\00"
@.str.12 = [31 x i8] c" [-e likelihoodEpsilon] \0A\00"
@.str.13 = [16 x i8] c" [-f d|o]\0A\00"
@.str.14 = [13 x i8] c" [-h] \0A\00"
@.str.15 = [41 x i8] c" [-i initialRearrangementSetting] \0A\00"
@.str.16 = [27 x i8] c" [-L maxMemUsageMB] \0A\00"
@.str.17 = [12 x i8] c" [-M]\0A\00"
@.str.18 = [25 x i8] c" [-P proteinModel]\0A\00"
@.str.19 = [35 x i8] c" [-q multipleModelFileName] \0A\00"
@.str.20 = [12 x i8] c" [-S]\0A\00"
@.str.21 = [54 x i8] c" [-t userStartingTree| -R binaryCheckpointFile]\0A\00"
@.str.22 = [28 x i8] c" [-T numberOfThreads]\0A\00"
@.str.23 = [12 x i8] c" [-v]\0A\00"
@.str.24 = [29 x i8] c" [-w outputDirectory] \0A\00"
@.str.25 = [12 x i8] c" [-X]\0A\00"
@.str.26 = [102 x i8] c" -a use the median for the discrete approximation of the GAMMA model of rate heterogeneity\0A\00"
@.str.27 = [28 x i8] c" DEFAULT: OFF\0A\00"
@.str.28 = [94 x i8] c" -B Parse phylip file and conduct pattern compression, then store the output in a \0A\00"
@.str.29 = [95 x i8] c" binary file called sequenceFileName.binary that can be read via the \22-G\22 option\0A\00"
@.str.30 = [81 x i8] c" ATTENTION: the \22-B\22 option only works with the sequential version\0A\00"
@.str.31 = [89 x i8] c" -c Specify number of distinct rate catgories for RAxML when modelOfEvolution\0A\00"
@.str.32 = [29 x i8] c" is set to PSR\0A\00"
@.str.33 = [87 x i8] c" Individual per-site rates are categorized into numberOfCategories rate \0A\00"
@.str.34 = [55 x i8] c" categories to accelerate computations. \0A\00"
@.str.35 = [27 x i8] c" DEFAULT: 25\0A\00"
@.str.36 = [97 x i8] c" -D ML search convergence criterion. This will break off ML searches if the relative \0A\00"
@.str.37 = [104 x i8] c" Robinson-Foulds distance between the trees obtained from two consecutive lazy SPR cycles\0A\00"
@.str.38 = [103 x i8] c" is smaller or equal to 1%s. Usage recommended for very large datasets in terms of taxa.\0A\00"
@.str.39 = [2 x i8] c"%\00"
@.str.40 = [114 x i8] c" On trees with more than 500 taxa this will yield execution time improvements of approximately 50%s\0A\00"
@.str.41 = [57 x i8] c" While yielding only slightly worse trees.\0A\00"
@.str.42 = [82 x i8] c" -e set model optimization precision in log likelihood units for final\0A\00"
@.str.43 = [48 x i8] c" optimization of model parameters\0A\00"
@.str.44 = [29 x i8] c" DEFAULT: 0.1 \0A\00"
@.str.45 = [33 x i8] c" -f select algorithm:\0A\00"
@.str.46 = [115 x i8] c" -G Read in a binary alignment file (instead of a text-based phylip file with \22-s\22) that was previsouly\0A\00"
@.str.47 = [104 x i8] c" generated with the \22-B\22 option. This can substantially save time spent in input parsing \0A\00"
@.str.48 = [44 x i8] c" for very large parallel runs\0A\00"
@.str.49 = [42 x i8] c" -h Display this help message.\0A\00"
@.str.50 = [92 x i8] c" -i Initial rearrangement setting for the subsequent application of topological \0A\00"
@.str.51 = [29 x i8] c" changes phase\0A\00"
@.str.52 = [104 x i8] c" -L Apply inner vector recomputation. Total memory usage remains under the given size in MB \0A\00"
@.str.53 = [65 x i8] c" -m Model of Nucleotide or Amino Acid Substitution: \0A\00"
@.str.54 = [29 x i8] c" NUCLEOTIDES:\0A\0A\00"
@.str.55 = [112 x i8] c" \22-m PSR\22 : GTR + Optimization of substitution rates + Optimization of site-specific\0A\00"
@.str.56 = [114 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \0A\00"
@.str.57 = [93 x i8] c" rate categories for greater computational efficiency.\0A\00"
@.str.58 = [118 x i8] c" \22-m GAMMA\22 : GTR + GAMMA model of rate heterogeneity. This uses 4 hard-coded discrete rates\0A\00"
@.str.59 = [77 x i8] c" to discretize the GAMMA distribution.\0A\00"
@.str.60 = [29 x i8] c" AMINO ACIDS:\0A\0A\00"
@.str.61 = [142 x i8] c" \22-m PROTPSRmatrixName[F]\22 : specified AA matrix + Optimization of substitution rates + Optimization of site-specific\0A\00"
@.str.62 = [128 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \0A\00"
@.str.63 = [107 x i8] c" rate categories for greater computational efficiency.\0A\00"
@.str.64 = [148 x i8] c" \22-m PROTGAMMAmatrixName[F]\22 : specified AA matrix + GAMMA model of rate heterogeneity. This uses 4 hard-coded discrete rates\0A\00"
@.str.65 = [91 x i8] c" to discretize the GAMMA distribution.\0A\00"
@.str.66 = [137 x i8] c" Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, MTART, MTZOA,\0A\00"
@.str.67 = [59 x i8] c" PMB, HIVB, HIVW, JTTDCMUT, FLU, AUTO, GTR\0A\00"
@.str.68 = [110 x i8] c" With the optional \22F\22 appendix you can specify if you want to use empirical base frequencies\0A\00"
@.str.69 = [104 x i8] c" Please note that for mixed models you can in addition specify the per-gene AA model in\0A\00"
@.str.70 = [130 x i8] c" the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned\0A\00"
@.str.71 = [118 x i8] c" dataset, they will be linked (estimated jointly) across all partitions to avoid over-parametrization\0A\00"
@.str.72 = [156 x i8] c" When AUTO is used RAxML will conduct an ML estimate of all available pre-defined AA models (excluding GTR) every time the model parameters\0A\00"
@.str.73 = [55 x i8] c" are optimized during the tree search.\0A\00"
@.str.74 = [147 x i8] c" WARNING: we have not figured out yet how to best do this for partitioned analyses, so don't use AUTO for datasets with partitions\0A\00"
@.str.75 = [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.76 = [90 x i8] c" Branch lengths for individual partitions will be printed to separate files\0A\00"
@.str.77 = [110 x i8] c" A weighted average of the branch lengths is computed by using the respective partition lengths\0A\00"
@.str.78 = [52 x i8] c" -n Specify the name of the output file.\0A\00"
@.str.79 = [111 x i8] c" -P Specify the file name of a user-defined AA (Protein) substitution model. This file must contain\0A\00"
@.str.80 = [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.81 = [58 x i8] c" last 20 are the empirical base frequencies\0A\00"
@.str.82 = [90 x i8] c" -q Specify the file name which contains the assignment of models to alignment\0A\00"
@.str.83 = [91 x i8] c" partitions for multiple models of substitution. For the syntax of this file\0A\00"
@.str.84 = [42 x i8] c" please consult the manual.\0A\00"
@.str.85 = [92 x i8] c" -R read in a binary checkpoint file called RAxML_binaryCheckpoint.RUN_ID_number\0A\00"
@.str.86 = [102 x i8] c" -s Specify the binary sequence file name of the alignment data file created by the parser\0A\00"
@.str.87 = [132 x i8] c" -S turn on memory saving option for gappy multi-gene alignments. For large and gappy datasets specify -S to save memory\0A\00"
@.str.88 = [125 x i8] c" This will produce slightly different likelihood values, may be a bit slower but can reduce memory consumption\0A\00"
@.str.89 = [66 x i8] c" from 70GB to 19GB on very large and gappy datasets\0A\00"
@.str.90 = [71 x i8] c" -t Specify a user starting tree file name in Newick format\0A\00"
@.str.91 = [85 x i8] c" -T PTHREADS VERSION ONLY! Specify the number of threads you want to run.\0A\00"
@.str.92 = [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.93 = [69 x i8] c" otherwise, there will be a huge performance decrease!\0A\00"
@.str.94 = [43 x i8] c" -v Display version information\0A\00"
@.str.95 = [92 x i8] c" -w FULL (!) path to the directory into which RAxML shall write its output files\0A\00"
@.str.96 = [42 x i8] c" DEFAULT: current directory\0A\00"
@.str.97 = [107 x i8] c" -X EXPERIMENTAL OPTION: This option will do a per-site estimate of protein substitution models\0A\00"
@.str.98 = [134 x i8] c" by looping over all given, fixed models LG, WAG, JTT, etc and using their respective base frequencies to independently\0A\00"
@.str.99 = [75 x i8] c" assign a prot subst. model to each site via ML optimization\0A\00"
@.str.100 = [121 x i8] c" At present this option only works with the GTR+GAMMA model, unpartitioned datasets, and in the sequential\0A\00"
@.str.101 = [29 x i8] c" version only.\0A\00"
@.str.102 = [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 ([50 x i8], [50 x i8]* @.str.1, i64 0, i64 0))
%4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.2, i64 0, i64 0))
%5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.3, i64 0, i64 0))
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.4, i64 0, i64 0))
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0))
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.6, i64 0, i64 0))
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.7, i64 0, i64 0))
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.8, i64 0, i64 0))
%11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0))
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0))
%13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.11, i64 0, i64 0))
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.12, i64 0, i64 0))
%15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.13, i64 0, i64 0))
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i64 0, i64 0))
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.15, i64 0, i64 0))
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.16, i64 0, i64 0))
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.17, i64 0, i64 0))
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.18, i64 0, i64 0))
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.19, i64 0, i64 0))
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.20, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.21, i64 0, i64 0))
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.22, i64 0, i64 0))
%25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.23, i64 0, i64 0))
%26 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.24, i64 0, i64 0))
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.25, i64 0, i64 0))
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%29 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.26, i64 0, i64 0))
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.27, i64 0, i64 0))
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([94 x i8], [94 x i8]* @.str.28, i64 0, i64 0))
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.29, i64 0, i64 0))
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @.str.30, 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 ([89 x i8], [89 x i8]* @.str.31, i64 0, i64 0))
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.32, i64 0, i64 0))
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.33, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.34, i64 0, i64 0))
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.35, i64 0, i64 0))
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.36, i64 0, i64 0))
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.37, i64 0, i64 0))
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.38, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([114 x i8], [114 x i8]* @.str.40, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.41, i64 0, i64 0))
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.27, i64 0, i64 0))
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.42, i64 0, i64 0))
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.43, i64 0, i64 0))
%54 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.44, i64 0, i64 0))
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.45, i64 0, i64 0))
%58 = call i32 (...) @printMinusFUsage()
%59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([115 x i8], [115 x i8]* @.str.46, i64 0, i64 0))
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.47, i64 0, i64 0))
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.48, i64 0, i64 0))
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%64 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.49, i64 0, i64 0))
%65 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.50, i64 0, i64 0))
%67 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.51, 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 ([104 x i8], [104 x i8]* @.str.52, i64 0, i64 0))
%70 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.53, i64 0, i64 0))
%72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.54, i64 0, i64 0))
%74 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([112 x i8], [112 x i8]* @.str.55, i64 0, i64 0))
%75 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([114 x i8], [114 x i8]* @.str.56, i64 0, i64 0))
%76 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.57, i64 0, i64 0))
%77 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([118 x i8], [118 x i8]* @.str.58, i64 0, i64 0))
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.59, 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 ([29 x i8], [29 x i8]* @.str.60, i64 0, i64 0))
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([142 x i8], [142 x i8]* @.str.61, i64 0, i64 0))
%82 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([128 x i8], [128 x i8]* @.str.62, i64 0, i64 0))
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.63, i64 0, i64 0))
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([148 x i8], [148 x i8]* @.str.64, i64 0, i64 0))
%85 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.65, i64 0, i64 0))
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([137 x i8], [137 x i8]* @.str.66, i64 0, i64 0))
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.67, i64 0, i64 0))
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([110 x i8], [110 x i8]* @.str.68, i64 0, i64 0))
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([104 x i8], [104 x i8]* @.str.69, i64 0, i64 0))
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([130 x i8], [130 x i8]* @.str.70, i64 0, i64 0))
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([118 x i8], [118 x i8]* @.str.71, i64 0, i64 0))
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([156 x i8], [156 x i8]* @.str.72, i64 0, i64 0))
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.73, i64 0, i64 0))
%95 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([147 x i8], [147 x i8]* @.str.74, i64 0, i64 0))
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%97 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([131 x i8], [131 x i8]* @.str.75, i64 0, i64 0))
%98 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.76, i64 0, i64 0))
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([110 x i8], [110 x i8]* @.str.77, 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 ([28 x i8], [28 x i8]* @.str.27, i64 0, i64 0))
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.78, i64 0, i64 0))
%104 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([111 x i8], [111 x i8]* @.str.79, i64 0, i64 0))
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([116 x i8], [116 x i8]* @.str.80, i64 0, i64 0))
%107 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.81, i64 0, i64 0))
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%109 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.82, i64 0, i64 0))
%110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([91 x i8], [91 x i8]* @.str.83, i64 0, i64 0))
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.84, i64 0, i64 0))
%112 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%114 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.85, i64 0, i64 0))
%115 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%116 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([102 x i8], [102 x i8]* @.str.86, 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 ([132 x i8], [132 x i8]* @.str.87, i64 0, i64 0))
%119 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([125 x i8], [125 x i8]* @.str.88, i64 0, i64 0))
%120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.89, i64 0, i64 0))
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.90, i64 0, i64 0))
%123 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%124 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([85 x i8], [85 x i8]* @.str.91, i64 0, i64 0))
%125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.92, i64 0, i64 0))
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.93, i64 0, i64 0))
%127 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%128 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.94, i64 0, i64 0))
%129 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.95, i64 0, i64 0))
%131 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.96, i64 0, i64 0))
%133 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%134 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.97, i64 0, i64 0))
%135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([134 x i8], [134 x i8]* @.str.98, i64 0, i64 0))
%136 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.99, i64 0, i64 0))
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([121 x i8], [121 x i8]* @.str.100, i64 0, i64 0))
%138 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.101, i64 0, i64 0))
%139 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.102, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str.38 = [103 x i8] c" is smaller or equal to 1%s. Usage recommended for very large datasets in terms of taxa.\0A\00"
@.str.39 = [2 x i8] c"%\00"
@.str.40 = [114 x i8] c" On trees with more than 500 taxa this will yield execution time improvements of approximately 50%s\0A\00"
@str = [49 x i8] c"\0ATo report bugs send an email to raxml@h-its.org\00"
@str.103 = [94 x i8] c"Please send me all input files, the exact invocation, details of the HW and operating system,\00"
@str.104 = [51 x i8] c"as well as all error messages printed to screen.\0A\0A\00"
@str.105 = [46 x i8] c"raxmlLight|raxmlLight-PTHREADS|raxmlLight-MPI\00"
@str.106 = [28 x i8] c" -s binarySequenceFile\00"
@str.107 = [24 x i8] c" -n outputFileName\00"
@str.108 = [27 x i8] c" -m substitutionModel\00"
@str.109 = [11 x i8] c" [-a]\00"
@str.110 = [11 x i8] c" [-B]\00"
@str.111 = [30 x i8] c" [-c numberOfCategories]\00"
@str.112 = [11 x i8] c" [-D]\00"
@str.113 = [30 x i8] c" [-e likelihoodEpsilon] \00"
@str.114 = [15 x i8] c" [-f d|o]\00"
@str.115 = [12 x i8] c" [-h] \00"
@str.116 = [40 x i8] c" [-i initialRearrangementSetting] \00"
@str.117 = [26 x i8] c" [-L maxMemUsageMB] \00"
@str.118 = [11 x i8] c" [-M]\00"
@str.119 = [24 x i8] c" [-P proteinModel]\00"
@str.120 = [34 x i8] c" [-q multipleModelFileName] \00"
@str.121 = [11 x i8] c" [-S]\00"
@str.122 = [53 x i8] c" [-t userStartingTree| -R binaryCheckpointFile]\00"
@str.123 = [27 x i8] c" [-T numberOfThreads]\00"
@str.124 = [11 x i8] c" [-v]\00"
@str.125 = [28 x i8] c" [-w outputDirectory] \00"
@str.126 = [11 x i8] c" [-X]\00"
@str.127 = [101 x i8] c" -a use the median for the discrete approximation of the GAMMA model of rate heterogeneity\00"
@str.129 = [93 x i8] c" -B Parse phylip file and conduct pattern compression, then store the output in a \00"
@str.130 = [94 x i8] c" binary file called sequenceFileName.binary that can be read via the \22-G\22 option\00"
@str.131 = [80 x i8] c" ATTENTION: the \22-B\22 option only works with the sequential version\00"
@str.132 = [88 x i8] c" -c Specify number of distinct rate catgories for RAxML when modelOfEvolution\00"
@str.133 = [28 x i8] c" is set to PSR\00"
@str.134 = [86 x i8] c" Individual per-site rates are categorized into numberOfCategories rate \00"
@str.135 = [54 x i8] c" categories to accelerate computations. \00"
@str.136 = [26 x i8] c" DEFAULT: 25\00"
@str.137 = [96 x i8] c" -D ML search convergence criterion. This will break off ML searches if the relative \00"
@str.138 = [103 x i8] c" Robinson-Foulds distance between the trees obtained from two consecutive lazy SPR cycles\00"
@str.139 = [56 x i8] c" While yielding only slightly worse trees.\00"
@str.141 = [81 x i8] c" -e set model optimization precision in log likelihood units for final\00"
@str.142 = [47 x i8] c" optimization of model parameters\00"
@str.143 = [28 x i8] c" DEFAULT: 0.1 \00"
@str.144 = [32 x i8] c" -f select algorithm:\00"
@str.145 = [114 x i8] c" -G Read in a binary alignment file (instead of a text-based phylip file with \22-s\22) that was previsouly\00"
@str.146 = [103 x i8] c" generated with the \22-B\22 option. This can substantially save time spent in input parsing \00"
@str.147 = [43 x i8] c" for very large parallel runs\00"
@str.148 = [41 x i8] c" -h Display this help message.\00"
@str.149 = [91 x i8] c" -i Initial rearrangement setting for the subsequent application of topological \00"
@str.150 = [28 x i8] c" changes phase\00"
@str.151 = [103 x i8] c" -L Apply inner vector recomputation. Total memory usage remains under the given size in MB \00"
@str.152 = [64 x i8] c" -m Model of Nucleotide or Amino Acid Substitution: \00"
@str.153 = [28 x i8] c" NUCLEOTIDES:\0A\00"
@str.154 = [111 x i8] c" \22-m PSR\22 : GTR + Optimization of substitution rates + Optimization of site-specific\00"
@str.155 = [113 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \00"
@str.156 = [92 x i8] c" rate categories for greater computational efficiency.\00"
@str.157 = [117 x i8] c" \22-m GAMMA\22 : GTR + GAMMA model of rate heterogeneity. This uses 4 hard-coded discrete rates\00"
@str.158 = [76 x i8] c" to discretize the GAMMA distribution.\00"
@str.159 = [28 x i8] c" AMINO ACIDS:\0A\00"
@str.160 = [141 x i8] c" \22-m PROTPSRmatrixName[F]\22 : specified AA matrix + Optimization of substitution rates + Optimization of site-specific\00"
@str.161 = [127 x i8] c" evolutionary rates which are categorized into numberOfCategories distinct \00"
@str.162 = [106 x i8] c" rate categories for greater computational efficiency.\00"
@str.163 = [147 x i8] c" \22-m PROTGAMMAmatrixName[F]\22 : specified AA matrix + GAMMA model of rate heterogeneity. This uses 4 hard-coded discrete rates\00"
@str.164 = [90 x i8] c" to discretize the GAMMA distribution.\00"
@str.165 = [136 x i8] c" Available AA substitution models: DAYHOFF, DCMUT, JTT, MTREV, WAG, RTREV, CPREV, VT, BLOSUM62, MTMAM, LG, MTART, MTZOA,\00"
@str.166 = [58 x i8] c" PMB, HIVB, HIVW, JTTDCMUT, FLU, AUTO, GTR\00"
@str.167 = [109 x i8] c" With the optional \22F\22 appendix you can specify if you want to use empirical base frequencies\00"
@str.168 = [103 x i8] c" Please note that for mixed models you can in addition specify the per-gene AA model in\00"
@str.169 = [129 x i8] c" the mixed model file (see manual for details). Also note that if you estimate AA GTR parameters on a partitioned\00"
@str.170 = [117 x i8] c" dataset, they will be linked (estimated jointly) across all partitions to avoid over-parametrization\00"
@str.171 = [155 x i8] c" When AUTO is used RAxML will conduct an ML estimate of all available pre-defined AA models (excluding GTR) every time the model parameters\00"
@str.172 = [54 x i8] c" are optimized during the tree search.\00"
@str.173 = [146 x i8] c" WARNING: we have not figured out yet how to best do this for partitioned analyses, so don't use AUTO for datasets with partitions\00"
@str.174 = [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.175 = [89 x i8] c" Branch lengths for individual partitions will be printed to separate files\00"
@str.176 = [109 x i8] c" A weighted average of the branch lengths is computed by using the respective partition lengths\00"
@str.177 = [27 x i8] c" DEFAULT: OFF\00"
@str.178 = [51 x i8] c" -n Specify the name of the output file.\00"
@str.179 = [110 x i8] c" -P Specify the file name of a user-defined AA (Protein) substitution model. This file must contain\00"
@str.180 = [115 x i8] c" 420 entries, the first 400 being the AA substitution rates (this must be a symmetric matrix) and the\00"
@str.181 = [57 x i8] c" last 20 are the empirical base frequencies\00"
@str.182 = [89 x i8] c" -q Specify the file name which contains the assignment of models to alignment\00"
@str.183 = [90 x i8] c" partitions for multiple models of substitution. For the syntax of this file\00"
@str.184 = [41 x i8] c" please consult the manual.\00"
@str.185 = [91 x i8] c" -R read in a binary checkpoint file called RAxML_binaryCheckpoint.RUN_ID_number\00"
@str.186 = [101 x i8] c" -s Specify the binary sequence file name of the alignment data file created by the parser\00"
@str.187 = [131 x i8] c" -S turn on memory saving option for gappy multi-gene alignments. For large and gappy datasets specify -S to save memory\00"
@str.188 = [124 x i8] c" This will produce slightly different likelihood values, may be a bit slower but can reduce memory consumption\00"
@str.189 = [65 x i8] c" from 70GB to 19GB on very large and gappy datasets\00"
@str.190 = [70 x i8] c" -t Specify a user starting tree file name in Newick format\00"
@str.191 = [84 x i8] c" -T PTHREADS VERSION ONLY! Specify the number of threads you want to run.\00"
@str.192 = [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.193 = [68 x i8] c" otherwise, there will be a huge performance decrease!\00"
@str.194 = [42 x i8] c" -v Display version information\00"
@str.195 = [91 x i8] c" -w FULL (!) path to the directory into which RAxML shall write its output files\00"
@str.196 = [41 x i8] c" DEFAULT: current directory\00"
@str.197 = [106 x i8] c" -X EXPERIMENTAL OPTION: This option will do a per-site estimate of protein substitution models\00"
@str.198 = [133 x i8] c" by looping over all given, fixed models LG, WAG, JTT, etc and using their respective base frequencies to independently\00"
@str.199 = [74 x i8] c" assign a prot subst. model to each site via ML optimization\00"
@str.200 = [120 x i8] c" At present this option only works with the GTR+GAMMA model, unpartitioned datasets, and in the sequential\00"
@str.201 = [28 x i8] c" version only.\00"
@str.202 = [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 ([49 x i8], [49 x i8]* @str, i64 0, i64 0))
%4 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.103, i64 0, i64 0))
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.104, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.105, i64 0, i64 0))
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.106, i64 0, i64 0))
%8 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.107, i64 0, i64 0))
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.108, i64 0, i64 0))
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.109, i64 0, i64 0))
%11 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.110, i64 0, i64 0))
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.111, i64 0, i64 0))
%13 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.112, i64 0, i64 0))
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.113, i64 0, i64 0))
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.114, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.115, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.116, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.117, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.118, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.119, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.120, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.121, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @str.122, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.123, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.124, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.125, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.126, i64 0, i64 0))
%28 = tail call i32 @putchar(i32 10)
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.127, i64 0, i64 0))
%30 = tail call i32 @putchar(i32 10)
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.177, i64 0, i64 0))
%32 = tail call i32 @putchar(i32 10)
%33 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([93 x i8], [93 x i8]* @str.129, i64 0, i64 0))
%34 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([94 x i8], [94 x i8]* @str.130, i64 0, i64 0))
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @str.131, i64 0, i64 0))
%36 = tail call i32 @putchar(i32 10)
%37 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([88 x i8], [88 x i8]* @str.132, i64 0, i64 0))
%38 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.133, i64 0, i64 0))
%39 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([86 x i8], [86 x i8]* @str.134, i64 0, i64 0))
%40 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str.135, i64 0, i64 0))
%41 = tail call i32 @putchar(i32 10)
%42 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.136, i64 0, i64 0))
%43 = tail call i32 @putchar(i32 10)
%44 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([96 x i8], [96 x i8]* @str.137, i64 0, i64 0))
%45 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @str.138, i64 0, i64 0))
%46 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @.str.38, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
%47 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([114 x i8], [114 x i8]* @.str.40, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
%48 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str.139, i64 0, i64 0))
%49 = tail call i32 @putchar(i32 10)
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.177, i64 0, i64 0))
%51 = tail call i32 @putchar(i32 10)
%52 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([81 x i8], [81 x i8]* @str.141, i64 0, i64 0))
%53 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.142, i64 0, i64 0))
%54 = tail call i32 @putchar(i32 10)
%55 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.143, i64 0, i64 0))
%56 = tail call i32 @putchar(i32 10)
%57 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.144, i64 0, i64 0))
%58 = tail call i32 (...) @printMinusFUsage()
%59 = tail call i32 @putchar(i32 10)
%60 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([114 x i8], [114 x i8]* @str.145, i64 0, i64 0))
%61 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @str.146, i64 0, i64 0))
%62 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @str.147, i64 0, i64 0))
%63 = tail call i32 @putchar(i32 10)
%64 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.148, i64 0, i64 0))
%65 = tail call i32 @putchar(i32 10)
%66 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.149, i64 0, i64 0))
%67 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.150, i64 0, i64 0))
%68 = tail call i32 @putchar(i32 10)
%69 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @str.151, i64 0, i64 0))
%70 = tail call i32 @putchar(i32 10)
%71 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.152, i64 0, i64 0))
%72 = tail call i32 @putchar(i32 10)
%73 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.153, i64 0, i64 0))
%74 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([111 x i8], [111 x i8]* @str.154, i64 0, i64 0))
%75 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([113 x i8], [113 x i8]* @str.155, i64 0, i64 0))
%76 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.156, i64 0, i64 0))
%77 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([117 x i8], [117 x i8]* @str.157, i64 0, i64 0))
%78 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.158, i64 0, i64 0))
%79 = tail call i32 @putchar(i32 10)
%80 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.159, i64 0, i64 0))
%81 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([141 x i8], [141 x i8]* @str.160, i64 0, i64 0))
%82 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([127 x i8], [127 x i8]* @str.161, i64 0, i64 0))
%83 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.162, i64 0, i64 0))
%84 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([147 x i8], [147 x i8]* @str.163, i64 0, i64 0))
%85 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.164, i64 0, i64 0))
%86 = tail call i32 @putchar(i32 10)
%87 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([136 x i8], [136 x i8]* @str.165, i64 0, i64 0))
%88 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @str.166, i64 0, i64 0))
%89 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([109 x i8], [109 x i8]* @str.167, i64 0, i64 0))
%90 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([103 x i8], [103 x i8]* @str.168, i64 0, i64 0))
%91 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([129 x i8], [129 x i8]* @str.169, i64 0, i64 0))
%92 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([117 x i8], [117 x i8]* @str.170, i64 0, i64 0))
%93 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([155 x i8], [155 x i8]* @str.171, i64 0, i64 0))
%94 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([54 x i8], [54 x i8]* @str.172, i64 0, i64 0))
%95 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([146 x i8], [146 x i8]* @str.173, i64 0, i64 0))
%96 = tail call i32 @putchar(i32 10)
%97 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([130 x i8], [130 x i8]* @str.174, i64 0, i64 0))
%98 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.175, i64 0, i64 0))
%99 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([109 x i8], [109 x i8]* @str.176, i64 0, i64 0))
%100 = tail call i32 @putchar(i32 10)
%101 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.177, i64 0, i64 0))
%102 = tail call i32 @putchar(i32 10)
%103 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @str.178, i64 0, i64 0))
%104 = tail call i32 @putchar(i32 10)
%105 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([110 x i8], [110 x i8]* @str.179, i64 0, i64 0))
%106 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([115 x i8], [115 x i8]* @str.180, i64 0, i64 0))
%107 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([57 x i8], [57 x i8]* @str.181, i64 0, i64 0))
%108 = tail call i32 @putchar(i32 10)
%109 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([89 x i8], [89 x i8]* @str.182, i64 0, i64 0))
%110 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([90 x i8], [90 x i8]* @str.183, i64 0, i64 0))
%111 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.184, i64 0, i64 0))
%112 = tail call i32 @putchar(i32 10)
%113 = tail call i32 @putchar(i32 10)
%114 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.185, i64 0, i64 0))
%115 = tail call i32 @putchar(i32 10)
%116 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([101 x i8], [101 x i8]* @str.186, i64 0, i64 0))
%117 = tail call i32 @putchar(i32 10)
%118 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([131 x i8], [131 x i8]* @str.187, i64 0, i64 0))
%119 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([124 x i8], [124 x i8]* @str.188, i64 0, i64 0))
%120 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @str.189, i64 0, i64 0))
%121 = tail call i32 @putchar(i32 10)
%122 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.190, i64 0, i64 0))
%123 = tail call i32 @putchar(i32 10)
%124 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([84 x i8], [84 x i8]* @str.191, i64 0, i64 0))
%125 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.192, i64 0, i64 0))
%126 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.193, i64 0, i64 0))
%127 = tail call i32 @putchar(i32 10)
%128 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.194, i64 0, i64 0))
%129 = tail call i32 @putchar(i32 10)
%130 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([91 x i8], [91 x i8]* @str.195, i64 0, i64 0))
%131 = tail call i32 @putchar(i32 10)
%132 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str.196, i64 0, i64 0))
%133 = tail call i32 @putchar(i32 10)
%134 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([106 x i8], [106 x i8]* @str.197, i64 0, i64 0))
%135 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([133 x i8], [133 x i8]* @str.198, i64 0, i64 0))
%136 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.199, i64 0, i64 0))
%137 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([120 x i8], [120 x i8]* @str.200, i64 0, i64 0))
%138 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.201, i64 0, i64 0))
%139 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.202, i64 0, i64 0))
ret void
}