user: What is the c source code of the assembly code below:

```asm
<main>:
  endbr64
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x5000(%rsp),%r11
L369:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L369
  sub    $0xd10,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x5d08(%rsp)
  xor    %eax,%eax
  call   <check_offloading@plt>
  mov    $0x0,%eax
  movsd  D80(%rip),%xmm1
L123:
  movq   $0x0,(%rsp,%rax,8)
  movsd  %xmm1,0x1f00(%rsp,%rax,8)
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x3e00(%rsp,%rax,8)
  add    $0x1,%rax
  cmp    $0x3e0,%rax
  jne    L123
  mov    $0x0,%eax
  lea    0x3e00(%rsp),%rdx
  movsd  D80(%rip),%xmm1
L419:
  movsd  0x1f00(%rsp,%rax,1),%xmm0
  addsd  (%rax,%rdx,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsp,%rax,1)
  add    $0x8,%rax
  cmp    $0x1f00,%rax
  jne    L419
  mov    $0x0,%ebx
  mov    $0x0,%ebp
  mov    $0x0,%edx
  lea    D229(%rip),%r13
  lea    D160(%rip),%r12
  mov    $0x1,%r14d
  jmp    L122
L152:
  add    $0x1,%rbx
  cmp    $0x3e0,%rbx
  je     L349
L122:
  mov    %ebx,%esi
  movsd  (%rsp,%rbx,8),%xmm1
  lea    0x2(%rbx),%eax
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  ucomisd %xmm0,%xmm1
  jp     L180
  je     L152
L180:
  mov    %r13,%rdx
  mov    %r12,%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  lea    0x1(%rbp),%eax
  cmp    $0xa,%ebp
  jg     L233
  mov    %eax,%ebp
  mov    %r14d,%edx
  jmp    L152
L349:
  test   %edx,%edx
  jne    L233
  lea    D182(%rip),%rdi
  call   <puts@plt>
  jmp    L54
L233:
  lea    D106(%rip),%rdi
  call   <puts@plt>
L54:
  mov    $0x1,%eax
  movsd  D27(%rip),%xmm1
L72:
  movsd  %xmm1,0x1ef8(%rsp,%rax,8)
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x3df8(%rsp,%rax,8)
  add    $0x1,%rax
  cmp    $0x3e1,%rax
  jne    L72
  mov    $0x0,%eax
  lea    0x3e00(%rsp),%rdx
  movsd  D80(%rip),%xmm1
L409:
  movsd  0x1f00(%rsp,%rax,1),%xmm0
  addsd  (%rax,%rdx,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsp,%rax,1)
  add    $0x8,%rax
  cmp    $0x1f00,%rax
  jne    L409
  mov    $0x0,%ebx
  mov    $0x0,%ebp
  mov    $0x0,%edx
  lea    D229(%rip),%r13
  lea    D160(%rip),%r12
  mov    $0x1,%r14d
  jmp    L303
L373:
  add    $0x1,%rbx
  cmp    $0x3e0,%rbx
  je     L328
L303:
  mov    %ebx,%esi
  movsd  (%rsp,%rbx,8),%xmm1
  lea    0x4(%rbx),%eax
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  ucomisd %xmm0,%xmm1
  jp     L251
  je     L373
L251:
  mov    %r13,%rdx
  mov    %r12,%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  lea    0x1(%rbp),%eax
  cmp    $0xa,%ebp
  jg     L266
  mov    %eax,%ebp
  mov    %r14d,%edx
  jmp    L373
L328:
  test   %edx,%edx
  jne    L266
  lea    D30(%rip),%rdi
  call   <puts@plt>
  jmp    L391
L266:
  lea    D129(%rip),%rdi
  call   <puts@plt>
L391:
  mov    $0x0,%eax
  movsd  D80(%rip),%xmm1
L413:
  movq   $0x0,(%rsp,%rax,8)
  movsd  %xmm1,0x1f00(%rsp,%rax,8)
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x3e00(%rsp,%rax,8)
  add    $0x1,%rax
  cmp    $0x3e0,%rax
  jne    L413
  mov    $0x0,%eax
  lea    0x3e00(%rsp),%rdx
  movsd  D80(%rip),%xmm1
L219:
  movsd  0x1f00(%rsp,%rax,1),%xmm0
  addsd  (%rax,%rdx,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsp,%rax,1)
  add    $0x8,%rax
  cmp    $0x1f00,%rax
  jne    L219
  mov    $0x0,%ebx
  mov    $0x0,%ebp
  mov    $0x0,%edx
  lea    D229(%rip),%r13
  lea    D160(%rip),%r12
  mov    $0x1,%r14d
  jmp    L234
L338:
  add    $0x1,%rbx
  cmp    $0x3e0,%rbx
  je     L299
L234:
  mov    %ebx,%esi
  movsd  (%rsp,%rbx,8),%xmm1
  lea    0x2(%rbx),%eax
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  ucomisd %xmm0,%xmm1
  jp     L285
  je     L338
L285:
  mov    %r13,%rdx
  mov    %r12,%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  lea    0x1(%rbp),%eax
  cmp    $0xa,%ebp
  jg     L388
  mov    %eax,%ebp
  mov    %r14d,%edx
  jmp    L338
L299:
  test   %edx,%edx
  jne    L388
  lea    D82(%rip),%rdi
  call   <puts@plt>
  jmp    L74
L388:
  lea    D233(%rip),%rdi
  call   <puts@plt>
L74:
  mov    $0x1,%eax
  movsd  D27(%rip),%xmm1
L415:
  movsd  %xmm1,0x1ef8(%rsp,%rax,8)
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,0x3df8(%rsp,%rax,8)
  add    $0x1,%rax
  cmp    $0x3e1,%rax
  jne    L415
  mov    $0x0,%eax
  lea    0x3e00(%rsp),%rdx
  movsd  D80(%rip),%xmm1
L10:
  movsd  0x1f00(%rsp,%rax,1),%xmm0
  addsd  (%rax,%rdx,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsp,%rax,1)
  add    $0x8,%rax
  cmp    $0x1f00,%rax
  jne    L10
  mov    $0x0,%ebx
  mov    $0x0,%ebp
  mov    $0x0,%edx
  lea    D229(%rip),%r13
  lea    D160(%rip),%r12
  mov    $0x1,%r14d
  jmp    L225
L331:
  add    $0x1,%rbx
  cmp    $0x3e0,%rbx
  je     L73
L225:
  mov    %ebx,%esi
  movsd  (%rsp,%rbx,8),%xmm1
  lea    0x4(%rbx),%eax
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  ucomisd %xmm0,%xmm1
  jp     L378
  je     L331
L378:
  mov    %r13,%rdx
  mov    %r12,%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  lea    0x1(%rbp),%eax
  cmp    $0xa,%ebp
  jg     L190
  mov    %eax,%ebp
  mov    %r14d,%edx
  jmp    L331
L73:
  test   %edx,%edx
  jne    L190
  lea    D91(%rip),%rdi
  call   <puts@plt>
  jmp    L242
L190:
  lea    D2(%rip),%rdi
  call   <puts@plt>
L242:
  mov    0x5d08(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L352
  mov    $0x0,%eax
  add    $0x5d10,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
L352:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: data_label: D80
type: byte[8]
name: parse_data
arguments: data_label: D229
type: string
name: parse_data
arguments: data_label: D160
type: string
name: parse_data
arguments: data_label: D182
type: string
name: parse_data
arguments: data_label: D106
type: string
name: parse_data
arguments: data_label: D27
type: byte[8]
name: parse_data
arguments: data_label: D30
type: string
name: parse_data
arguments: data_label: D129
type: string
name: parse_data
arguments: data_label: D82
type: string
name: parse_data
arguments: data_label: D233
type: string
name: parse_data
arguments: data_label: D91
type: string
name: parse_data
arguments: data_label: D2
type: string

tool: {"D80": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: D229: A[i]

tool: D160: Failed at %3d with %s, expected %f, got %f


tool: D182: Test update from: Succeeded

tool: D106: Test update from: Failed

tool: {"D27": [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40]}

tool: D30: Test update to: Succeeded

tool: D129: Test update to: Failed

tool: D82: Test update from with offsets: Succeeded

tool: D233: Test update from with offsets: Failed

tool: D91: Test update to with offsets: Succeeded

tool: D2: Test update to with offsets: Failed

assistant: ```c
int main(void) {
  check_offloading();
  int fail;
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  double *pA, *pB, *pC, *pD, *pE;
  pA = &A[0];
  pB = &B[0];
  pC = &C[0];
  pD = &D[0];
  pE = &E[0];
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp target data map(from : pA [0:N]) map(to : pC [0:N], pD [0:N]) device(1)
  {
#pragma omp target device(1)
    {
#pragma omp parallel for schedule(static, 1)
      for (int i = 0; i < (992); i++)
        pA[i] = pC[i] + pD[i] + 1;
    }
#pragma omp target update from(pA [0:N]) device(1)
    fail = 0;
    {
      int i;
      int errorNum = 0;
      for (i = 0; i < (992); i++) {
        if (A[i] != (double)(i + 2)) {
          printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", (double)(i + 2), A[i]);
          fail = 1;
          if (errorNum++ > 10)
            break;
        }
      }
    };
    if (fail) {
      printf("Test update from: Failed\n");
    } else {
      printf("Test update from: Succeeded\n");
    }
    for (int i = 0; i < (992); i++) {
      C[i] = 2;
      D[i] = i + 1;
    }
#pragma omp target update to(pC [0:N], pD [0:N]) device(1)
#pragma omp target device(1)
    {
#pragma omp parallel for schedule(static, 1)
      for (int i = 0; i < (992); i++)
        pA[i] = pC[i] + pD[i] + 1;
    }
#pragma omp target update from(pA [0:N]) device(1)
    fail = 0;
    {
      int i;
      int errorNum = 0;
      for (i = 0; i < (992); i++) {
        if (A[i] != (double)(i + 4)) {
          printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", (double)(i + 4), A[i]);
          fail = 1;
          if (errorNum++ > 10)
            break;
        }
      }
    };
    if (fail) {
      printf("Test update to: Failed\n");
    } else {
      printf("Test update to: Succeeded\n");
    }
  }
  pA = pA - 100;
  pC = pC - 200;
  pD = pD - 300;
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
#pragma omp target data map(from : pA [100:N]) map(to : pC [200:N], pD [300:N]) device(1)
  {
#pragma omp target map(from : pA [100:N]) map(to : pC [200:N], pD [300:N]) device(1)
    {
#pragma omp parallel for schedule(static, 1)
      for (int i = 0; i < (992); i++)
        pA[i + 100] = pC[i + 200] + pD[i + 300] + 1;
    }
#pragma omp target update from(pA [100:N]) device(1)
    fail = 0;
    {
      int i;
      int errorNum = 0;
      for (i = 0; i < (992); i++) {
        if (A[i] != (double)(i + 2)) {
          printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", (double)(i + 2), A[i]);
          fail = 1;
          if (errorNum++ > 10)
            break;
        }
      }
    };
    if (fail) {
      printf("Test update from with offsets: Failed\n");
    } else {
      printf("Test update from with offsets: Succeeded\n");
    }
    for (int i = 0; i < (992); i++) {
      C[i] = 2;
      D[i] = i + 1;
    }
#pragma omp target update to(pC [200:N], pD [300:N]) device(1)
#pragma omp target map(from : pA [100:N]) map(to : pC [200:N], pD [300:N]) device(1)
    {
#pragma omp parallel for schedule(static, 1)
      for (int i = 0; i < (992); i++)
        pA[i + 100] = pC[i + 200] + pD[i + 300] + 1;
    }
#pragma omp target update from(pA [100:N]) device(1)
    fail = 0;
    {
      int i;
      int errorNum = 0;
      for (i = 0; i < (992); i++) {
        if (A[i] != (double)(i + 4)) {
          printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", (double)(i + 4), A[i]);
          fail = 1;
          if (errorNum++ > 10)
            break;
        }
      }
    };
    if (fail) {
      printf("Test update to with offsets: Failed\n");
    } else {
      printf("Test update to with offsets: Succeeded\n");
    }
  }
  return 0;
}
```