user: Converte this assembly snippet into its equivalent C code:

```asm
<usage>:
  endbr64
  push   %rbx
  mov    %rdi,%rbx
  mov    %rsi,%rdx
  lea    D14(%rip),%rsi
  mov    $0x0,%eax
  call   <fprintf@plt>
  mov    %rbx,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D157(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x15,%edx
  mov    $0x1,%esi
  lea    D161(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x35,%edx
  mov    $0x1,%esi
  lea    D55(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x21,%edx
  mov    $0x1,%esi
  lea    D60(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x28,%edx
  mov    $0x1,%esi
  lea    D75(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x38,%edx
  mov    $0x1,%esi
  lea    D158(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x38,%edx
  mov    $0x1,%esi
  lea    D132(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x33,%edx
  mov    $0x1,%esi
  lea    D48(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D90(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x25,%edx
  mov    $0x1,%esi
  lea    D109(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D130(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D20(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x29,%edx
  mov    $0x1,%esi
  lea    D144(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D11(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x31,%edx
  mov    $0x1,%esi
  lea    D156(%rip),%rdi
  call   <fwrite@plt>
  mov    %rbx,%rcx
  mov    $0x2e,%edx
  mov    $0x1,%esi
  lea    D80(%rip),%rdi
  call   <fwrite@plt>
  pop    %rbx
  ret
```

tool_calls: name: read_data
arguments: data_tag: D14
type_guessed: string
name: read_data
arguments: data_tag: D157
type_guessed: string
name: read_data
arguments: data_tag: D161
type_guessed: string
name: read_data
arguments: data_tag: D55
type_guessed: string
name: read_data
arguments: data_tag: D60
type_guessed: string
name: read_data
arguments: data_tag: D75
type_guessed: string
name: read_data
arguments: data_tag: D158
type_guessed: string
name: read_data
arguments: data_tag: D132
type_guessed: string
name: read_data
arguments: data_tag: D48
type_guessed: string
name: read_data
arguments: data_tag: D90
type_guessed: string
name: read_data
arguments: data_tag: D109
type_guessed: string
name: read_data
arguments: data_tag: D130
type_guessed: string
name: read_data
arguments: data_tag: D20
type_guessed: string
name: read_data
arguments: data_tag: D144
type_guessed: string
name: read_data
arguments: data_tag: D11
type_guessed: string
name: read_data
arguments: data_tag: D156
type_guessed: string
name: read_data
arguments: data_tag: D80
type_guessed: string

tool: D14: usage: %s [-h|-?] [-v] [-l] [-d] [-3] [-n nrruns] [-i iterations]


tool: D157:                      [-r rollout] [-a] test [test...]


tool: D161: 
	-h|-?  : this help


tool: D55: 	-v     : verbose, display actual PMC counter values


tool: D60: 	-l     : list all defined tests


tool: D75: 	-d     : dump generated code to stdout


tool: D158: 	-3     : generate code with 32-bit operands by default


tool: D132: 	-6     : generate code with 64-bit operands by default


tool: D48: 	-n runs: repeat each run <runs> times and average


tool: D90: 	-i iter: repeat the 8 instructions <iter> times in a


tool: D109: 	         loop, default is 1 million


tool: D130: 	-r loop: roll out the loops <loop> times, default: 8


tool: D20: 	-c file: load binary code from file and execute that


tool: D144: 	-a     : run all defined tests in a row


tool: D11: 	test   : test name, can be followed by .32 or .64 to


tool: D156: 	         explicitly specify the operand bitness


tool: D80: 	         use -l to get list of defined tests


assistant: ```c
void usage(FILE *outf, const char *progname) {
  fprintf(outf, "usage: %s [-h|-?] [-v] [-l] [-d] [-3] [-n nrruns] [-i iterations]\n", progname);
  fprintf(outf, "                     [-r rollout] [-a] test [test...]\n");
  fprintf(outf, "\n\t-h|-?  : this help\n");
  fprintf(outf, "\t-v     : verbose, display actual PMC counter values\n");
  fprintf(outf, "\t-l     : list all defined tests\n");
  fprintf(outf, "\t-d     : dump generated code to stdout\n");
  fprintf(outf, "\t-3     : generate code with 32-bit operands by default\n");
  fprintf(outf, "\t-6     : generate code with 64-bit operands by default\n");
  fprintf(outf, "\t-n runs: repeat each run <runs> times and average\n");
  fprintf(outf, "\t-i iter: repeat the 8 instructions <iter> times in a\n");
  fprintf(outf, "\t         loop, default is 1 million\n");
  fprintf(outf, "\t-r loop: roll out the loops <loop> times, default: 8\n");
  fprintf(outf, "\t-c file: load binary code from file and execute that\n");
  fprintf(outf, "\t-a     : run all defined tests in a row\n");
  fprintf(outf, "\ttest   : test name, can be followed by .32 or .64 to\n");
  fprintf(outf, "\t         explicitly specify the operand bitness\n");
  fprintf(outf, "\t         use -l to get list of defined tests\n");
  return;
}
```