user: 请显示与下面列出的汇编代码相匹配的C语言实现:

```asm
<printMinusFUsage>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  lea    D436(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D169(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D257(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D430(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D68(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D740(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D774(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D38(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D464(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D557(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D186(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D264(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D495(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D280(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D797(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D555(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D693(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D306(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D200(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D544(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D92(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D644(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D743(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D306(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D484(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D743(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D92(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D446(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D68(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D75(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D131(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D537(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D21(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D396(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D804(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D185(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D578(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D819(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D168(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D511(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D540(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D229(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D15(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D493(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D400(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D315(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D306(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D802(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D315(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D92(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D23(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D576(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D559(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D288(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D128(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D543(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D721(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D134(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D663(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D536(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D687(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D274(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D548(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D547(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D294(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D112(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D99(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D806(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D780(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D806(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D793(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D399(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D306(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D718(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D92(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D674(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D46(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D783(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D20(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D806(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D436(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D403(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  lea    D436(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  nop
  pop    %rbp
  ret
```

tool_calls: name: unpack_data
arguments: data_tag: D436
type_infered: string
name: unpack_data
arguments: data_tag: D169
type_infered: string
name: unpack_data
arguments: data_tag: D257
type_infered: string
name: unpack_data
arguments: data_tag: D430
type_infered: string
name: unpack_data
arguments: data_tag: D68
type_infered: string
name: unpack_data
arguments: data_tag: D740
type_infered: string
name: unpack_data
arguments: data_tag: D774
type_infered: string
name: unpack_data
arguments: data_tag: D38
type_infered: string
name: unpack_data
arguments: data_tag: D464
type_infered: string
name: unpack_data
arguments: data_tag: D557
type_infered: string
name: unpack_data
arguments: data_tag: D186
type_infered: string
name: unpack_data
arguments: data_tag: D264
type_infered: string
name: unpack_data
arguments: data_tag: D495
type_infered: string
name: unpack_data
arguments: data_tag: D280
type_infered: string
name: unpack_data
arguments: data_tag: D797
type_infered: string
name: unpack_data
arguments: data_tag: D555
type_infered: string
name: unpack_data
arguments: data_tag: D693
type_infered: string
name: unpack_data
arguments: data_tag: D306
type_infered: string
name: unpack_data
arguments: data_tag: D200
type_infered: string
name: unpack_data
arguments: data_tag: D544
type_infered: string
name: unpack_data
arguments: data_tag: D92
type_infered: string
name: unpack_data
arguments: data_tag: D644
type_infered: string
name: unpack_data
arguments: data_tag: D743
type_infered: string
name: unpack_data
arguments: data_tag: D484
type_infered: string
name: unpack_data
arguments: data_tag: D446
type_infered: string
name: unpack_data
arguments: data_tag: D75
type_infered: string
name: unpack_data
arguments: data_tag: D131
type_infered: string
name: unpack_data
arguments: data_tag: D537
type_infered: string
name: unpack_data
arguments: data_tag: D21
type_infered: string
name: unpack_data
arguments: data_tag: D396
type_infered: string
name: unpack_data
arguments: data_tag: D804
type_infered: string
name: unpack_data
arguments: data_tag: D185
type_infered: string
name: unpack_data
arguments: data_tag: D578
type_infered: string
name: unpack_data
arguments: data_tag: D819
type_infered: string
name: unpack_data
arguments: data_tag: D168
type_infered: string
name: unpack_data
arguments: data_tag: D511
type_infered: string
name: unpack_data
arguments: data_tag: D540
type_infered: string
name: unpack_data
arguments: data_tag: D229
type_infered: string
name: unpack_data
arguments: data_tag: D15
type_infered: string
name: unpack_data
arguments: data_tag: D493
type_infered: string
name: unpack_data
arguments: data_tag: D400
type_infered: string
name: unpack_data
arguments: data_tag: D315
type_infered: string
name: unpack_data
arguments: data_tag: D802
type_infered: string
name: unpack_data
arguments: data_tag: D23
type_infered: string
name: unpack_data
arguments: data_tag: D576
type_infered: string
name: unpack_data
arguments: data_tag: D559
type_infered: string
name: unpack_data
arguments: data_tag: D288
type_infered: string
name: unpack_data
arguments: data_tag: D128
type_infered: string
name: unpack_data
arguments: data_tag: D543
type_infered: string
name: unpack_data
arguments: data_tag: D721
type_infered: string
name: unpack_data
arguments: data_tag: D134
type_infered: string
name: unpack_data
arguments: data_tag: D663
type_infered: string
name: unpack_data
arguments: data_tag: D536
type_infered: string
name: unpack_data
arguments: data_tag: D687
type_infered: string
name: unpack_data
arguments: data_tag: D274
type_infered: string
name: unpack_data
arguments: data_tag: D548
type_infered: string
name: unpack_data
arguments: data_tag: D547
type_infered: string
name: unpack_data
arguments: data_tag: D294
type_infered: string
name: unpack_data
arguments: data_tag: D112
type_infered: string
name: unpack_data
arguments: data_tag: D99
type_infered: string
name: unpack_data
arguments: data_tag: D806
type_infered: string
name: unpack_data
arguments: data_tag: D780
type_infered: string
name: unpack_data
arguments: data_tag: D793
type_infered: string
name: unpack_data
arguments: data_tag: D399
type_infered: string
name: unpack_data
arguments: data_tag: D718
type_infered: string
name: unpack_data
arguments: data_tag: D674
type_infered: string
name: unpack_data
arguments: data_tag: D46
type_infered: string
name: unpack_data
arguments: data_tag: D783
type_infered: string
name: unpack_data
arguments: data_tag: D20
type_infered: string
name: unpack_data
arguments: data_tag: D403
type_infered: string

