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

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbx
  sub    $0x38,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  xor    %eax,%eax
  lea    -0x4000000(%rsp),%rax
L42:
  cmp    %rax,%rsp
  je     L217
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  jmp    L42
L217:
  mov    %rsp,%r14
  lea    -0x4000000(%rsp),%rax
L209:
  cmp    %rax,%rsp
  je     L10
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  jmp    L209
L10:
  mov    %rsp,%r15
  lea    -0x4000(%rsp),%rax
L113:
  cmp    %rax,%rsp
  je     L96
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  jmp    L113
L96:
  mov    %rsp,%rbx
  mov    $0x4000000,%edx
  mov    $0x0,%esi
  mov    %r14,%rdi
  call   <memset@plt>
  lea    0x4000(%r14),%rdx
  mov    %r14,%rax
L160:
  movl   $0x0,(%rax)
  movl   $0x0,0x3ffc000(%rax)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L160
  mov    %r14,%r13
  mov    $0x0,%r12d
L190:
  pxor   %xmm0,%xmm0
  cvtsi2ss %r12d,%xmm0
  mulss  D71(%rip),%xmm0
  divss  D91(%rip),%xmm0
  call   <sinf@plt>
  movss  %xmm0,(%rbx,%r12,4)
  movss  %xmm0,0x0(%r13)
  mulss  D44(%rip),%xmm0
  movss  %xmm0,0x3ffc(%r13)
  add    $0x1,%r12
  add    $0x4000,%r13
  cmp    $0x1000,%r12
  jne    L190
  mov    $0x1000,%esi
  movsd  D6(%rip),%xmm0
  lea    D60(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  mov    $0x0,%eax
  call   <StartTimer@plt>
  lea    0x4(%r15),%rax
  lea    0x4000(%r15),%rdx
L167:
  movl   $0x0,(%rax)
  movl   $0x0,0x3ffc000(%rax)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L167
  add    $0x4,%rbx
  lea    0x4000(%r15),%rax
  lea    0x4000000(%r15),%rdx
L137:
  movss  (%rbx),%xmm0
  movss  %xmm0,(%rax)
  mulss  D44(%rip),%xmm0
  movss  %xmm0,0x3ffc(%rax)
  add    $0x4,%rbx
  add    $0x4000,%rax
  cmp    %rdx,%rax
  jne    L137
  movl   $0x0,-0x48(%rbp)
  lea    0x3fffff8(%r14),%rax
  mov    %rax,-0x58(%rbp)
  jmp    L34
L146:
  addq   $0x4000,-0x50(%rbp)
  add    $0x4000,%r13
  cmp    -0x58(%rbp),%r13
  je     L21
L126:
  lea    -0x3ff8(%r13),%rbx
  mov    -0x50(%rbp),%r12
L16:
  movss  0x8(%rbx),%xmm0
  addss  (%rbx),%xmm0
  addss  -0x3ffc(%rbx),%xmm0
  addss  0x4004(%rbx),%xmm0
  mulss  D13(%rip),%xmm0
  movss  %xmm0,(%r12)
  subss  0x4(%rbx),%xmm0
  call   <fabsf@plt>
  mov    %eax,%edi
  movss  -0x44(%rbp),%xmm0
  call   <fmaxf@plt>
  movss  %xmm0,-0x44(%rbp)
  add    $0x4,%rbx
  add    $0x4,%r12
  cmp    %r13,%rbx
  jne    L16
  jmp    L146
L21:
  mov    $0x7ffc,%edx
L41:
  lea    -0x3ff8(%rdx),%rax
L189:
  movss  (%r15,%rax,1),%xmm0
  movss  %xmm0,(%r14,%rax,1)
  add    $0x4,%rax
  cmp    %rax,%rdx
  jne    L189
  add    $0x4000,%rdx
  cmp    $0x3fffffc,%rdx
  jne    L41
  mov    -0x48(%rbp),%ecx
  movslq %ecx,%rax
  imul   $0x51eb851f,%rax,%rax
  sar    $0x25,%rax
  mov    %ecx,%edx
  sar    $0x1f,%edx
  sub    %edx,%eax
  imul   $0x64,%eax,%eax
  cmp    %eax,%ecx
  je     L78
L66:
  addl   $0x1,-0x48(%rbp)
  mov    -0x48(%rbp),%eax
  cmp    $0x3e7,%eax
  jg     L57
  movss  -0x44(%rbp),%xmm2
  comiss D38(%rip),%xmm2
  jbe    L57
L34:
  lea    0x4004(%r15),%rax
  mov    %rax,-0x50(%rbp)
  lea    0x7ff8(%r14),%r13
  movl   $0x0,-0x44(%rbp)
  jmp    L126
L78:
  pxor   %xmm0,%xmm0
  cvtsi2sd %ecx,%xmm0
  pxor   %xmm1,%xmm1
  cvtss2sd -0x44(%rbp),%xmm1
  lea    D73(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  jmp    L66
L57:
  mov    $0x0,%eax
  call   <GetTimer@plt>
  divsd  D70(%rip),%xmm0
  lea    D105(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L219
  mov    $0x0,%eax
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
L219:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: tag: D71
type_infered: byte[4]
name: disassemble_data
arguments: tag: D91
type_infered: byte[4]
name: disassemble_data
arguments: tag: D44
type_infered: byte[4]
name: disassemble_data
arguments: tag: D6
type_infered: byte[8]
name: disassemble_data
arguments: tag: D60
type_infered: string
name: disassemble_data
arguments: tag: D13
type_infered: byte[4]
name: disassemble_data
arguments: tag: D38
type_infered: byte[4]
name: disassemble_data
arguments: tag: D73
type_infered: string
name: disassemble_data
arguments: tag: D70
type_infered: byte[8]
name: disassemble_data
arguments: tag: D105
type_infered: string

tool: {"D71": [0xdb,0x0f,0x49,0x40]}

tool: {"D91": [0x00,0xf0,0x7f,0x45]}

tool: {"D44": [0x13,0x01,0x31,0x3d]}

tool: {"D6": [0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x40]}

tool: D60: Jacobi relaxation Calculation: %d x %d mesh


tool: {"D13": [0x00,0x00,0x80,0x3e]}

tool: {"D38": [0xac,0xc5,0x27,0x37]}

tool: D73: %5d, %0.6f


tool: {"D70": [0x00,0x00,0x00,0x00,0x00,0x40,0x8f,0x40]}

tool: D105:  total: %f s


assistant: ```c
int main(int argc, char **argv) {
  int n = 4096;
  int m = 4096;
  int iter_max = 1000;
  const float pi = 2.0f * asinf(1.0f);
  const float tol = 1.0e-5f;
  float error = 1.0f;
  float A[n][m];
  float Anew[n][m];
  float y0[n];
  memset(A, 0, n * m * sizeof(float));
  for (int i = 0; i < m; i++) {
    A[0][i] = 0.f;
    A[n - 1][i] = 0.f;
  }
  for (int j = 0; j < n; j++) {
    y0[j] = sinf(pi * j / (n - 1));
    A[j][0] = y0[j];
    A[j][m - 1] = y0[j] * expf(-pi);
  }
  printf("Jacobi relaxation Calculation: %d x %d mesh\n", n, m);
  StartTimer();
  int iter = 0;
#pragma omp parallel for shared(Anew)
  for (int i = 1; i < m; i++) {
    Anew[0][i] = 0.f;
    Anew[n - 1][i] = 0.f;
  }
#pragma omp parallel for shared(Anew)
  for (int j = 1; j < n; j++) {
    Anew[j][0] = y0[j];
    Anew[j][m - 1] = y0[j] * expf(-pi);
  }
  while (error > tol && iter < iter_max) {
    error = 0.f;
#pragma omp parallel for shared(m, n, Anew, A)
#pragma acc kernels
    for (int j = 1; j < n - 1; j++) {
      for (int i = 1; i < m - 1; i++) {
        Anew[j][i] = 0.25f * (A[j][i + 1] + A[j][i - 1] + A[j - 1][i] + A[j + 1][i]);
        error = fmaxf(error, fabsf(Anew[j][i] - A[j][i]));
      }
    }
#pragma omp parallel for shared(m, n, Anew, A)
#pragma acc kernels
    for (int j = 1; j < n - 1; j++) {
      for (int i = 1; i < m - 1; i++) {
        A[j][i] = Anew[j][i];
      }
    }
    if (iter % 100 == 0)
      printf("%5d, %0.6f\n", iter, error);
    iter++;
  }
  double runtime = GetTimer();
  printf(" total: %f s\n", runtime / 1000.f);
}
```