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

```asm
<usage>:
  endbr64
  push   %r12
  mov    %rsi,%rdx
  mov    %rdi,%r12
  lea    D146(%rip),%rsi
  xor    %eax,%eax
  call   <fprintf@plt>
  mov    %r12,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D68(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x15,%edx
  mov    $0x1,%esi
  lea    D16(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x35,%edx
  mov    $0x1,%esi
  lea    D84(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x21,%edx
  mov    $0x1,%esi
  lea    D12(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x28,%edx
  mov    $0x1,%esi
  lea    D4(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x38,%edx
  mov    $0x1,%esi
  lea    D154(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x38,%edx
  mov    $0x1,%esi
  lea    D152(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x33,%edx
  mov    $0x1,%esi
  lea    D17(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D81(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x25,%edx
  mov    $0x1,%esi
  lea    D53(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D110(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D103(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x29,%edx
  mov    $0x1,%esi
  lea    D24(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x36,%edx
  mov    $0x1,%esi
  lea    D3(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  mov    $0x31,%edx
  mov    $0x1,%esi
  lea    D41(%rip),%rdi
  call   <fwrite@plt>
  mov    %r12,%rcx
  pop    %r12
  mov    $0x2e,%edx
  mov    $0x1,%esi
  lea    D42(%rip),%rdi
  jmp    1070 <fwrite@plt>
```

tool_calls: name: unpack_data
arguments: tag: D146
datatype: string
name: unpack_data
arguments: tag: D68
datatype: string
name: unpack_data
arguments: tag: D16
datatype: string
name: unpack_data
arguments: tag: D84
datatype: string
name: unpack_data
arguments: tag: D12
datatype: string
name: unpack_data
arguments: tag: D4
datatype: string
name: unpack_data
arguments: tag: D154
datatype: string
name: unpack_data
arguments: tag: D152
datatype: string
name: unpack_data
arguments: tag: D17
datatype: string
name: unpack_data
arguments: tag: D81
datatype: string
name: unpack_data
arguments: tag: D53
datatype: string
name: unpack_data
arguments: tag: D110
datatype: string
name: unpack_data
arguments: tag: D103
datatype: string
name: unpack_data
arguments: tag: D24
datatype: string
name: unpack_data
arguments: tag: D3
datatype: string
name: unpack_data
arguments: tag: D41
datatype: string
name: unpack_data
arguments: tag: D42
datatype: string

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


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


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


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


tool: D12: 	-l     : list all defined tests


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


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


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


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


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


tool: D53: 	         loop, default is 1 million


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


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


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


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


tool: D41: 	         explicitly specify the operand bitness


tool: D42: 	         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;
}
```