tool: D436: 


tool: D169:               "-f a": rapid Bootstrap analysis and search for best-scoring ML tree in one program run


tool: D257:               "-f A": compute marginal ancestral states on a ROOTED reference tree provided with "t"


tool: D430:               "-f b": draw bipartition information on a tree provided with "-t" based on multiple trees


tool: D68:                       (e.g., from a bootstrap) in a file specified by "-z"


tool: D740:               "-f B": optimize br-len scaler and other model parameters (GTR, alpha, etc.) on a tree provided with "-t".


tool: D774:                       The tree needs to contain branch lengths. The branch lengths will not be optimized, just scaled by a single common value.


tool: D38:               "-f c": check if the alignment can be properly read by RAxML


tool: D464:               "-f C": ancestral sequence test for Jiajie, users will also need to provide a list of taxon names via -Y separated by whitespaces


tool: D557:               "-f d": new rapid hill-climbing 


tool: D186:                       DEFAULT: ON


tool: D264:               "-f D": rapid hill-climbing with RELL bootstraps


tool: D495:               "-f e": optimize model+branch lengths for given input tree under GAMMA/GAMMAI only


tool: D280:               "-f E": execute very fast experimental tree search, at present only for testing


tool: D797:               "-f F": execute fast experimental tree search, at present only for testing


tool: D555:               "-f g": compute per site log Likelihoods for one ore more trees passed via


tool: D693:                       "-z" and write them to a file that can be read by CONSEL


tool: D306:                       The model parameters will be estimated on the first tree only!


tool: D200:               "-f G": compute per site log Likelihoods for one ore more trees passed via


tool: D544:                       "-z" and write them to a file that can be read by CONSEL.


tool: D92:                       The model parameters will be re-estimated for each tree


tool: D644:               "-f h": compute log likelihood test (SH-test) between best tree passed via "-t"


tool: D743:                       and a bunch of other trees passed via "-z" 


tool: D484:               "-f H": compute log likelihood test (SH-test) between best tree passed via "-t"


tool: D446:               "-f i": calculate IC and TC scores (Salichos and Rokas 2013) on a tree provided with "-t" based on multiple trees


tool: D75:               "-f I": a simple tree rooting algorithm for unrooted trees.


