user: Please show me the C implementation that matches the assembly code listed below:

```asm
<help>:
  endbr64
  sub    $0x10,%rsp
  mov    (%rdi),%rsi
  lea    D3(%rip),%rdi
  push   %rsi
  mov    %rsi,%r9
  mov    %rsi,%r8
  mov    %rsi,%rcx
  mov    %rsi,%rdx
  call   <printf@plt>
  add    $0x18,%rsp
  ret
```

tool_calls: name: read_data
arguments: label: D3
datatype: string

tool: {"D3": "Performs actions on nodes that match some condition\n\nSynopsis\n--------\n\n%s [-hnor] <newick trees filename|-> <address> <action>\n\nInput\n-----\n\nFirst argument is the name of a file that contains Newick trees, or '-' (in\nwhich case trees are read from standard input).\n\nSecond argument is a node address, in the form of a logical expression (see\nAddresses below).\n\nThird argument is a code that specifies an action to perform on nodes\nwhich match the address (see Actions).\n\nOutput\n------\n\nBy default, prints the input tree, which may have been modified. However,\nthe 's' action (see Actions, below) causes matching subtrees to be\nprinted out.\n\nThis program is analogous to pattern-oriented, stream processing UNIX\nutilities like sed(1) and awk(1), but instead of working on lines (like\nsed) or records (like awk), %s works on tree nodes.\n\nThe program traverses the tree in Newick order, evaluating the address\nexpression for each node in turn. If (and only if) the address matches, the\naction is performed.\n\nAddresses\n---------\n\nThe address expression involves node properties such as depth, bootstrap\nsupport, whether or not a node is a leaf, etc. These are represented by\nsingle-letter codes, to make expressions short. For example:\n\n\t\t\t\t       i\n\nmatches internal nodes, while\n\n\t\t\t\t     b > 75\n\nmatches nodes whose label has a numerical value of 75 or more (if the label\nis numeric). The usual logical and relational operators are available, so\n\n\t\t\t\t   i & b > 75\n\ncould be used to match internal nodes with a bootstrap support value\ngreater than 75.\n\nThe functions are:\n    a numeric    number of ancestors of node\t\n    b numeric    node's support value (or zero)\n    d numeric    node's depth (distance to root)\n    c numeric    node's number of children\n    D numeric    node's number of descendants\n    i boolean    true iff node is strictly internal (i.e., not root!)\n    l boolean    true iff node is a leaf\n    r boolean    true iff node is the root\n\nThe operators are:\n    ==  equality\n    !=  inequality\n    <   greater than\n    >   lesser than\n    >=  greater than or equal to\n    <=  lesser than or equal to\n    !   logical negation\n    &   logical and\n    |   logical or\n\nThe operator precedence is: negation, relationals, and, or; i.e. \n\n\t\t\t\t 1 == d & !i | l\n\nis equivalent to\n\n\t\t\t       ((1 == d) & (!i)) | l\n\nParentheses can be used for overriding precedence, or for clarity.\n\nActions\n-------\n\nActions are performed on nodes that match the address. They are:\n    s   (Subtree) print subtree rooted at matching node\n    o   (splice Out) splice out node, and attach children to parent, \n\t   preserving branch lengths. This is useful for \"opening\" poorly\n          supported nodes.\n    d   Delete node\n    l   Print node's label\n\n\nOptions\n-------\n\n    -h: print this help text, and exit\n    -n: do not print the (possibly modified) tree at the end of the run \n        (modeled after sed -n)\n    -r: visit tree in preorder (starting at root, and visiting a node\n        before any of its descendants). Default is post-order (ends at root\n        and visits a node after all its descendats).\n    -o: stop processing a clade after the first match - that is, if a node\n        matches, its descendants are not processed.\n        Note: this option will automatically set -r, as it makes no\n        sense in post-order.\n\nBugs\n----\n\nAlthough there are no known bugs in this program, it is to be considered\nmore experimental than the others.\n\nExamples\n--------\n\n# \"open\" all nodes with bootstrap support <= 10 (assuming support is coded\n# in internal node labels)\n\n$ %s data/HRV.bs.nw 'i & b <= 10' o \n\n# \"open\" all nodes with bootstrap support < 750, then discard leaves that\n# are directly attached to the ingroup's root. This effectively keeps only\n# leaves that are part of well-supported clades.\n\n$ %s data/big.rn.nw 'i & b < 750' o | %s - 'l & a == 2' d\n\n# get all clades with at least one ancestor, 980 or better support. Do not\n# print subtrees of matching clades, even if they match (option -o)\n\n$ %s data/big.rn.nw -n -o 'a >= 1 & b >= 980' s\n"}

