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

```asm
<solve_dobldobl_start_system>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %edi,%ebp
  lea    D106(%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    D20(%rip),%rdi
  call   <puts@plt>
  test   %ebp,%ebp
  jle    L32
  xor    %r14d,%r14d
  mov    $0x1,%ebx
  xor    %r13d,%r13d
  mov    %rsp,%r15
  lea    0x4(%rsp),%r12
  nopl   (%rax)
L97:
  mov    %r15,%rsi
  mov    %ebx,%edi
  call   <celcon_solve_dobldobl_start_system@plt>
  mov    (%rsp),%esi
  mov    %ebx,%edx
  xor    %eax,%eax
  lea    D74(%rip),%rdi
  call   <printf@plt>
  mov    %r12,%rsi
  mov    %ebx,%edi
  call   <celcon_mixed_volume@plt>
  mov    0x4(%rsp),%esi
  cmp    %esi,(%rsp)
  je     L71
  lea    D44(%rip),%rdi
  xor    %eax,%eax
  add    $0x1,%ebx
  call   <printf@plt>
  add    (%rsp),%r13d
  add    0x4(%rsp),%r14d
  cmp    %ebx,%ebp
  jge    L97
  cmp    %r14d,%r13d
  je     L96
L56:
  lea    D57(%rip),%rdi
  mov    %r14d,%edx
  mov    %r13d,%esi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D19(%rip),%rdi
  call   <puts@plt>
L46:
  mov    $0x1,%r13d
  lea    D147(%rip),%r14
L68:
  mov    %r12,%rsi
  mov    %r13d,%edi
  call   <celcon_mixed_volume@plt>
  mov    0x4(%rsp),%edx
  test   %edx,%edx
  jle    L107
  mov    $0x1,%ebx
  nopl   0x0(%rax,%rax,1)
L118:
  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    L118
L107:
  add    $0x1,%r13d
  cmp    %r13d,%ebp
  jge    L68
  lea    D40(%rip),%rdi
  mov    $0x1,%r13d
  call   <puts@plt>
  nop
L121:
  mov    %r12,%rsi
  mov    %r13d,%edi
  call   <celcon_mixed_volume@plt>
  mov    0x4(%rsp),%eax
  test   %eax,%eax
  jle    L122
  mov    $0x1,%ebx
  nopl   0x0(%rax,%rax,1)
L133:
  mov    %ebx,%esi
  mov    %r13d,%edi
  add    $0x1,%ebx
  call   <celcon_copy_target_dobldobl_solution_to_container@plt>
  cmp    %ebx,0x4(%rsp)
  jge    L133
L122:
  add    $0x1,%r13d
  cmp    %r13d,%ebp
  jge    L121
L59:
  lea    D32(%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    L119
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L71:
  lea    D69(%rip),%rdi
  xor    %eax,%eax
  add    $0x1,%ebx
  call   <printf@plt>
  add    (%rsp),%r13d
  add    0x4(%rsp),%r14d
  cmp    %ebp,%ebx
  jle    L97
  cmp    %r14d,%r13d
  jne    L56
L96:
  mov    %r13d,%edx
  mov    %r13d,%esi
  lea    D27(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D19(%rip),%rdi
  call   <puts@plt>
  jmp    L46
L32:
  xor    %edx,%edx
  xor    %esi,%esi
  lea    D27(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D19(%rip),%rdi
  call   <puts@plt>
  lea    D40(%rip),%rdi
  call   <puts@plt>
  jmp    L59
L119:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: data_label: D106
type_infered: string
name: parse_data
arguments: data_label: D20
type_infered: string
name: parse_data
arguments: data_label: D74
type_infered: string
name: parse_data
arguments: data_label: D44
type_infered: string
name: parse_data
arguments: data_label: D57
type_infered: string
name: parse_data
arguments: data_label: D19
type_infered: string
name: parse_data
arguments: data_label: D147
type_infered: string
name: parse_data
arguments: data_label: D40
type_infered: string
name: parse_data
arguments: data_label: D32
type_infered: string
name: parse_data
arguments: data_label: D69
type_infered: string
name: parse_data
arguments: data_label: D27
type_infered: string

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

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

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


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


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


tool: D19: tracking the solution paths ...

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


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

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

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


tool: D27: 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();
}
```