user: Converte this assembly snippet into its equivalent C code:

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rsi,%rbx
  sub    $0x58,%rsp
  cmp    $0x1,%edi
  je     L83
  mov    0x8(%rsi),%rdi
  call   <get_h_size@plt>
  mov    0x8(%rbx),%rdi
  mov    %eax,%r15d
  mov    %eax,0x24(%rsp)
  call   <get_v_size@plt>
  mov    0x8(%rbx),%rdi
  mov    %eax,%r12d
  call   <get_l_size@plt>
  mov    0x8(%rbx),%rsi
  mov    %r15d,%edi
  mov    %eax,%r14d
  mov    %eax,0x20(%rsp)
  call   <load_H@plt>
  mov    0x8(%rbx),%rsi
  mov    %r12d,%edi
  mov    %rax,0x8(%rsp)
  call   <load_V@plt>
  mov    0x8(%rbx),%rsi
  mov    %r12d,%edi
  mov    %rax,0x10(%rsp)
  call   <load_T@plt>
  mov    0x8(%rbx),%rdx
  mov    %r14d,%esi
  mov    %r15d,%edi
  mov    %rax,0x18(%rsp)
  call   <load_G@plt>
  mov    0x8(%rbx),%rsi
  mov    %r14d,%edi
  mov    %rax,0x28(%rsp)
  call   <load_K@plt>
  xor    %edi,%edi
  mov    %rax,0x30(%rsp)
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  xor    %edi,%edi
  call   <time@plt>
  mov    %rax,%rdi
  call   <srand48@plt>
  xor    %eax,%eax
  call   <check_instance@plt>
  test   %rax,%rax
  jne    L65
  mov    0x10(%rsp),%r15
  mov    0x24(%rsp),%r14d
  mov    %r12d,%edx
  mov    $0x64,%edi
  mov    $0x1,%r8d
  mov    %r15,%rcx
  mov    %r14d,%esi
  call   <initialization@plt>
  mov    0x8(%rsp),%rsi
  mov    %r14d,%r8d
  mov    %r15,%rdx
  mov    %r12d,%r9d
  mov    $0x64,%ecx
  mov    %rax,%rdi
  mov    %rax,%r13
  call   <load_utilization@plt>
  mov    0x20(%rsp),%r8d
  mov    %r13,%rdi
  mov    %r12d,%r9d
  mov    0x18(%rsp),%rdx
  mov    0x28(%rsp),%rsi
  mov    $0x64,%ecx
  mov    %rax,%rbp
  call   <load_network_utilization@plt>
  mov    %r14d,%r9d
  mov    %r13,%rdi
  mov    %rbp,%rsi
  push   %rcx
  mov    %rax,%rbx
  mov    %r15,%rcx
  mov    $0x64,%r8d
  push   0x20(%rsp)
  push   0x38(%rsp)
  mov    0x38(%rsp),%eax
  push   %rax
  push   %rbx
  push   0x58(%rsp)
  push   $0x1
  push   %r12
  mov    0x48(%rsp),%rdx
  call   <reparation@plt>
  add    $0x38,%rsp
  mov    %r15,%rcx
  mov    %rbp,%rsi
  mov    %rax,%r13
  mov    0x28(%rsp),%eax
  mov    $0x64,%r9d
  xor    %r15d,%r15d
  mov    %r13,%rdi
  push   %rax
  push   %rbx
  push   0x48(%rsp)
  push   %r12
  push   %r14
  mov    0x48(%rsp),%r8
  mov    0x38(%rsp),%rdx
  call   <load_objectives@plt>
  add    $0x30,%rsp
  mov    $0x64,%esi
  mov    %rax,%rdi
  mov    %rax,%r14
  call   <non_dominated_sorting@plt>
  xor    %edi,%edi
  mov    %rax,%rbx
  jmp    L1
  nopl   0x0(%rax)
L30:
  add    $0x1,%r15
  cmp    $0x64,%r15
  je     L21
L1:
  cmpl   $0x1,(%rbx,%r15,4)
  jne    L30
  mov    (%r14,%r15,8),%rcx
  mov    0x0(%r13,%r15,8),%rdx
  mov    %r12d,%esi
  add    $0x1,%r15
  call   <pareto_insert@plt>
  mov    %rax,%rdi
  cmp    $0x64,%r15
  jne    L1
