user: Translate the below assembly code into C programming language:

```asm
<main>:
  endbr64
  push   %r15
  xor    %eax,%eax
  push   %r14
  push   %r13
  push   %r12
  lea    D13(%rip),%r12
  push   %rbp
  mov    %rsi,%rbp
  push   %rbx
  mov    %edi,%ebx
  mov    %r12,%rdi
  sub    $0x28,%rsp
  call   <printf@plt>
  lea    D62(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D90(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D191(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D127(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D33(%rip),%rdi
  call   <puts@plt>
  cmp    $0x3,%ebx
  je     L27
  lea    D139(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D185(%rip),%rdi
  call   <puts@plt>
  lea    D66(%rip),%rdi
  call   <puts@plt>
  or     $0xffffffff,%edi
  call   <exit@plt>
L102:
  lea    D133(%rip),%rsi
  mov    %r13,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L73
  movq   $0x1800000,0x10(%rsp)
  mov    $0x2000,%ebx
  mov    $0x400,%r12d
L1:
  mov    %r12d,%esi
  lea    D194(%rip),%rdi
  xor    %eax,%eax
  mov    %r12d,%r13d
  call   <printf@plt>
  mov    0x8(%rsp),%esi
  xor    %eax,%eax
  lea    (%r12,%r12,1),%ebp
  lea    D142(%rip),%rdi
  call   <printf@plt>
  mov    $0xa,%edi
  call   <putchar@plt>
  mov    %ebx,%edi
  call   <malloc@plt>
  mov    %rax,%r15
  mov    %rax,%r14
  nopw   0x0(%rax,%rax,1)
L39:
  mov    %ebx,%edi
  call   <malloc@plt>
  mov    %r13d,%edx
  mov    %rax,(%r14)
  sub    %r12d,%edx
L101:
  pxor   %xmm0,%xmm0
  add    $0x8,%rax
  cvtsi2sd %edx,%xmm0
  add    $0x1,%edx
  movsd  %xmm0,-0x8(%rax)
  cmp    %r13d,%edx
  jne    L101
  lea    0x1(%rdx),%r13d
  add    $0x8,%r14
  cmp    %ebp,%r13d
  jne    L39
  mov    %ebx,%edi
  mov    %r12d,%r13d
  call   <malloc@plt>
  mov    %rax,0x18(%rsp)
  mov    %rax,%r14
  nopl   0x0(%rax,%rax,1)
L28:
  mov    %ebx,%edi
  call   <malloc@plt>
  mov    %r13d,%edx
  mov    %rax,(%r14)
  sub    %r12d,%edx
L61:
  pxor   %xmm0,%xmm0
  add    $0x8,%rax
  cvtsi2sd %edx,%xmm0
  add    $0x1,%edx
  movsd  %xmm0,-0x8(%rax)
  cmp    %r13d,%edx
  jne    L61
  lea    0x1(%rdx),%r13d
  add    $0x8,%r14
  cmp    %ebp,%r13d
  jne    L28
  mov    %ebx,%edi
  call   <malloc@plt>
  mov    %rax,%r13
  mov    %rax,%r14
  mov    %r12d,%eax
  lea    0x0(%r13,%rax,8),%rbp
  nopl   0x0(%rax,%rax,1)
L17:
  mov    %ebx,%edi
  add    $0x8,%r14
  call   <malloc@plt>
  mov    %rax,-0x8(%r14)
  cmp    %r14,%rbp
  jne    L17
  mov    0x18(%rsp),%rbx
  mov    0x8(%rsp),%r8d
  mov    %r12d,%ecx
  mov    %r13,%rdx
  mov    %r15,%rdi
  mov    %rbx,%rsi
  call   <Matrix_Multiplication_Static@plt>
  lea    D106(%rip),%rdi
  mov    $0x1,%eax
  movsd  %xmm0,0x8(%rsp)
  pxor   %xmm0,%xmm0
  cvtsi2sdq 0x10(%rsp),%xmm0
  mulsd  D196(%rip),%xmm0
  call   <printf@plt>
  movsd  0x8(%rsp),%xmm1
  mov    $0x1,%eax
  lea    D61(%rip),%rdi
  movapd %xmm1,%xmm0
  call   <printf@plt>
  lea    D94(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D33(%rip),%rdi
  call   <puts@plt>
  mov    %r15,%rdi
  call   <free@plt>
  mov    %rbx,%rdi
  call   <free@plt>
  mov    %r13,%rdi
  call   <free@plt>
  add    $0x28,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L27:
  mov    0x10(%rbp),%rdi
  mov    0x8(%rbp),%r13
  call   <atoi@plt>
  mov    %eax,0x8(%rsp)
  jmp    L102
L73:
  lea    D75(%rip),%rsi
  mov    %r13,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L64
  movq   $0x6000000,0x10(%rsp)
  mov    $0x4000,%ebx
  mov    $0x800,%r12d
  jmp    L1
L64:
  lea    D26(%rip),%rsi
  mov    %r13,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L20
  movq   $0x18000000,0x10(%rsp)
  mov    $0x8000,%ebx
  mov    $0x1000,%r12d
  jmp    L1
L20:
  lea    D88(%rip),%rdi
  xor    %r12d,%r12d
  call   <puts@plt>
  or     $0xffffffff,%edi
  lea    0x0(,%r12,8),%ebx
  call   <exit@plt>
  movq   $0x0,0x10(%rsp)
  jmp    L1
```

