user: Translate the below assembly code into C programming language:

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x20,%rsp
  mov    %edi,-0x14(%rbp)
  mov    %rsi,-0x20(%rbp)
  mov    %fs:0x28,%rax
  mov    %rax,-0x8(%rbp)
  xor    %eax,%eax
  movl   $0x0,-0xc(%rbp)
  lea    D83(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D66(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D43(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  cmpl   $0x2,-0x14(%rbp)
  je     L185
  cmpl   $0x3,-0x14(%rbp)
  je     L185
  mov    -0x20(%rbp),%rax
  mov    (%rax),%rax
  mov    %rax,%rsi
  lea    D41(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x20(%rbp),%rax
  mov    (%rax),%rax
  mov    %rax,%rsi
  lea    D88(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L224
L185:
  mov    -0x20(%rbp),%rax
  add    $0x8,%rax
  mov    (%rax),%rax
  lea    -0x10(%rbp),%rdx
  lea    D74(%rip),%rcx
  mov    %rcx,%rsi
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <sscanf@plt>
  mov    -0x10(%rbp),%eax
  cmp    $0xff,%eax
  jbe    L64
  lea    D73(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    $0x1,%eax
  jmp    L224
L64:
  cmpl   $0x3,-0x14(%rbp)
  jne    L170
  mov    -0x20(%rbp),%rax
  add    $0x10,%rax
  mov    (%rax),%rax
  lea    -0xc(%rbp),%rdx
  lea    D71(%rip),%rcx
  mov    %rcx,%rsi
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <sscanf@plt>
L170:
  mov    -0xc(%rbp),%eax
  cmp    $0x100,%eax
  jg     L32
  cmp    $0xc8,%eax
  jge    L75
  cmp    $0xc0,%eax
  jg     L32
  cmp    $0x88,%eax
  jge    L103
  cmp    $0x80,%eax
  jg     L32
  cmp    $0x50,%eax
  jge    L39
  test   %eax,%eax
  je     L202
  test   %eax,%eax
  js     L32
  cmp    $0x40,%eax
  jg     L32
  cmp    $0x20,%eax
  jge    L108
  jmp    L32
L75:
  sub    $0xc8,%eax
  movabs $0x100000001000001,%rdx
  mov    %eax,%ecx
  shr    %cl,%rdx
  mov    %rdx,%rax
  and    $0x1,%eax
  test   %rax,%rax
  setne  %al
  test   %al,%al
  jne    L202
  jmp    L32
L103:
  sub    $0x88,%eax
  movabs $0x100010001010101,%rdx
  mov    %eax,%ecx
  shr    %cl,%rdx
  mov    %rdx,%rax
  and    $0x1,%eax
  test   %rax,%rax
  setne  %al
  test   %al,%al
  jne    L202
  jmp    L32
L39:
  sub    $0x50,%eax
  movabs $0x1010101010001,%rdx
  mov    %eax,%ecx
  shr    %cl,%rdx
  mov    %rdx,%rax
  and    $0x1,%eax
  test   %rax,%rax
  setne  %al
  test   %al,%al
  jne    L202
  jmp    L32
L108:
  sub    $0x20,%eax
  movabs $0x101000001,%rdx
  mov    %eax,%ecx
  shr    %cl,%rdx
  mov    %rdx,%rax
  and    $0x1,%eax
  test   %rax,%rax
  setne  %al
  test   %al,%al
  jne    L202
L32:
  movl   $0xffffffff,-0xc(%rbp)
  jmp    L55
L202:
  nop
L55:
  mov    -0xc(%rbp),%edx
  mov    -0x10(%rbp),%eax
  mov    %eax,%esi
  lea    D47(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x0,%eax
  call   <init_part_sum_bitarrays@plt>
  mov    -0xc(%rbp),%eax
  mov    %eax,%edi
  call   <init_sum_bitarray@plt>
  mov    -0xc(%rbp),%edx
  mov    -0x10(%rbp),%eax
  mov    %edx,%esi
  mov    %eax,%edi
  call   <precalculate_bit0_bitflip_bitarrays@plt>
  mov    $0x0,%eax
  call   <free_sum_bitarray@plt>
  mov    $0x0,%eax
  call   <free_part_sum_bitarrays@plt>
  mov    $0x0,%eax
L224:
  mov    -0x8(%rbp),%rdx
  sub    %fs:0x28,%rdx
  je     L136
  call   <__stack_chk_fail@plt>
L136:
  leave
  ret
```

tool_calls: name: parse_data
arguments: data_label: D83
type: string
name: parse_data
arguments: data_label: D66
type: string
name: parse_data
arguments: data_label: D43
type: string
name: parse_data
arguments: data_label: D41
type: string
name: parse_data
arguments: data_label: D88
type: string
name: parse_data
arguments: data_label: D74
type: string
name: parse_data
arguments: data_label: D73
type: string
name: parse_data
arguments: data_label: D71
type: string
name: parse_data
arguments: data_label: D47
type: string

tool: D83: Create tables required by hardnested attack.

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

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


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



tool: D88:  example: %s 1f


tool: D74: %x

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


tool: D71: %d

tool: D47: Calculating for bitflip = %02x, sum_a0 = %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;
}
```