user: 请从给定的汇编指令推导出C源代码:

```asm
<main>:
  endbr64
  push   %r12
  lea    D145(%rip),%rdi
  mov    $0x1,%r12d
  push   %rbp
  lea    D28(%rip),%rbp
  push   %rbx
  lea    D157(%rip),%rbx
  sub    $0x20,%rsp
  call   <puts@plt>
  lea    D78(%rip),%rdi
  call   <puts@plt>
  lea    D164(%rip),%rdi
  call   <puts@plt>
  pxor   %xmm0,%xmm0
  mov    %rbx,%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  nopl   (%rax)
L74:
  mov    %r12d,%edx
  xor    %eax,%eax
  cmp    $0x80,%r12d
  je     L27
  nopw   0x0(%rax,%rax,1)
L31:
  add    %edx,%edx
  mov    %eax,%ecx
  add    $0x1,%eax
  cmp    $0x80,%edx
  jle    L31
  sub    $0x6,%ecx
  pxor   %xmm0,%xmm0
  cvtsi2sd %ecx,%xmm0
L28:
  mov    %rbx,%rdi
  mov    $0x1,%eax
  add    $0x1,%r12d
  call   <printf@plt>
  cmp    $0x81,%r12d
  jne    L74
  mov    $0x1,%eax
  mov    $0xfffffe82,%r12d
  lea    0x1(%rax),%ebp
  cmp    $0x7f,%eax
  ja     L6
  nopw   0x0(%rax,%rax,1)
L14:
  add    %eax,%eax
  cmp    $0x7f,%eax
  jle    L14
  lea    -0x180(%rax,%rax,1),%eax
  pxor   %xmm0,%xmm0
  mov    %rbx,%rdi
  cvtsi2sd %eax,%xmm0
  mov    $0x1,%eax
  call   <printf@plt>
L49:
  mov    %ebp,%eax
  add    $0x2,%r12d
  lea    0x1(%rax),%ebp
  cmp    $0x7f,%eax
  jbe    L14
L6:
  pxor   %xmm0,%xmm0
  mov    %rbx,%rdi
  mov    $0x1,%eax
  cvtsi2sd %r12d,%xmm0
  call   <printf@plt>
  cmp    $0x81,%ebp
  jne    L49
  lea    D154(%rip),%rdi
  mov    $0x40,%r12d
  lea    D143(%rip),%rbx
  call   <puts@plt>
  pxor   %xmm4,%xmm4
  pxor   %xmm2,%xmm2
  movsd  D108(%rip),%xmm1
  cvtsi2sd %r12d,%xmm2
  movsd  %xmm4,(%rsp)
  lea    D138(%rip),%rbp
  jmp    L77
  nopl   0x0(%rax,%rax,1)
L80:
  pxor   %xmm2,%xmm2
  movsd  D117(%rip),%xmm0
  movsd  D105(%rip),%xmm3
  cvtsi2sd %r12d,%xmm2
  movsd  D107(%rip),%xmm5
  divsd  %xmm2,%xmm0
  movapd %xmm0,%xmm1
  andpd  %xmm3,%xmm1
  ucomisd %xmm1,%xmm5
  jbe    L54
  cvttsd2si %xmm0,%rax
  pxor   %xmm1,%xmm1
  movapd %xmm0,%xmm5
  movsd  D66(%rip),%xmm7
  andnpd %xmm0,%xmm3
  cvtsi2sd %rax,%xmm1
  cmpnlesd %xmm1,%xmm5
  andpd  %xmm7,%xmm5
  addsd  %xmm5,%xmm1
  orpd   %xmm3,%xmm1
  movapd %xmm1,%xmm0
L54:
  movapd %xmm0,%xmm1
L77:
  cvttsd2si %xmm1,%rax
  pxor   %xmm0,%xmm0
  mov    %rbx,%rdi
  add    $0x1,%r12d
  movsd  %xmm2,0x18(%rsp)
  movsd  %xmm4,0x10(%rsp)
  movsd  %xmm1,0x8(%rsp)
  mov    %eax,%eax
  cvtsi2sd %rax,%xmm0
  mov    $0x1,%eax
  call   <printf@plt>
  movsd  0x18(%rsp),%xmm2
  movsd  D117(%rip),%xmm3
  movsd  0x8(%rsp),%xmm1
  movsd  0x10(%rsp),%xmm4
  divsd  %xmm2,%xmm3
  subsd  %xmm3,%xmm1
  mulsd  %xmm1,%xmm2
  movapd %xmm1,%xmm6
  mulsd  D59(%rip),%xmm2
  maxsd  %xmm4,%xmm6
  maxsd  (%rsp),%xmm2
  movapd %xmm6,%xmm4
  movsd  %xmm2,(%rsp)
  cmp    $0x80,%r12d
  je     L72
  cmp    $0x60,%r12d
  jne    L80
  mov    %rbp,%rdi
  movsd  %xmm4,0x8(%rsp)
  call   <puts@plt>
  movsd  0x8(%rsp),%xmm4
  jmp    L80
  nopl   (%rax)
L27:
  mov    %rbp,%rdi
  call   <puts@plt>
  mov    D31(%rip),%rax
  movq   %rax,%xmm0
  jmp    L28
L72:
  movapd %xmm2,%xmm1
  movapd %xmm6,%xmm0
  mov    $0x2,%eax
  lea    D0(%rip),%rdi
  call   <printf@plt>
  xor    %edi,%edi
  call   <exit@plt>
  add    $0x20,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
```

