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
  sub    $0x148,%rsp
  mov    %fs:0x28,%rdx
  mov    %rdx,0x138(%rsp)
  xor    %edx,%edx
  cmp    $0x1,%edi
  jg     L91
L36:
  lea    0x110(%rsp),%rsi
  lea    0x108(%rsp),%rdi
  mov    $0x84,%edx
  call   <allocate@plt>
  lea    0x120(%rsp),%rsi
  mov    $0x84,%edx
  lea    0x118(%rsp),%rdi
  call   <allocate@plt>
  lea    0x130(%rsp),%rsi
  mov    $0x84,%edx
  lea    0x128(%rsp),%rdi
  call   <allocate@plt>
  movss  D162(%rip),%xmm1
  movss  D132(%rip),%xmm0
  mov    $0x84,%ecx
  mov    0x130(%rsp),%rdx
  mov    0x110(%rsp),%rsi
  mov    0x120(%rsp),%rdi
  call   <initialize@plt>
  mov    0x110(%rsp),%rdi
  mov    $0x84,%edx
  xor    %esi,%esi
  call   <write@plt>
  xor    %eax,%eax
  call   <seconds@plt>
  movl   $0x3e8,0xa8(%rsp)
  movsd  %xmm0,0xb8(%rsp)
L44:
  mov    0x110(%rsp),%rax
  movaps D65(%rip),%xmm3
  movl   $0x0,0xac(%rsp)
  movaps D60(%rip),%xmm2
  movaps D209(%rip),%xmm1
  mov    %rax,0x98(%rsp)
  mov    0x120(%rsp),%rax
  movss  D65(%rip),%xmm6
  movss  D60(%rip),%xmm5
  mov    %rax,0xa0(%rsp)
  mov    0x130(%rsp),%rax
  movss  D209(%rip),%xmm4
  mov    0x98(%rsp),%rcx
  mov    %rax,0x90(%rsp)
L98:
  lea    0x22080(%rax),%rsi
  lea    0x22080(%rcx),%rdi
  add    $0x224a0,%rax
  movq   $0x0,0xc8(%rsp)
  mov    %rsi,0xf8(%rsp)
  mov    0xa0(%rsp),%rsi
  movq   $0x108,0xb0(%rsp)
  lea    0x22080(%rsi),%rbx
  add    $0x224a0,%rsi
  movq   $0x0,0xd0(%rsp)
  mov    %rbx,0xf0(%rsp)
  mov    %rdi,0xe8(%rsp)
  mov    %rsi,0xd8(%rsp)
  mov    %rax,0xe0(%rsp)
L69:
  mov    0xc8(%rsp),%rbx
  mov    0xd8(%rsp),%rax
  movq   $0x0,0x10(%rsp)
  mov    0xe8(%rsp),%rsi
  add    %rbx,%rax
  mov    %rax,0x20(%rsp)
  mov    0xd0(%rsp),%rax
  add    %rbx,%rsi
  mov    %rsi,0xc0(%rsp)
  lea    0x89ac(%rax),%rcx
  lea    0x8928(%rax),%rdi
  mov    %rsi,0x18(%rsp)
  mov    %rcx,0x28(%rsp)
  lea    0x88a4(%rax),%rcx
  mov    %rdi,0x30(%rsp)
  lea    0xcd38(%rax),%rdi
  mov    %rcx,0x38(%rsp)
  lea    0x4518(%rax),%rcx
  mov    %rdi,0x40(%rsp)
  lea    0x8a30(%rax),%rdi
  mov    %rcx,0x48(%rsp)
  lea    0x8820(%rax),%rcx
  mov    %rdi,0x50(%rsp)
  lea    0x11148(%rax),%rdi
  add    $0x108,%rax
  mov    %rax,0x68(%rsp)
  mov    0xe0(%rsp),%rax
  mov    %rcx,0x58(%rsp)
  add    %rbx,%rax
  mov    %rdi,0x60(%rsp)
  mov    %rax,0x70(%rsp)
  mov    0xf8(%rsp),%rax
  lea    0x428(%rax,%rbx,1),%rax
  mov    %rax,0x78(%rsp)
  mov    0xf0(%rsp),%rax
  add    %rbx,%rax
  lea    0x42c(%rax),%rbx
  add    $0x428,%rax
  mov    %rbx,0x80(%rsp)
  mov    %rax,0x88(%rsp)