tool: D131:                       It roots the tree by rooting it at the branch that best balances the subtree lengths


tool: D537:                       (sum over branches in the subtrees) of the left and right subtree.


tool: D21:                       A branch with an optimal balance does not always exist!


tool: D396:                       You need to specify the tree you want to root via "-t".


tool: D804:               "-f j": generate a bunch of bootstrapped alignment files from an original alignemnt file.


tool: D185:                       You need to specify a seed with "-b" and the number of replicates with "-#" 


tool: D578:               "-f J": Compute SH-like support values on a given tree passed via "-t".


tool: D819:               "-f k": Predict missing sequence data in a partitioned multi-gene alignment for a given tree.


tool: D168:                       Only works in conjunction with "-t", "-M", and "-q".


tool: D511:                       This option is in an early experimental state, use at your own risk!


tool: D540:               "-f m": compare bipartitions between two bunches of trees passed via "-t" and "-z" 


tool: D229:                       respectively. This will return the Pearson correlation between all bipartitions found


tool: D15:                       in the two tree files. A file called RAxML_bipartitionFrequencies.outpuFileName


tool: D493:                       will be printed that contains the pair-wise bipartition frequencies of the two sets


tool: D400:               "-f n": compute the log likelihood score of all trees contained in a tree file provided by


tool: D315:                       "-z" under GAMMA or GAMMA+P-Invar


tool: D802:               "-f N": compute the log likelihood score of all trees contained in a tree file provided by


tool: D23:               "-f o": old and slower rapid hill-climbing without heuristic cutoff


tool: D576:               "-f p": perform pure stepwise MP addition of new sequences to an incomplete starting tree and exit


tool: D559:               "-f q": fast quartet calculator


tool: D288:               "-f r": compute pairwise Robinson-Foulds (RF) distances between all pairs of trees in a tree file passed via "-z" 


tool: D128:                       if the trees have node labales represented as integer support values the program will also compute two flavors of


tool: D543:                       the weighted Robinson-Foulds (WRF) distance


tool: D721:               "-f R": compute all pairwise Robinson-Foulds (RF) distances between a large reference tree  passed via "-t" 


tool: D134:                       and many smaller trees (that must have a subset of the taxa of the large tree) passed via "-z".


tool: D663:                       This option is intended for checking the plausibility of very large phylogenies that can not be inspected


tool: D536:                       visually any more.


tool: D687:               "-f s": split up a multi-gene partitioned alignment into the respective subalignments 


tool: D274:               "-f S": compute site-specific placement bias using a leave one out test inspired by the evolutionary placement algorithm


tool: D548:               "-f t": do randomized tree searches on one fixed starting tree


tool: D547:               "-f T": do final thorough optimization of ML tree from rapid bootstrap search in stand-alone mode


tool: D294:               "-f u": execute morphological weight calibration using maximum likelihood, this will return a weight vector.


tool: D112:                       you need to provide a morphological alignment and a reference tree via "-t" 


tool: D99:               "-f v": classify a bunch of environmental sequences into a reference tree using thorough read insertions


tool: D806:                       you will need to start RAxML with a non-comprehensive reference tree and an alignment containing all sequences (reference + query)


tool: D780:               "-f V": classify a bunch of environmental sequences into a reference tree using thorough read insertions


tool: D793:                       WARNING: this is a test implementation for more efficient handling of multi-gene/whole-genome datasets!


tool: D399:               "-f w": compute ELW test on a bunch of trees passed via "-z" 


tool: D718:               "-f W": compute ELW test on a bunch of trees passed via "-z" 


tool: D674:               "-f x": compute pair-wise ML distances, ML model parameters will be estimated on an MP 


tool: D46:                       starting tree or a user-defined tree passed via "-t", only allowed for GAMMA-based


tool: D783:                       models of rate heterogeneity


tool: D20:               "-f y": classify a bunch of environmental sequences into a reference tree using parsimony


tool: D403:               DEFAULT for "-f": new rapid hill climbing


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