L21:
  mov    0x24(%rsp),%r15d
  mov    0x10(%rsp),%rcx
  mov    %r12d,%edx
  mov    %rdi,%rbp
  mov    $0x1,%r8d
  mov    $0x64,%edi
  mov    %r15d,%esi
  call   <initialization@plt>
  movsd  D27(%rip),%xmm0
  mov    %rbx,%rdi
  mov    $0x64,%esi
  mov    %rax,0x38(%rsp)
  call   <selection@plt>
  mov    %rbx,%rdi
  mov    $0x64,%esi
  mov    %eax,0x24(%rsp)
  mov    D27(%rip),%rax
  movq   %rax,%xmm0
  call   <selection@plt>
  mov    0x24(%rsp),%esi
  mov    0x38(%rsp),%rdi
  mov    %r12d,%ecx
  mov    %eax,%edx
  call   <crossover@plt>
  mov    0x10(%rsp),%rsi
  mov    %r15d,%ecx
  mov    %r12d,%r8d
  mov    %rax,%rdi
  mov    $0x64,%edx
  call   <mutation@plt>
  mov    0x10(%rsp),%rdx
  mov    %r15d,%r8d
  mov    %r12d,%r9d
  mov    0x8(%rsp),%rsi
  mov    %rax,%rdi
  mov    $0x64,%ecx
  mov    %r15d,0x24(%rsp)
  mov    %rax,0x38(%rsp)
  call   <load_utilization@plt>
  mov    0x18(%rsp),%rdx
  mov    0x38(%rsp),%rdi
  mov    %r12d,%r9d
  mov    0x20(%rsp),%r8d
  mov    0x28(%rsp),%rsi
  mov    $0x64,%ecx
  mov    %rax,%r15
  mov    %rdi,0x40(%rsp)
  call   <load_network_utilization@plt>
  mov    %r15,%rsi
  mov    $0x64,%r8d
  push   %rdx
  mov    %rax,%r10
  push   0x20(%rsp)
  push   0x38(%rsp)
  mov    0x38(%rsp),%eax
  push   %rax
  push   %r10
  mov    %r10,0x60(%rsp)
  push   0x58(%rsp)
  push   $0x1
  push   %r12
  mov    0x64(%rsp),%r9d
  mov    0x80(%rsp),%rdi
  mov    0x50(%rsp),%rcx
  mov    0x48(%rsp),%rdx
  call   <reparation@plt>
  mov    0x60(%rsp),%esi
  add    $0x38,%rsp
  mov    $0x64,%r9d
  mov    %rax,%r11
  push   %rsi
  mov    0x48(%rsp),%r10
  mov    %r15,%rsi
  mov    %r11,%rdi
  xor    %r15d,%r15d
  push   %r10
  push   0x48(%rsp)
  push   %r12
  mov    0x4c(%rsp),%eax
  push   %rax
  mov    0x48(%rsp),%r8
  mov    0x40(%rsp),%rcx
  mov    0x38(%rsp),%rdx
  mov    %r11,0x78(%rsp)
  call   <load_objectives@plt>
  add    $0x30,%rsp
  mov    $0x64,%esi
  mov    %rax,%rdi
  mov    %rax,0x40(%rsp)
  call   <non_dominated_sorting@plt>
  mov    %r13,0x30(%rsp)
  mov    %rbp,%rdi
  mov    0x40(%rsp),%r13
  mov    %rbx,0x38(%rsp)
  mov    0x48(%rsp),%rbp
  mov    %rax,%rbx
  jmp    L58
  nopl   0x0(%rax)
L93:
  add    $0x1,%r15
  cmp    $0x64,%r15
  je     L12
L58:
  cmpl   $0x1,(%rbx,%r15,4)
  jne    L93
  mov    0x0(%r13,%r15,8),%rcx
  mov    0x0(%rbp,%r15,8),%rdx
  mov    %r12d,%esi
  add    $0x1,%r15
  call   <pareto_insert@plt>
  mov    %rax,%rdi
  cmp    $0x64,%r15
  jne    L58
