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

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  mov    %edi,%ebp
  mov    %rsi,%rbx
  lea    D14(%rip),%r12
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D52(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D83(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D98(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D135(%rip),%rdi
  call   <puts@plt>
  cmp    $0x3,%ebp
  jne    L44
L117:
  mov    0x8(%rbx),%rdi
  call   <atoi@plt>
  mov    %eax,%r15d
  mov    %eax,0x20(%rsp)
  mov    0x10(%rbx),%rdi
  call   <atoi@plt>
  mov    %eax,%r12d
  cmp    $0x10,%r15d
  ja     L59
  mov    $0x10116,%eax
  mov    %r15d,%ecx
  shr    %cl,%rax
  test   $0x1,%al
  je     L59
L112:
  test   %r12d,%r12d
  jle    L133
  lea    0x0(,%r12,8),%r13d
  mov    %r13d,%edi
  call   <malloc@plt>
  mov    %rax,%rbp
  mov    %rax,0x8(%rsp)
  mov    %rax,0x18(%rsp)
  mov    %r13d,%edi
  call   <malloc@plt>
  mov    %rax,(%rsp)
  mov    %rax,0x10(%rsp)
  lea    (%r12,%r12,1),%r14d
  mov    %r12d,%ebx
L27:
  mov    %r13d,%edi
  call   <malloc@plt>
  mov    %rbp,%rsi
  mov    %rax,0x0(%rbp)
  mov    %ebx,%eax
  sub    %r12d,%eax
  mov    $0x0,%edx
L168:
  mov    (%rsi),%rcx
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,(%rcx,%rdx,1)
  add    $0x8,%rdx
  add    $0x1,%eax
  cmp    %ebx,%eax
  jne    L168
  add    $0x8,%rbp
  add    $0x1,%ebx
  cmp    %r14d,%ebx
  jne    L27
  mov    %r12d,%ebp
  shl    $0x3,%rbp
  mov    0x8(%rsp),%rax
  lea    0x0(%rbp,%rax,1),%r15
  mov    %rax,%rbx
  mov    (%rsp),%r14
  sub    %rax,%r14
L227:
  mov    %r13d,%edi
  call   <malloc@plt>
  lea    (%r14,%rbx,1),%rcx
  mov    %rax,(%rcx)
  mov    $0x0,%eax
L110:
  mov    (%rbx),%rdx
  movsd  (%rdx,%rax,1),%xmm0
  mov    (%rcx),%rdx
  movsd  %xmm0,(%rdx,%rax,1)
  add    $0x8,%rax
  cmp    %rbp,%rax
  jne    L110
  add    $0x8,%rbx
  cmp    %r15,%rbx
  jne    L227
  mov    0x20(%rsp),%edi
  call   <omp_set_num_threads@plt>
  cmp    $0x1,%r12d
  jle    L101
  mov    %r12d,%r15d
  shl    $0x3,%r15
  lea    -0x2(%r12),%eax
  lea    0x10(,%rax,8),%rax
  mov    %rax,0x20(%rsp)
  mov    0x8(%rsp),%r14
  add    %rax,%r14
  mov    $0x8,%ebp
  mov    %r12d,0x2c(%rsp)
  mov    0x18(%rsp),%r12
  jmp    L187
L44:
  lea    D113(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D39(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
  jmp    L117
L59:
  lea    D75(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
  jmp    L112
L133:
  lea    D89(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  lea    0x0(,%r12,8),%ebx
  mov    %ebx,%edi
  call   <malloc@plt>
  mov    %rax,0x18(%rsp)
  mov    %ebx,%edi
  call   <malloc@plt>
  mov    %rax,0x10(%rsp)
  mov    0x20(%rsp),%edi
  call   <omp_set_num_threads@plt>
L241:
  mov    0x28(%rsp),%esi
  lea    D35(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r12d,%esi
  lea    D64(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D115(%rip),%rdi
  call   <puts@plt>
  lea    D135(%rip),%rdi
  call   <puts@plt>
  mov    $0xa,%edi
  call   <putchar@plt>
  mov    0x18(%rsp),%rdi
  call   <free@plt>
  mov    0x10(%rsp),%rdi
  call   <free@plt>
  mov    $0x0,%eax
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L258:
  mov    (%rbx),%rdx
  lea    (%rdx,%rbp,1),%rax
  movsd  (%rax),%xmm0
  addsd  (%rdx,%r13,1),%xmm0
  movsd  %xmm0,(%rax)
  add    $0x8,%rbx
  cmp    %r14,%rbx
  je     L70
L250:
  mov    $0x0,%eax
  call   <omp_get_thread_num@plt>
  test   %rax,%rax
  jne    L258
  call   <omp_get_num_threads@plt>
  mov    %eax,0x28(%rsp)
  jmp    L258
L70:
  add    $0x8,%rbp
  cmp    %r15,%rbp
  je     L186
L187:
  lea    -0x8(%rbp),%r13
  lea    0x8(%r12),%rbx
  jmp    L250
L186:
  mov    0x2c(%rsp),%r12d
  mov    0x20(%rsp),%r8
  add    (%rsp),%r8
  mov    $0x8,%esi
  mov    0x10(%rsp),%r9
L212:
  lea    -0x8(%rsi),%rdi
  lea    0x8(%r9),%rax
L237:
  mov    (%rax),%rcx
  lea    (%rcx,%rsi,1),%rdx
  movsd  (%rdx),%xmm0
  addsd  (%rcx,%rdi,1),%xmm0
  movsd  %xmm0,(%rdx)
  add    $0x8,%rax
  cmp    %rax,%r8
  jne    L237
  add    $0x8,%rsi
  cmp    %r15,%rsi
  jne    L212
L101:
  mov    (%rsp),%r13
  mov    0x8(%rsp),%rbp
  mov    $0x0,%r15d
  lea    D50(%rip),%r14
  jmp    L51
L34:
  mov    %r14,%rdi
  call   <puts@plt>
  mov    $0x1,%edi
  call   <exit@plt>
L120:
  add    $0x1,%rbx
  cmp    %ebx,%r12d
  jle    L176
L154:
  mov    0x0(%r13),%rdx
  mov    0x0(%rbp),%rax
  movsd  (%rdx,%rbx,8),%xmm0
  ucomisd (%rax,%rbx,8),%xmm0
  jp     L34
  je     L120
  jmp    L34
L176:
  add    $0x1,%r15d
  add    $0x8,%r13
  add    $0x8,%rbp
  cmp    %r15d,%r12d
  jle    L241
L51:
  mov    $0x0,%ebx
  jmp    L154
```

tool_calls: name: read_data
arguments: data_tag: D14
data_type: string
name: read_data
arguments: data_tag: D52
data_type: string
name: read_data
arguments: data_tag: D83
data_type: string
name: read_data
arguments: data_tag: D98
data_type: string
name: read_data
arguments: data_tag: D135
data_type: string
name: read_data
arguments: data_tag: D113
data_type: string
name: read_data
arguments: data_tag: D39
data_type: string
name: read_data
arguments: data_tag: D75
data_type: string
name: read_data
arguments: data_tag: D89
data_type: string
name: read_data
arguments: data_tag: D35
data_type: string
name: read_data
arguments: data_tag: D64
data_type: string
name: read_data
arguments: data_tag: D115
data_type: string
name: read_data
arguments: data_tag: D50
data_type: string

tool: D14: 
		---------------------------------------------------------------------------

tool: D52: 
		 Email : RarchK

tool: D83: 
		 Objective : Parallization of a loop nest contating a recurrence relation.
 

tool: D98: 
		 Demonstrates the use of OpenMP Parallel for directive  

tool: D135: 
		..........................................................................

tool: D113: 		 Very Few Arguments
 

tool: D39: 		 Syntax : exec <Threads> <matrix-size>

tool: D75: 
 Number of threads should be 1,2,4,8 or 16 for the execution of program. 


tool: D89: 
		 Array Size Should Be Of Positive Sign 

tool: D35: 

		 Threads     : %d

tool: D64: 
		 Matrix Size : %d 

tool: D115: 

		 Serial And Parallel Calculation Are Same. 

tool: D50: 
		 The result of the serial and parallel calculation are not Equal 

assistant: ```c
main(int argc, char **argv) {
  double **InputMatrix, **CheckMatrix;
  int j, i, N, Noofthreads, total_threads;
  printf("\n\t\t---------------------------------------------------------------------------");
  printf("\n\t\t Email : RarchK");
  printf("\n\t\t---------------------------------------------------------------------------");
  printf("\n\t\t Objective : Parallization of a loop nest contating a recurrence relation.\n ");
  printf("\n\t\t Demonstrates the use of OpenMP Parallel for directive  ");
  printf("\n\t\t..........................................................................\n");
  if (argc != 3) {
    printf("\t\t Very Few Arguments\n ");
    printf("\t\t Syntax : exec <Threads> <matrix-size>\n");
    exit(-1);
  }
  Noofthreads = atoi(argv[1]);
  N = atoi(argv[2]);
  if ((Noofthreads != 1) && (Noofthreads != 2) && (Noofthreads != 4) && (Noofthreads != 8) && (Noofthreads != 16)) {
    printf("\n Number of threads should be 1,2,4,8 or 16 for the execution of program. \n\n");
    exit(-1);
  }
  if (N <= 0) {
    printf("\n\t\t Array Size Should Be Of Positive Sign \n");
    exit(1);
  }
  InputMatrix = (double **)malloc(sizeof(double *) * N);
  CheckMatrix = (double **)malloc(sizeof(double *) * N);
  for (i = 0; i < N; i++) {
    InputMatrix[i] = (double *)malloc(sizeof(double) * N);
    for (j = 0; j < N; j++)
      InputMatrix[i][j] = i + j;
  }
  for (i = 0; i < N; i++) {
    CheckMatrix[i] = (double *)malloc(sizeof(double) * N);
    for (j = 0; j < N; j++)
      CheckMatrix[i][j] = InputMatrix[i][j];
  }
  omp_set_num_threads(Noofthreads);
  for (j = 1; j < N; j++)
#pragma omp parallel for
    for (i = 1; i < N; i++) {
      if ((omp_get_thread_num()) == 0) {
        total_threads = omp_get_num_threads();
      }
      InputMatrix[i][j] = InputMatrix[i][j] + InputMatrix[i][j - 1];
    }
  for (j = 1; j < N; j++)
    for (i = 1; i < N; i++)
      CheckMatrix[i][j] = CheckMatrix[i][j] + CheckMatrix[i][j - 1];
  for (i = 0; i < N; i++)
    for (j = 0; j < N; j++)
      if (CheckMatrix[i][j] == InputMatrix[i][j]) {
        continue;
      } else {
        printf("\n\t\t The result of the serial and parallel calculation are not Equal \n");
        exit(1);
      }
  printf("\n\n\t\t Threads     : %d", total_threads);
  printf("\n\t\t Matrix Size : %d ", N);
  printf("\n\n\t\t Serial And Parallel Calculation Are Same. \n");
  printf("\n\t\t..........................................................................\n");
  printf("\n");
  free(InputMatrix);
  free(CheckMatrix);
}
```