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

```asm
<solve_dobldobl_start_system>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %edi,%ebp
  lea    D88(%rip),%rdi
  push   %rbx
  sub    $0x18,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x8(%rsp)
  xor    %eax,%eax
  call   <puts@plt>
  xor    %eax,%eax
  call   <celcon_dobldobl_random_coefficient_system@plt>
  xor    %eax,%eax
  call   <celcon_dobldobl_polyhedral_homotopy@plt>
  lea    D83(%rip),%rdi
  call   <puts@plt>
  test   %ebp,%ebp
  jle    L128
  xor    %r14d,%r14d
  mov    $0x1,%ebx
  xor    %r13d,%r13d
  mov    %rsp,%r15
  lea    0x4(%rsp),%r12
  jmp    L51
  nopw   0x0(%rax,%rax,1)
L36:
  lea    D144(%rip),%rdi
  xor    %eax,%eax
  add    $0x1,%ebx
  call   <printf@plt>
  add    (%rsp),%r13d
  add    0x4(%rsp),%r14d
  cmp    %ebx,%ebp
  jl     L45
L51:
  mov    %r15,%rsi
  mov    %ebx,%edi
  call   <celcon_solve_dobldobl_start_system@plt>
  mov    (%rsp),%esi
  mov    %ebx,%edx
  xor    %eax,%eax
  lea    D22(%rip),%rdi
  call   <printf@plt>
  mov    %r12,%rsi
  mov    %ebx,%edi
  call   <celcon_mixed_volume@plt>
  mov    0x4(%rsp),%esi
  cmp    %esi,(%rsp)
  jne    L36
  lea    D11(%rip),%rdi
  xor    %eax,%eax
  add    $0x1,%ebx
  call   <printf@plt>
  add    (%rsp),%r13d
  add    0x4(%rsp),%r14d
  cmp    %ebx,%ebp
  jge    L51
L45:
  cmp    %r14d,%r13d
  je     L22
  lea    D44(%rip),%rdi
  mov    %r14d,%edx
  mov    %r13d,%esi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D111(%rip),%rdi
  call   <puts@plt>
L21:
  mov    $0x1,%r13d
  lea    D122(%rip),%r14
  nopw   0x0(%rax,%rax,1)
L31:
  mov    %r12,%rsi
  mov    %r13d,%edi
  call   <celcon_mixed_volume@plt>
  mov    0x4(%rsp),%edx
  test   %edx,%edx
  jle    L16
  mov    $0x1,%ebx
L29:
  mov    %ebx,%esi
  mov    %r13d,%edx
  mov    %r14,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %ebx,%esi
  xor    %edx,%edx
  mov    %r13d,%edi
  call   <celcon_track_dobldobl_solution_path@plt>
  add    $0x1,%ebx
  cmp    %ebx,0x4(%rsp)
  jge    L29
L16:
  add    $0x1,%r13d
  cmp    %r13d,%ebp
  jge    L31
  lea    D120(%rip),%rdi
  mov    $0x1,%r13d
  call   <puts@plt>
  nop
L84:
  mov    %r12,%rsi
  mov    %r13d,%edi
  call   <celcon_mixed_volume@plt>
  mov    0x4(%rsp),%eax
  test   %eax,%eax
  jle    L123
  mov    $0x1,%ebx
  nopl   0x0(%rax,%rax,1)
L54:
  mov    %ebx,%esi
  mov    %r13d,%edi
  add    $0x1,%ebx
  call   <celcon_copy_target_dobldobl_solution_to_container@plt>
  cmp    %ebx,0x4(%rsp)
  jge    L54
L123:
  add    $0x1,%r13d
  cmp    %r13d,%ebp
  jge    L84
L114:
  lea    D55(%rip),%rdi
  call   <puts@plt>
  xor    %eax,%eax
  call   <celcon_write_dobldobl_random_coefficient_system@plt>
  xor    %eax,%eax
  call   <solcon_write_dobldobl_solutions@plt>
  mov    0x8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L70
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L22:
  mov    %r13d,%edx
  mov    %r13d,%esi
  lea    D76(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D111(%rip),%rdi
  call   <puts@plt>
  jmp    L21
L128:
  xor    %edx,%edx
  xor    %esi,%esi
  lea    D76(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D111(%rip),%rdi
  call   <puts@plt>
  lea    D120(%rip),%rdi
  call   <puts@plt>
  jmp    L114
L70:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: data_tag: D88
type_infered: string
name: read_data
arguments: data_tag: D83
type_infered: string
name: read_data
arguments: data_tag: D144
type_infered: string
name: read_data
arguments: data_tag: D22
type_infered: string
name: read_data
arguments: data_tag: D11
type_infered: string
name: read_data
arguments: data_tag: D44
type_infered: string
name: read_data
arguments: data_tag: D111
type_infered: string
name: read_data
arguments: data_tag: D122
type_infered: string
name: read_data
arguments: data_tag: D120
type_infered: string
name: read_data
arguments: data_tag: D55
type_infered: string
name: read_data
arguments: data_tag: D76
type_infered: string

tool: D88: solving a random coefficient system with double doubles ...

tool: D83: solving the binomial start systems ...

tool: D144: #start solutions does not equal mixed volume %d!!!


tool: D22:  -> found %d start solutions from cell %d


tool: D11: #start solutions equals mixed volume %d, OK


tool: D44: Total #start solutions : %d /= %d mixed volume!!!


tool: D111: tracking the solution paths ...

tool: D122: Tracking path %d corresponding to cell %d ...


tool: D120: copying the target solutions to the solution container ...

tool: D55: writing random coefficient system and its solutions to file ...

tool: D76: Total #start solutions : %d = %d mixed volume, OK.


assistant: ```c
void solve_dobldobl_start_system(int len) {
  int fail, nb, tnb, k, tmv, mv, i;
  printf("solving a random coefficient system with double doubles ...\n");
  fail = celcon_dobldobl_random_coefficient_system();
  fail = celcon_dobldobl_polyhedral_homotopy();
  printf("solving the binomial start systems ...\n");
  tnb = 0;
  tmv = 0;
  for (k = 1; k <= len; k++) {
    fail = celcon_solve_dobldobl_start_system(k, &nb);
    printf(" -> found %d start solutions from cell %d\n", nb, k);
    fail = celcon_mixed_volume(k, &mv);
    if (nb == mv)
      printf("#start solutions equals mixed volume %d, OK\n", mv);
    else
      printf("#start solutions does not equal mixed volume %d!!!\n", mv);
    tnb += nb;
    tmv += mv;
  }
  if (tnb == tmv)
    printf("Total #start solutions : %d = %d mixed volume, OK.\n", tnb, tmv);
  else
    printf("Total #start solutions : %d /= %d mixed volume!!!\n", tnb, tmv);
  printf("tracking the solution paths ...\n");
  for (k = 1; k <= len; k++) {
    fail = celcon_mixed_volume(k, &mv);
    for (i = 1; i <= mv; i++) {
      printf("Tracking path %d corresponding to cell %d ...\n", i, k);
      fail = celcon_track_dobldobl_solution_path(k, i, 0);
    }
  }
  printf("copying the target solutions to the solution container ...\n");
  for (k = 1; k <= len; k++) {
    fail = celcon_mixed_volume(k, &mv);
    for (i = 1; i <= mv; i++)
      fail = celcon_copy_target_dobldobl_solution_to_container(k, i);
  }
  printf("writing random coefficient system and its solutions to file ...\n");
  fail = celcon_write_dobldobl_random_coefficient_system();
  fail = solcon_write_dobldobl_solutions();
}
```