tool_calls: name: disassemble_data
arguments: data_label: D13
datatype: string
name: disassemble_data
arguments: data_label: D62
datatype: string
name: disassemble_data
arguments: data_label: D90
datatype: string
name: disassemble_data
arguments: data_label: D191
datatype: string
name: disassemble_data
arguments: data_label: D127
datatype: string
name: disassemble_data
arguments: data_label: D33
datatype: string
name: disassemble_data
arguments: data_label: D139
datatype: string
name: disassemble_data
arguments: data_label: D185
datatype: string
name: disassemble_data
arguments: data_label: D66
datatype: string
name: disassemble_data
arguments: data_label: D133
datatype: string
name: disassemble_data
arguments: data_label: D194
datatype: string
name: disassemble_data
arguments: data_label: D142
datatype: string
name: disassemble_data
arguments: data_label: D106
datatype: string
name: disassemble_data
arguments: data_label: D196
datatype: f32[2]
name: disassemble_data
arguments: data_label: D61
datatype: string
name: disassemble_data
arguments: data_label: D94
datatype: string
name: disassemble_data
arguments: data_label: D75
datatype: string
name: disassemble_data
arguments: data_label: D26
datatype: string
name: disassemble_data
arguments: data_label: D88
datatype: string

tool: D13: 
		---------------------------------------------------------------------------

tool: D62: 
		 Email : RarchK

tool: D90: 
		 Objective : Dense Matrix Computations (Floating Point Operations)
 

tool: D191: 
		 Matrix into Matrix Multiplication using 

tool: D127: 
		 OpenMP one PARALLEL for directive with Schedule(static) and Private Clause

tool: D33: 
		..........................................................................

tool: D139: 		 Very Few Arguments
 

tool: D185: 		 Syntax : exec <Class-Size> <Threads>

tool: D66: 		 Where : Class-Size must be A or B or C 

tool: D133: A

tool: D194: 
		 Matrix Size :  %d

tool: D142: 
		 Threads     :  %d

tool: D106: 
		 Memory Utilized            : %lf MB 


tool: {"D196": [0.0,0.34375]}

tool: D61: 
		 Time in Seconds (T)        : %lf Seconds 


tool: D94: 
		   ( T represents the Time taken for the execution )

tool: D75: B

tool: D26: C

tool: D88: 
		 Class-Size must be A or B or C 

assistant: ```c
main(int argc, char *argv[]) {
  int CLASS_SIZE, N_size, i, j, k, Total_threads, THREADS;
  double Total_overhead = 0.0;
  double **Matrix_A, **Matrix_B, **Result;
  double memoryused = 0.0;
  int iteration;
  FILE *fp;
  char *CLASS;
  printf("\n\t\t---------------------------------------------------------------------------");
  printf("\n\t\t Email : RarchK");
  printf("\n\t\t---------------------------------------------------------------------------");
  printf("\n\t\t Objective : Dense Matrix Computations (Floating Point Operations)\n ");
  printf("\n\t\t Matrix into Matrix Multiplication using ");
  printf("\n\t\t OpenMP one PARALLEL for directive with Schedule(static) and Private Clause");
  printf("\n\t\t..........................................................................\n");
  if (argc != 3) {
    printf("\t\t Very Few Arguments\n ");
    printf("\t\t Syntax : exec <Class-Size> <Threads>\n");
    printf("\t\t Where : Class-Size must be A or B or C \n");
    exit(-1);
  } else {
    CLASS = argv[1];
    THREADS = atoi(argv[2]);
  }
  if (strcmp(CLASS, "A") == 0) {
    CLASS_SIZE = 1024;
  } else if (strcmp(CLASS, "B") == 0) {
    CLASS_SIZE = 2048;
  } else if (strcmp(CLASS, "C") == 0) {
    CLASS_SIZE = 4096;
  } else {
    printf("\n\t\t Class-Size must be A or B or C \n");
    exit(-1);
  }
  N_size = CLASS_SIZE;
  Total_threads = THREADS;
  printf("\n\t\t Matrix Size :  %d", N_size);
  printf("\n\t\t Threads     :  %d", Total_threads);
  printf("\n");
  Matrix_A = (double **)malloc(sizeof(double *) * N_size);
  for (i = 0; i < N_size; i++) {
    Matrix_A[i] = (double *)malloc(sizeof(double) * N_size);
    for (j = 0; j < N_size; j++) {
      Matrix_A[i][j] = i + j;
    }
  }
  Matrix_B = (double **)malloc(sizeof(double *) * N_size);
  for (i = 0; i < N_size; i++) {
    Matrix_B[i] = (double *)malloc(sizeof(double) * N_size);
    for (j = 0; j < N_size; j++) {
      Matrix_B[i][j] = i + j;
    }
  }
  Result = (double **)malloc(sizeof(double *) * N_size);
  for (i = 0; i < N_size; i++)
    Result[i] = (double *)malloc(sizeof(double) * N_size);
  memoryused = (3 * (N_size * N_size)) * sizeof(double);
  Total_overhead = Matrix_Multiplication_Static(Matrix_A, Matrix_B, Result, N_size, Total_threads);
  printf("\n\t\t Memory Utilized            : %lf MB \n", (memoryused / (1024 * 1024)));
  printf("\n\t\t Time in Seconds (T)        : %lf Seconds \n", Total_overhead);
  printf("\n\t\t   ( T represents the Time taken for the execution )");
  printf("\n\t\t..........................................................................\n");
  free(Matrix_A);
  free(Matrix_B);
  free(Result);
}
```