L130:
  mov    0x78(%rsp),%rax
  mov    0x10(%rsp),%rbx
  lea    (%rax,%rbx,1),%rcx
  sub    0x80(%rsp),%rax
  mov    %rcx,(%rsp)
  cmp    $0x8,%rax
  jbe    L156
  mov    0x18(%rsp),%rax
  lea    -0x21c54(%rax),%rdx
  mov    %rcx,%rax
  sub    %rdx,%rax
  cmp    $0x44108,%rax
  jbe    L156
  mov    0x18(%rsp),%rax
  mov    0x88(%rsp),%r14
  add    0x10(%rsp),%r14
  lea    -0x21c58(%rax),%rdx
  lea    0x428(%rax),%r15
  mov    %rdx,0x8(%rsp)
  lea    0x42c(%rax),%r13
  lea    0x424(%rax),%r12
  lea    0x638(%rax),%rbp
  lea    0x218(%rax),%rbx
  lea    0x11468(%rax),%r11
  lea    -0x10c18(%rax),%r10
  lea    0x430(%rax),%r9
  lea    0x420(%rax),%r8
  lea    0x848(%rax),%rdi
  lea    0x8(%rax),%rsi
  lea    0x224a8(%rax),%rcx
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L33:
  movups 0x0(%r13,%rax,1),%xmm7
  movups (%r12,%rax,1),%xmm0
  movups (%r14,%rax,1),%xmm8
  movups (%r9,%rax,1),%xmm9
  addps  %xmm7,%xmm0
  movups 0x0(%rbp,%rax,1),%xmm7
  movups (%rdi,%rax,1),%xmm10
  movups (%rsi,%rax,1),%xmm11
  movups (%rcx,%rax,1),%xmm12
  mov    0x8(%rsp),%rdx
  addps  %xmm7,%xmm0
  movups (%rbx,%rax,1),%xmm7
  movups (%rdx,%rax,1),%xmm13
  mov    (%rsp),%rdx
  addps  %xmm7,%xmm0
  movups (%r11,%rax,1),%xmm7
  addps  %xmm7,%xmm0
  movups (%r10,%rax,1),%xmm7
  addps  %xmm7,%xmm0
  movups (%r15,%rax,1),%xmm7
  mulps  %xmm2,%xmm7
  mulps  %xmm3,%xmm0
  subps  %xmm8,%xmm7
  addps  %xmm7,%xmm0
  movups (%r8,%rax,1),%xmm7
  addps  %xmm9,%xmm7
  addps  %xmm10,%xmm7
  addps  %xmm11,%xmm7
  addps  %xmm12,%xmm7
  addps  %xmm13,%xmm7
  mulps  %xmm1,%xmm7
  addps  %xmm7,%xmm0
  movups %xmm0,(%rdx,%rax,1)
  add    $0x10,%rax
  cmp    $0x200,%rax
  jne    L33