L12:
  mov    0x38(%rsp),%rbx
  mov    %r13,%r10
  mov    0x30(%rsp),%r13
  push   %rax
  push   %r12
  mov    %rbp,%r11
  mov    %r10,%rcx
  mov    %rdi,%rbp
  mov    %r11,%rsi
  mov    $0x64,%r9d
  mov    %rbx,%r8
  mov    %r14,%rdx
  mov    %r13,%rdi
  call   <population_evolution@plt>
  mov    0x30(%rsp),%eax
  mov    %r12d,%r9d
  mov    %rbp,%rdi
  push   %rax
  mov    0x3c(%rsp),%eax
  push   %rax
  mov    0x30(%rsp),%r8
  mov    0x28(%rsp),%rcx
  mov    0x38(%rsp),%rdx
  mov    0x48(%rsp),%rsi
  call   <report_best_population@plt>
  add    $0x20,%rsp
  mov    $0xa,%edi
  call   <putchar@plt>
  xor    %eax,%eax
  jmp    L85
L65:
  lea    D39(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%eax
L85:
  add    $0x58,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L83:
  mov    (%rsi),%rsi
  lea    D3(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L85
```

tool_calls: name: unpack_data
arguments: tag: D27
type: f64
name: unpack_data
arguments: tag: D39
type: string
name: unpack_data
arguments: tag: D3
type: string

tool: D27: 0.5

tool: D39: 
The problem has no solution, call Amazon EC2

tool: D3: [ERROR] usage: %s datacenter_file


assistant: ```c
int main(int argc, char *argv[]) {
  if (argc == 1) {
    printf("[ERROR] usage: %s datacenter_file\n", argv[0]);
    return 1;
  } else {
    int generation = 0;
    int h_size = get_h_size(argv[1]);
    int v_size = get_v_size(argv[1]);
    int l_size = get_l_size(argv[1]);
    int **H = load_H(h_size, argv[1]);
    int **V = load_V(v_size, argv[1]);
    int **T = load_T(v_size, argv[1]);
    int **G = load_G(h_size, l_size, argv[1]);
    int *K = load_K(l_size, argv[1]);
    srand((unsigned int)time(NULL));
    srand48(time(NULL));
    if (check_instance() != 0) {
      printf("\nThe problem has no solution, call Amazon EC2\n");
      return 1;
    }
    int **P = initialization(100, h_size, v_size, V, 1);
    int ***utilization_P = load_utilization(P, H, V, 100, h_size, v_size);
    int **network_utilization_P = load_network_utilization(P, G, T, 100, l_size, v_size);
    P = reparation(P, utilization_P, H, V, 100, h_size, v_size, 1, K, network_utilization_P, l_size, G, T);
    float **objectives_functions_P = load_objectives(P, utilization_P, H, V, T, 100, h_size, v_size, K, network_utilization_P, l_size);
    int *fronts_P = non_dominated_sorting(objectives_functions_P, 100);
    struct pareto_element *pareto_head = NULL;
    int iterator_individual;
    for (iterator_individual = 0; iterator_individual < 100; iterator_individual++) {
      if (fronts_P[iterator_individual] == 1) {
        pareto_head = (struct pareto_element *)pareto_insert(pareto_head, v_size, P[iterator_individual], objectives_functions_P[iterator_individual]);
      }
    }
    int father, mother;
    int **Q;
    int ***utilization_Q;
    int **network_utilization_Q;
    float **objectives_functions_Q;
    int *fronts_Q;
    while (generation < 1) {
      generation++;
      Q = initialization(100, h_size, v_size, V, 1);
      father = selection(fronts_P, 100, 0.5);
      mother = selection(fronts_P, 100, 0.5);
      Q = crossover(Q, father, mother, v_size);
      Q = mutation(Q, V, 100, h_size, v_size);
      utilization_Q = load_utilization(Q, H, V, 100, h_size, v_size);
      network_utilization_Q = load_network_utilization(Q, G, T, 100, l_size, v_size);
      Q = reparation(Q, utilization_Q, H, V, 100, h_size, v_size, 1, K, network_utilization_Q, l_size, G, T);
      objectives_functions_Q = load_objectives(Q, utilization_Q, H, V, T, 100, h_size, v_size, K, network_utilization_Q, l_size);
      fronts_Q = non_dominated_sorting(objectives_functions_Q, 100);
      for (iterator_individual = 0; iterator_individual < 100; iterator_individual++) {
        if (fronts_Q[iterator_individual] == 1) {
          pareto_head = (struct pareto_element *)pareto_insert(pareto_head, v_size, Q[iterator_individual], objectives_functions_Q[iterator_individual]);
        }
      }
      P = population_evolution(P, Q, objectives_functions_P, objectives_functions_Q, fronts_P, 100, v_size);
    }
    report_best_population(pareto_head, G, T, H, V, v_size, h_size, l_size);
    printf("\n");
    return 0;
  }
}
```