assistant: ```c
void help(char *argv[]) {
  printf("Performs actions on nodes that match some condition\n"
         "\n"
         "Synopsis\n"
         "--------\n"
         "\n"
         "%s [-hnor] <newick trees filename|-> <address> <action>\n"
         "\n"
         "Input\n"
         "-----\n"
         "\n"
         "First argument is the name of a file that contains Newick trees, or '-' (in\n"
         "which case trees are read from standard input).\n"
         "\n"
         "Second argument is a node address, in the form of a logical expression (see\n"
         "Addresses below).\n"
         "\n"
         "Third argument is a code that specifies an action to perform on nodes\n"
         "which match the address (see Actions).\n"
         "\n"
         "Output\n"
         "------\n"
         "\n"
         "By default, prints the input tree, which may have been modified. However,\n"
         "the 's' action (see Actions, below) causes matching subtrees to be\n"
         "printed out.\n"
         "\n"
         "This program is analogous to pattern-oriented, stream processing UNIX\n"
         "utilities like sed(1) and awk(1), but instead of working on lines (like\n"
         "sed) or records (like awk), %s works on tree nodes.\n"
         "\n"
         "The program traverses the tree in Newick order, evaluating the address\n"
         "expression for each node in turn. If (and only if) the address matches, the\n"
         "action is performed.\n"
         "\n"
         "Addresses\n"
         "---------\n"
         "\n"
         "The address expression involves node properties such as depth, bootstrap\n"
         "support, whether or not a node is a leaf, etc. These are represented by\n"
         "single-letter codes, to make expressions short. For example:\n"
         "\n"
         "				       i\n"
         "\n"
         "matches internal nodes, while\n"
         "\n"
         "				     b > 75\n"
         "\n"
         "matches nodes whose label has a numerical value of 75 or more (if the label\n"
         "is numeric). The usual logical and relational operators are available, so\n"
         "\n"
         "				   i & b > 75\n"
         "\n"
         "could be used to match internal nodes with a bootstrap support value\n"
         "greater than 75.\n"
         "\n"
         "The functions are:\n"
         "    a numeric    number of ancestors of node	\n"
         "    b numeric    node's support value (or zero)\n"
         "    d numeric    node's depth (distance to root)\n"
         "    c numeric    node's number of children\n"
         "    D numeric    node's number of descendants\n"
         "    i boolean    true iff node is strictly internal (i.e., not root!)\n"
         "    l boolean    true iff node is a leaf\n"
         "    r boolean    true iff node is the root\n"
         "\n"
         "The operators are:\n"
         "    ==  equality\n"
         "    !=  inequality\n"
         "    <   greater than\n"
         "    >   lesser than\n"
         "    >=  greater than or equal to\n"
         "    <=  lesser than or equal to\n"
         "    !   logical negation\n"
         "    &   logical and\n"
         "    |   logical or\n"
         "\n"
         "The operator precedence is: negation, relationals, and, or; i.e. \n"
         "\n"
         "				 1 == d & !i | l\n"
         "\n"
         "is equivalent to\n"
         "\n"
         "			       ((1 == d) & (!i)) | l\n"
         "\n"
         "Parentheses can be used for overriding precedence, or for clarity.\n"
         "\n"
         "Actions\n"
         "-------\n"
         "\n"
         "Actions are performed on nodes that match the address. They are:\n"
         "    s   (Subtree) print subtree rooted at matching node\n"
         "    o   (splice Out) splice out node, and attach children to parent, \n"
         "	   preserving branch lengths. This is useful for \"opening\" poorly\n"
         "          supported nodes.\n"
         "    d   Delete node\n"
         "    l   Print node's label\n"
         "\n"
         "\n"
         "Options\n"
         "-------\n"
         "\n"
         "    -h: print this help text, and exit\n"
         "    -n: do not print the (possibly modified) tree at the end of the run \n"
         "        (modeled after sed -n)\n"
         "    -r: visit tree in preorder (starting at root, and visiting a node\n"
         "        before any of its descendants). Default is post-order (ends at root\n"
         "        and visits a node after all its descendats).\n"
         "    -o: stop processing a clade after the first match - that is, if a node\n"
         "        matches, its descendants are not processed.\n"
         "        Note: this option will automatically set -r, as it makes no\n"
         "        sense in post-order.\n"
         "\n"
         "Bugs\n"
         "----\n"
         "\n"
         "Although there are no known bugs in this program, it is to be considered\n"
         "more experimental than the others.\n"
         "\n"
         "Examples\n"
         "--------\n"
         "\n"
         "# \"open\" all nodes with bootstrap support <= 10 (assuming support is coded\n"
         "# in internal node labels)\n"
         "\n"
         "$ %s data/HRV.bs.nw 'i & b <= 10' o \n"
         "\n"
         "# \"open\" all nodes with bootstrap support < 750, then discard leaves that\n"
         "# are directly attached to the ingroup's root. This effectively keeps only\n"
         "# leaves that are part of well-supported clades.\n"
         "\n"
         "$ %s data/big.rn.nw 'i & b < 750' o | %s - 'l & a == 2' d\n"
         "\n"
         "# get all clades with at least one ancestor, 980 or better support. Do not\n"
         "# print subtrees of matching clades, even if they match (option -o)\n"
         "\n"
         "$ %s data/big.rn.nw -n -o 'a >= 1 & b >= 980' s\n",
         argv[0], argv[0], argv[0], argv[0], argv[0], argv[0]);
}
```