L71:
  addq   $0x210,0x10(%rsp)
  mov    0x10(%rsp),%rax
  addq   $0x210,0x18(%rsp)
  addq   $0x210,0x20(%rsp)
  addq   $0x84,0x28(%rsp)
  addq   $0x84,0x30(%rsp)
  addq   $0x84,0x38(%rsp)
  addq   $0x84,0x40(%rsp)
  addq   $0x84,0x48(%rsp)
  addq   $0x84,0x50(%rsp)
  addq   $0x84,0x58(%rsp)
  addq   $0x84,0x60(%rsp)
  addq   $0x84,0x68(%rsp)
  addq   $0x210,0x70(%rsp)
  cmp    $0x10800,%rax
  jne    L130
  addq   $0x84,0xb0(%rsp)
  mov    0xb0(%rsp),%rax
  addq   $0x4410,0xd0(%rsp)
  addq   $0x11040,0xc8(%rsp)
  cmp    $0x4308,%rax
  jne    L69
  mov    0xac(%rsp),%eax
  mov    $0xcccccccd,%ebx
  mov    %rax,%rsi
  imul   %rbx,%rax
  shr    $0x23,%rax
  lea    (%rax,%rax,4),%edx
  mov    %esi,%eax
  add    $0x1,%esi
  add    %edx,%edx
  mov    %esi,0xac(%rsp)
  sub    %edx,%eax
  test   %eax,%eax
  je     L122
  mov    0x98(%rsp),%rax
  mov    %rax,0x120(%rsp)
  mov    0x90(%rsp),%rax
  mov    %rax,0x110(%rsp)
  mov    0xa0(%rsp),%rax
  mov    %rax,0x130(%rsp)
  cmp    %esi,0xa8(%rsp)
  jle    L93
L159:
  mov    0x98(%rsp),%rax
  mov    0x90(%rsp),%rsi
  mov    0xa0(%rsp),%rbx
  mov    %rsi,0x98(%rsp)
  mov    %rsi,%rcx
  mov    %rax,0xa0(%rsp)
  mov    %rbx,%rax
  mov    %rbx,0x90(%rsp)
  jmp    L98
L156:
  mov    0x10(%rsp),%rsi
  mov    0xc0(%rsp),%rax
  xor    %edx,%edx
  mov    0x30(%rsp),%r15
  mov    0x28(%rsp),%rbx
  mov    0x38(%rsp),%r11
  mov    0x40(%rsp),%r10
  lea    0x420(%rax,%rsi,1),%rax
  mov    0x48(%rsp),%r9
  mov    0x50(%rsp),%r8
  sub    %r15,%rbx
  mov    0x58(%rsp),%rdi
  mov    0x60(%rsp),%rsi
  sub    %r15,%r11
  sub    %r15,%r10
  mov    0x68(%rsp),%rcx
  mov    0x20(%rsp),%rbp
  sub    %r15,%r9
  sub    %r15,%r8
  mov    0x70(%rsp),%r12
  sub    %r15,%rdi
  sub    %r15,%rsi
  sub    %r15,%rcx
  nop
L59:
  movss  0x4(%rax),%xmm0
  addss  0xc(%rax),%xmm0
  addss  0x8(%rax,%rbx,4),%xmm0
  addss  0x8(%rax,%r11,4),%xmm0
  addss  0x8(%rax,%r10,4),%xmm0
  addss  0x8(%rax,%r9,4),%xmm0
  movss  0x8(%rax),%xmm7
  mulss  %xmm6,%xmm0
  mulss  %xmm5,%xmm7
  subss  0x8(%rbp,%rdx,4),%xmm7
  addss  %xmm7,%xmm0
  movss  (%rax),%xmm7
  addss  0x10(%rax),%xmm7
  addss  0x8(%rax,%r8,4),%xmm7
  addss  0x8(%rax,%rdi,4),%xmm7
  addss  0x8(%rax,%rsi,4),%xmm7
  addss  0x8(%rax,%rcx,4),%xmm7
  add    $0x4,%rax
  mulss  %xmm4,%xmm7
  addss  %xmm7,%xmm0
  movss  %xmm0,0x8(%r12,%rdx,4)
  add    $0x1,%rdx
  cmp    $0x80,%rdx
  jne    L59
  jmp    L71
