user: What would the C source look like for the assembly code provided here:

```asm
<printTimingInfo>:
  endbr64
  push   %r13
  push   %r12
  push   %rbp
  lea    D76(%rip),%rbp
  sub    $0x30,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x28(%rsp)
  xor    %eax,%eax
  lea    0x20(%rsp),%rsi
  lea    0x18(%rsp),%rdi
  call   <soar_cDetermineTimerResolution@plt>
  lea    D11(%rip),%rdi
  xor    %eax,%eax
  lea    0x14(%rsp),%r12
  movsd  %xmm0,0x8(%rsp)
  lea    0x10(%rsp),%r13
  call   <print@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D180(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D167(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D160(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D103(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D75(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D7(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D21(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D138(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D22(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D87(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <print@plt>
  movsd  0x8(%rsp),%xmm0
  mov    $0x1,%eax
  lea    D173(%rip),%rdi
  call   <print@plt>
  movsd  0x18(%rsp),%xmm0
  mov    $0x1,%eax
  lea    D31(%rip),%rdi
  call   <print@plt>
  movsd  0x20(%rsp),%xmm0
  mov    $0x1,%eax
  lea    D159(%rip),%rdi
  call   <print@plt>
  xor    %eax,%eax
  mov    %rbp,%rdi
  call   <print@plt>
  lea    D114(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  lea    D64(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  mov    %r12,%rdi
  call   <reset_timer@plt>
  mov    %r13,%rdi
  call   <start_timer@plt>
  mov    $0x3,%edi
  call   <sleep@plt>
  mov    %r12,%rsi
  mov    %r13,%rdi
  call   <stop_timer@plt>
  lea    D125(%rip),%rdi
  xor    %eax,%eax
  call   <print@plt>
  mov    %r12,%rdi
  call   <timer_value@plt>
  lea    D105(%rip),%rdi
  mov    %eax,%esi
  xor    %eax,%eax
  call   <print@plt>
  xor    %eax,%eax
  mov    %rbp,%rdi
  call   <print@plt>
  mov    0x28(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L4
  add    $0x30,%rsp
  mov    $0x1,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
L4:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D76
datatype: string
name: unpack_data
arguments: label: D11
datatype: string
name: unpack_data
arguments: label: D180
datatype: string
name: unpack_data
arguments: label: D167
datatype: string
name: unpack_data
arguments: label: D160
datatype: string
name: unpack_data
arguments: label: D103
datatype: string
name: unpack_data
arguments: label: D75
datatype: string
name: unpack_data
arguments: label: D7
datatype: string
name: unpack_data
arguments: label: D21
datatype: string
name: unpack_data
arguments: label: D138
datatype: string
name: unpack_data
arguments: label: D22
datatype: string
name: unpack_data
arguments: label: D87
datatype: string
name: unpack_data
arguments: label: D173
datatype: string
name: unpack_data
arguments: label: D31
datatype: string
name: unpack_data
arguments: label: D159
datatype: string
name: unpack_data
arguments: label: D114
datatype: string
name: unpack_data
arguments: label: D64
datatype: string
name: unpack_data
arguments: label: D125
datatype: string
name: unpack_data
arguments: label: D105
datatype: string

tool: D76: ---------------------------------------------------------------


tool: D11: Using system timers...


tool: D180: A timing loop is used to obtain the following values.


tool: D167: At least one additional instruction takes place between


tool: D160: starting and stopping the timers, thus a perfectly accurate


tool: D103: timer which costs nothing to invoke would still accumulate


tool: D75: non-zero value. The loop runs for a total of ~2 seconds as 


tool: D7: a result, the Maximum timer value is likely to be relatively 


tool: D21: large, but should be < 2 seconds


tool: D138: ** NOTE: If the code was optimized, the timing loop may yield


tool: D22:          unanticipated results.  If both minimum values are


tool: D87:          zero, it is unclear what the timer resolution is...


tool: D173: Minimum (Non-Zero) Timer Value: %11.5e sec


tool: D31: Minimum Timer Value           : %11.5e sec


tool: D159: Maximum Timer Value           : %11.5e sec



tool: D114: A short delay will be issued using the sleep() command, and 


tool: D64: timed using Soar's timers....


tool: D125: Sleep interval  -->   3 seconds


tool: D105: Timers report   -->  %8.5f seconds


assistant: ```c
int printTimingInfo() {
  struct timeval start, stop;
  double min, max, min_nz;
  min_nz = soar_cDetermineTimerResolution(&min, &max);
  print("Using system timers...\n");
  print("---------------------------------------------------------------\n");
  print("A timing loop is used to obtain the following values.\n");
  print("At least one additional instruction takes place between\n");
  print("starting and stopping the timers, thus a perfectly accurate\n");
  print("timer which costs nothing to invoke would still accumulate\n");
  print("non-zero value. The loop runs for a total of ~2 seconds as \n");
  print("a result, the Maximum timer value is likely to be relatively \n");
  print("large, but should be < 2 seconds\n");
  print("** NOTE: If the code was optimized, the timing loop may yield\n");
  print("         unanticipated results.  If both minimum values are\n");
  print("         zero, it is unclear what the timer resolution is...\n");
  print("---------------------------------------------------------------\n");
  print("Minimum (Non-Zero) Timer Value: %11.5e sec\n", min_nz);
  print("Minimum Timer Value           : %11.5e sec\n", min);
  print("Maximum Timer Value           : %11.5e sec\n\n", max);
  print("---------------------------------------------------------------\n");
  print("A short delay will be issued using the sleep() command, and \n");
  print("timed using Soar's timers....\n");
  reset_timer(&stop);
  start_timer(&start);
  sleep(3);
  stop_timer(&start, &stop);
  print("Sleep interval  -->   3 seconds\n");
  print("Timers report   -->  %8.5f seconds\n", timer_value(&stop));
  print("---------------------------------------------------------------\n");
  return 1;
}
```