tool_calls: name: read_data
arguments: data_label: D145
type_infered: string
name: read_data
arguments: data_label: D28
type_infered: string
name: read_data
arguments: data_label: D157
type_infered: string
name: read_data
arguments: data_label: D78
type_infered: string
name: read_data
arguments: data_label: D164
type_infered: string
name: read_data
arguments: data_label: D154
type_infered: string
name: read_data
arguments: data_label: D143
type_infered: string
name: read_data
arguments: data_label: D108
type_infered: f32[2]
name: read_data
arguments: data_label: D138
type_infered: string
name: read_data
arguments: data_label: D117
type_infered: f32[2]
name: read_data
arguments: data_label: D105
type_infered: byte[8]
name: read_data
arguments: data_label: D107
type_infered: f32[2]
name: read_data
arguments: data_label: D66
type_infered: f32[2]
name: read_data
arguments: data_label: D59
type_infered: f32[2]
name: read_data
arguments: data_label: D31
type_infered: f32[2]
name: read_data
arguments: data_label: D0
type_infered: string

tool: D145: /* This table has been generated by divtab-sh4.c.  */

tool: D28: /* Lookup table translating positive divisor to index into table of
   normalized inverse.  N.B. the '0' entry is also the last entry of the
 previous table, and causes an unaligned access for division by zero.  */
LOCAL(div_table_ix):

tool: D157: 	.byte	%d


tool: D78: 	.balign 4

tool: D164: LOCAL(div_table_clz):

tool: D154: /* 1/64 .. 1/127, normalized.  There is an implicit leading 1 in bit 32.  */
	.balign 4
LOCAL(zero_l):

tool: D143: 	.long	0x%X


tool: {"D108": [0.0,32.0]}

tool: D138: LOCAL(div_table):

tool: {"D117": [0.0,56.0]}

tool: {"D105": [0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f]}

tool: {"D107": [0.0,176.0]}

tool: {"D66": [0.0,1.875]}

tool: {"D59": [0.0,1.0]}

tool: {"D31": [0.0,-2.375]}

tool: D0: 	/* maximum error: %f scaled: %f*/


assistant: ```c
int main() {
  int i, j;
  double q, r, err, max_err = 0, max_s_err = 0;
  puts("/* This table has been generated by divtab-sh4.c.  */");
  puts("\t.balign 4");
  puts("LOCAL(div_table_clz):");
  printf("\t.byte\t%d\n", 0);
  for (i = 1; i <= 128; i++) {
    int n = 0;
    if (i == 128)
      puts("/* Lookup table translating positive divisor to index into table of\n   normalized inverse.  N.B. the '0' entry is also the last entry of the\n previous table, and causes an unaligned access for division by zero.  */\nLOCAL(div_table_ix):");
    for (j = i; j <= 128; j += j)
      n++;
    printf("\t.byte\t%d\n", n - 7);
  }
  for (i = 1; i <= 128; i++) {
    j = i < 0 ? -i : i;
    while (j < 128)
      j += j;
    printf("\t.byte\t%d\n", j * 2 - 96 * 4);
  }
  puts("/* 1/64 .. 1/127, normalized.  There is an implicit leading 1 in bit 32.  */\n	.balign 4\nLOCAL(zero_l):");
  for (i = 64; i < 128; i++) {
    if (i == 96)
      puts("LOCAL(div_table):");
    q = 4. * (1 << 30) * 128 / i;
    r = ceil(q);
    printf("\t.long\t0x%X\n", (unsigned)r);
    err = r - q;
    if (err > max_err)
      max_err = err;
    err = err * i / 128;
    if (err > max_s_err)
      max_s_err = err;
  }
  printf("\t/* maximum error: %f scaled: %f*/\n", max_err, max_s_err);
  exit(0);
}
```