user: Translate the below assembly code into C programming language:

```asm
<printMinusFUsage>:
  endbr64
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    D360(%rip),%r12
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D562(%rip),%rdi
  call   <printf@plt>
  lea    D628(%rip),%rdi
  call   <printf@plt>
  lea    D571(%rip),%rdi
  call   <printf@plt>
  lea    D35(%rip),%r13
  mov    %r13,%rdi
  call   <printf@plt>
  lea    D100(%rip),%rdi
  call   <printf@plt>
  lea    D673(%rip),%rdi
  call   <printf@plt>
  lea    D317(%rip),%rdi
  call   <printf@plt>
  lea    D125(%rip),%rdi
  call   <printf@plt>
  lea    D527(%rip),%rdi
  call   <printf@plt>
  lea    D535(%rip),%rdi
  call   <printf@plt>
  lea    D296(%rip),%rdi
  call   <printf@plt>
  lea    D471(%rip),%rdi
  call   <printf@plt>
  lea    D23(%rip),%rdi
  call   <printf@plt>
  lea    D62(%rip),%rdi
  call   <printf@plt>
  lea    D26(%rip),%rdi
  call   <printf@plt>
  lea    D404(%rip),%rdi
  call   <printf@plt>
  lea    D397(%rip),%rbp
  mov    %rbp,%rdi
  call   <printf@plt>
  lea    D443(%rip),%rdi
  call   <printf@plt>
  lea    D123(%rip),%rdi
  call   <printf@plt>
  lea    D618(%rip),%rbx
  mov    %rbx,%rdi
  call   <printf@plt>
  lea    D432(%rip),%rdi
  call   <printf@plt>
  lea    D309(%rip),%r14
  mov    %r14,%rdi
  call   <printf@plt>
  mov    %rbp,%rdi
  call   <printf@plt>
  lea    D217(%rip),%rdi
  call   <printf@plt>
  mov    %r14,%rdi
  call   <printf@plt>
  mov    %rbx,%rdi
  call   <printf@plt>
  lea    D354(%rip),%rdi
  call   <printf@plt>
  mov    %r13,%rdi
  call   <printf@plt>
  lea    D335(%rip),%rdi
  call   <printf@plt>
  lea    D636(%rip),%rdi
  call   <printf@plt>
  lea    D481(%rip),%rdi
  call   <printf@plt>
  lea    D60(%rip),%rdi
  call   <printf@plt>
  lea    D651(%rip),%rdi
  call   <printf@plt>
  lea    D207(%rip),%rdi
  call   <printf@plt>
  lea    D417(%rip),%rdi
  call   <printf@plt>
  lea    D508(%rip),%rdi
  call   <printf@plt>
  lea    D442(%rip),%rdi
  call   <printf@plt>
  lea    D124(%rip),%rdi
  call   <printf@plt>
  lea    D196(%rip),%rdi
  call   <printf@plt>
  lea    D252(%rip),%rdi
  call   <printf@plt>
  lea    D46(%rip),%rdi
  call   <printf@plt>
  lea    D166(%rip),%rdi
  call   <printf@plt>
  lea    D642(%rip),%rdi
  call   <printf@plt>
  lea    D509(%rip),%rdi
  call   <printf@plt>
  lea    D310(%rip),%r13
  mov    %r13,%rdi
  call   <printf@plt>
  mov    %rbp,%rdi
  call   <printf@plt>
  lea    D568(%rip),%rdi
  call   <printf@plt>
  mov    %r13,%rdi
  call   <printf@plt>
  mov    %rbx,%rdi
  call   <printf@plt>
  lea    D232(%rip),%rdi
  call   <printf@plt>
  lea    D401(%rip),%rdi
  call   <printf@plt>
  lea    D553(%rip),%rdi
  call   <printf@plt>
  lea    D38(%rip),%rdi
  call   <printf@plt>
  lea    D697(%rip),%rdi
  call   <printf@plt>
  lea    D494(%rip),%rdi
  call   <printf@plt>
  lea    D175(%rip),%rdi
  call   <printf@plt>
  lea    D652(%rip),%rdi
  call   <printf@plt>
  lea    D110(%rip),%rdi
  call   <printf@plt>
  lea    D693(%rip),%rdi
  call   <printf@plt>
  lea    D615(%rip),%rdi
  call   <printf@plt>
  lea    D698(%rip),%rdi
  call   <printf@plt>
  lea    D510(%rip),%rdi
  call   <printf@plt>
  lea    D264(%rip),%rdi
  call   <printf@plt>
  lea    D306(%rip),%rdi
  call   <printf@plt>
  lea    D590(%rip),%rdi
  call   <printf@plt>
  lea    D575(%rip),%rdi
  call   <printf@plt>
  lea    D439(%rip),%r13
  mov    %r13,%rdi
  call   <printf@plt>
  lea    D645(%rip),%rdi
  call   <printf@plt>
  mov    %r13,%rdi
  call   <printf@plt>
  lea    D403(%rip),%rdi
  call   <printf@plt>
  lea    D379(%rip),%rdi
  call   <printf@plt>
  mov    %rbp,%rdi
  call   <printf@plt>
  lea    D28(%rip),%rdi
  call   <printf@plt>
  mov    %rbx,%rdi
  call   <printf@plt>
  lea    D15(%rip),%rdi
  call   <printf@plt>
  lea    D37(%rip),%rdi
  call   <printf@plt>
  lea    D600(%rip),%rdi
  call   <printf@plt>
  lea    D324(%rip),%rdi
  call   <printf@plt>
  mov    %r13,%rdi
  call   <printf@plt>
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D76(%rip),%rdi
  call   <printf@plt>
  mov    %r12,%rdi
  call   <printf@plt>
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
```

tool_calls: name: extract_symbolic_data
arguments: data_label: D360
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D562
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D628
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D571
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D35
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D100
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D673
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D317
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D125
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D527
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D535
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D296
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D471
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D23
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D62
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D26
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D404
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D397
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D443
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D123
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D618
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D432
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D309
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D217
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D354
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D335
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D636
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D481
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D60
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D651
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D207
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D417
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D508
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D442
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D124
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D196
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D252
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D46
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D166
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D642
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D509
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D310
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D568
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D232
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D401
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D553
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D38
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D697
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D494
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D175
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D652
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D110
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D693
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D615
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D698
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D510
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D264
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D306
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D590
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D575
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D439
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D645
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D403
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D379
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D28
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D15
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D37
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D600
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D324
type_guessed: string
name: extract_symbolic_data
arguments: data_label: D76
type_guessed: string

tool: D360: 


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


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


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


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


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


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


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


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


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


tool: D535:                       DEFAULT: ON


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


tool: D693:                       visually any more.


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


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


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


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


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


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


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


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


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


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


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


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


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


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


tool: D600:                       models of rate heterogeneity


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


tool: D76:               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");
}
```