user: 请显示与下面列出的汇编代码相匹配的C语言实现：

```asm
<main>:
  endbr64
  push   %rbp
  mov    %edi,%ebp
  lea    D35(%rip),%rdi
  push   %rbx
  mov    %rsi,%rbx
  sub    $0x18,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x8(%rsp)
  xor    %eax,%eax
  movl   $0x0,0x4(%rsp)
  call   <puts@plt>
  lea    D75(%rip),%rdi
  call   <puts@plt>
  lea    D29(%rip),%rdi
  call   <puts@plt>
  lea    -0x2(%rbp),%eax
  cmp    $0x1,%eax
  ja     L120
  mov    0x8(%rbx),%rdi
  xor    %eax,%eax
  mov    %rsp,%rdx
  lea    D73(%rip),%rsi
  call   <sscanf@plt>
  cmpl   $0xff,(%rsp)
  ja     L36
  cmp    $0x3,%ebp
  je     L14
L153:
  mov    0x4(%rsp),%edx
  cmp    $0x80,%edx
  jg     L101
  cmp    $0x4f,%edx
  jg     L82
  test   %edx,%edx
  je     L93
  lea    -0x20(%rdx),%ecx
  cmp    $0x20,%ecx
  ja     L64
  movabs $0x101000001,%rax
  shr    %cl,%rax
  test   $0x1,%al
  jne    L93
L64:
  movl   $0xffffffff,0x4(%rsp)
  or     $0xffffffff,%edx
L93:
  mov    (%rsp),%esi
  lea    D54(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  call   <init_part_sum_bitarrays@plt>
  mov    0x4(%rsp),%edi
  call   <init_sum_bitarray@plt>
  mov    0x4(%rsp),%esi
  mov    (%rsp),%edi
  call   <precalculate_bit0_bitflip_bitarrays@plt>
  xor    %eax,%eax
  call   <free_sum_bitarray@plt>
  xor    %eax,%eax
  call   <free_part_sum_bitarrays@plt>
  xor    %eax,%eax
L208:
  mov    0x8(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L5
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  ret
L82:
  movabs $0x1010101010001,%rax
  lea    -0x50(%rdx),%ecx
  shr    %cl,%rax
  test   $0x1,%al
  je     L64
  jmp    L93
L101:
  cmp    $0xc0,%edx
  jg     L137
  cmp    $0x87,%edx
  jle    L64
  movabs $0x100010001010101,%rax
  lea    -0x88(%rdx),%ecx
  shr    %cl,%rax
  test   $0x1,%al
  je     L64
  jmp    L93
L137:
  lea    -0xc8(%rdx),%ecx
  cmp    $0x38,%ecx
  ja     L64
  movabs $0x100000001000001,%rax
  shr    %cl,%rax
  test   $0x1,%al
  je     L64
  jmp    L93
L120:
  mov    (%rbx),%rsi
  lea    D31(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    (%rbx),%rsi
  lea    D11(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L208
L36:
  lea    D12(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%eax
  jmp    L208
L14:
  mov    0x10(%rbx),%rdi
  lea    0x4(%rsp),%rdx
  lea    D41(%rip),%rsi
  xor    %eax,%eax
  call   <sscanf@plt>
  jmp    L153
L5:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: data_tag: D35
type_guessed: string
name: disassemble_data
arguments: data_tag: D75
type_guessed: string
name: disassemble_data
arguments: data_tag: D29
type_guessed: string
name: disassemble_data
arguments: data_tag: D73
type_guessed: string
name: disassemble_data
arguments: data_tag: D54
type_guessed: string
name: disassemble_data
arguments: data_tag: D31
type_guessed: string
name: disassemble_data
arguments: data_tag: D11
type_guessed: string
name: disassemble_data
arguments: data_tag: D12
type_guessed: string
name: disassemble_data
arguments: data_tag: D41
type_guessed: string

tool: D35: Create tables required by hardnested attack.

tool: D75: Expect a runtime in the range of days or weeks.

tool: D29: Single thread only. If you want to use several threads, start it multiple times :-)


tool: D73: %x

tool: D54: Calculating for bitflip = %02x, sum_a0 = %d


tool: D31:  syntax: %s <bitflip property> [<Sum_a0>]



tool: D11:  example: %s 1f


tool: D12: Bitflip property must be less than or equal to 0xff


tool: D41: %d

assistant: ```c
int main(int argc, char *argv[]) {
  unsigned int bitflip_in;
  int sum_a0 = 0;
  printf("Create tables required by hardnested attack.\n");
  printf("Expect a runtime in the range of days or weeks.\n");
  printf("Single thread only. If you want to use several threads, start it multiple times :-)\n\n");
  if (argc != 2 && argc != 3) {
    printf(" syntax: %s <bitflip property> [<Sum_a0>]\n\n", argv[0]);
    printf(" example: %s 1f\n", argv[0]);
    return 1;
  }
  sscanf(argv[1], "%x", &bitflip_in);
  if (bitflip_in > 255) {
    printf("Bitflip property must be less than or equal to 0xff\n\n");
    return 1;
  }
  if (argc == 3) {
    sscanf(argv[2], "%d", &sum_a0);
  }
  switch (sum_a0) {
  case 0:
  case 32:
  case 56:
  case 64:
  case 80:
  case 96:
  case 104:
  case 112:
  case 120:
  case 128:
  case 136:
  case 144:
  case 152:
  case 160:
  case 176:
  case 192:
  case 200:
  case 224:
  case 256:
    break;
  default:
    sum_a0 = -1;
  }
  printf("Calculating for bitflip = %02x, sum_a0 = %d\n", bitflip_in, sum_a0);
  init_part_sum_bitarrays();
  init_sum_bitarray(sum_a0);
  precalculate_bit0_bitflip_bitarrays(bitflip_in, sum_a0);
  free_sum_bitarray();
  free_part_sum_bitarrays();
  return 0;
}
```