L122:
  mov    0x90(%rsp),%rdi
  mov    $0x84,%edx
  mov    %esi,%r14d
  call   <write@plt>
  mov    0x110(%rsp),%rax
  mov    0x130(%rsp),%rbx
  mov    0x120(%rsp),%rdi
  cmp    %r14d,0xa8(%rsp)
  mov    %rax,0x98(%rsp)
  movaps D65(%rip),%xmm3
  mov    %rbx,0x90(%rsp)
  movaps D60(%rip),%xmm2
  mov    %rdi,0xa0(%rsp)
  movaps D209(%rip),%xmm1
  mov    %rax,0x120(%rsp)
  movss  D65(%rip),%xmm6
  mov    %rbx,0x110(%rsp)
  movss  D60(%rip),%xmm5
  mov    %rdi,0x130(%rsp)
  movss  D209(%rip),%xmm4
  jg     L159
L93:
  xor    %eax,%eax
  call   <seconds@plt>
  pxor   %xmm1,%xmm1
  lea    D47(%rip),%rdi
  cvtsi2sdl 0xa8(%rsp),%xmm1
  movq   %xmm0,%rbx
  mulsd  D217(%rip),%xmm1
  mulsd  D173(%rip),%xmm1
  movapd %xmm1,%xmm0
  movsd  %xmm1,0x8(%rsp)
  call   <printf@plt>
  movq   %rbx,%xmm0
  subsd  0xb8(%rsp),%xmm0
  lea    D115(%rip),%rdi
  movsd  %xmm0,(%rsp)
  call   <printf@plt>
  movsd  (%rsp),%xmm0
  mulsd  D51(%rip),%xmm0
  lea    D137(%rip),%rdi
  movsd  0x8(%rsp),%xmm1
  divsd  %xmm0,%xmm1
  movapd %xmm1,%xmm0
  call   <printf@plt>
  mov    0x118(%rsp),%rdi
  call   <free@plt>
  mov    0x108(%rsp),%rdi
  call   <free@plt>
  mov    0x128(%rsp),%rdi
  call   <free@plt>
  mov    0x138(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L66
  add    $0x148,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L91:
  mov    0x8(%rsi),%rdi
  call   <atoi@plt>
  mov    %eax,0xa8(%rsp)
  mov    %eax,%ebx
  test   %eax,%eax
  je     L36
  lea    0x110(%rsp),%rsi
  lea    0x108(%rsp),%rdi
  mov    $0x84,%edx
  call   <allocate@plt>
  lea    0x120(%rsp),%rsi
  mov    $0x84,%edx
  lea    0x118(%rsp),%rdi
  call   <allocate@plt>
  lea    0x130(%rsp),%rsi
  mov    $0x84,%edx
  lea    0x128(%rsp),%rdi
  call   <allocate@plt>
  movss  D162(%rip),%xmm1
  movss  D132(%rip),%xmm0
  mov    $0x84,%ecx
  mov    0x130(%rsp),%rdx
  mov    0x110(%rsp),%rsi
  mov    0x120(%rsp),%rdi
  call   <initialize@plt>
  mov    0x110(%rsp),%rdi
  mov    $0x84,%edx
  xor    %esi,%esi
  call   <write@plt>
  xor    %eax,%eax
  call   <seconds@plt>
  movsd  %xmm0,0xb8(%rsp)
  test   %ebx,%ebx
  jle    L93
  jmp    L44
L66:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: tag: D162
datatype: byte[4]
name: disassemble_data
arguments: tag: D132
datatype: byte[4]
name: disassemble_data
arguments: tag: D65
datatype: byte[16]
name: disassemble_data
arguments: tag: D60
datatype: byte[16]
name: disassemble_data
arguments: tag: D209
datatype: byte[16]
name: disassemble_data
arguments: tag: D47
datatype: string
name: disassemble_data
arguments: tag: D217
datatype: byte[8]
name: disassemble_data
arguments: tag: D173
datatype: f64
name: disassemble_data
arguments: tag: D115
datatype: string
name: disassemble_data
arguments: tag: D51
datatype: f64
name: disassemble_data
arguments: tag: D137
datatype: string

tool: {"D162": [0xf8,0x03,0x7e,0x3c]}

tool: {"D132": [0x00,0x00,0x80,0xbf]}

tool: {"D65": [0x0f,0x74,0x5a,0x3b,0x0f,0x74,0x5a,0x3b,0x0f,0x74,0x5a,0x3b,0x0f,0x74,0x5a,0x3b]}

tool: {"D60": [0x9a,0x99,0xfd,0x3f,0x9a,0x99,0xfd,0x3f,0x9a,0x99,0xfd,0x3f,0x9a,0x99,0xfd,0x3f]}

tool: {"D209": [0x0f,0x74,0x5a,0xb9,0x0f,0x74,0x5a,0xb9,0x0f,0x74,0x5a,0xb9,0x0f,0x74,0x5a,0xb9]}

tool: D47: Flops in stencil code:      %e


tool: {"D217": [0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x41]}

tool: D173: 16

tool: D115: Time spent in stencil code: %f


tool: D51: 1000000000

tool: D137: Performance in GFlop/s:     %f


assistant: ```c
int main(int argc, char **argv) {
  int t;
  double t1, t2, num_flops;
  int num_timesteps = 0;
  if (argc > 1)
    num_timesteps = atoi(argv[1]);
  if (num_timesteps == 0)
    num_timesteps = 1000;
  const int size = 128 + 4;
  const float min_x = -1.0f;
  const float max_x = 1.0f;
  const float dx = (max_x - min_x) / (128 + 1);
  const float dt = dx / 20.0f;
  const float dt_dx_square = dt * dt / (dx * dx);
  float *_U_0, *U_0;
  float *_U_m1, *U_m1;
  float *_U_1, *U_1;
  allocate(&_U_0, &U_0, size);
  allocate(&_U_m1, &U_m1, size);
  allocate(&_U_1, &U_1, size);
  initialize(U_m1, U_0, U_1, min_x, dx, size);
  write(U_0, 0, size);
  const float c0 = 2.0f - 7.5f * dt_dx_square;
  const float c1 = 4.0f / 3.0f * dt_dx_square;
  const float c2 = -1.0f / 12.0f * dt_dx_square;
  t1 = seconds();
  for (t = 0; t < num_timesteps; t++) {
    int i, j, k;
#pragma omp parallel for private(i, j, k)
    for (k = 2; k < size - 2; k++) {
      for (j = 2; j < size - 2; j++) {
        for (i = 2; i < size - 2; i++) {
          U_1[((i) + size * ((j) + size * (k)))] = c0 * U_0[((i) + size * ((j) + size * (k)))] - U_m1[((i) + size * ((j) + size * (k)))] + c1 * (U_0[((i + 1) + size * ((j) + size * (k)))] + U_0[((i - 1) + size * ((j) + size * (k)))] + U_0[((i) + size * ((j + 1) + size * (k)))] + U_0[((i) + size * ((j - 1) + size * (k)))] + U_0[((i) + size * ((j) + size * (k + 1)))] + U_0[((i) + size * ((j) + size * (k - 1)))]) + c2 * (U_0[((i + 2) + size * ((j) + size * (k)))] + U_0[((i - 2) + size * ((j) + size * (k)))] + U_0[((i) + size * ((j + 2) + size * (k)))] + U_0[((i) + size * ((j - 2) + size * (k)))] + U_0[((i) + size * ((j) + size * (k + 2)))] + U_0[((i) + size * ((j) + size * (k - 2)))]);
        }
      }
    }
    if (t % 10 == 0)
      write(U_1, t + 1, size);
    float *tmp = U_m1;
    U_m1 = U_0;
    U_0 = U_1;
    U_1 = tmp;
  }
  t2 = seconds();
  num_flops = (double)(size - 4) * (double)(size - 4) * (double)(size - 4) * num_timesteps * 16.0;
  printf("Flops in stencil code:      %e\n", num_flops);
  printf("Time spent in stencil code: %f\n", t2 - t1);
  printf("Performance in GFlop/s:     %f\n", num_flops / (1e9 * (t2 - t1)));
  free(_U_m1);
  free(_U_0);
  free(_U_1);
  return 0;
}
```