user: Please show me the C implementation that matches the assembly code listed below:

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %edi,%ebx
  mov    %rsi,%rbp
  lea    D178(%rip),%r12
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D93(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D110(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D187(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D71(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D81(%rip),%rdi
  call   <puts@plt>
  cmp    $0x3,%ebx
  je     L103
  lea    D192(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D109(%rip),%rdi
  call   <puts@plt>
  lea    D121(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
L27:
  lea    D99(%rip),%rsi
  mov    %r13,%rdi
  call   <strcmp@plt>
  mov    $0x400,%r14d
  test   %rax,%rax
  jne    L80
L126:
  mov    %r14d,%esi
  lea    D179(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    0x1c(%rsp),%esi
  lea    D125(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0xa,%edi
  call   <putchar@plt>
  lea    0x0(,%r14,8),%ebp
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,0x8(%rsp)
  mov    %rax,%r15
  mov    %r14d,%r12d
  lea    (%r14,%r14,1),%r13d
  mov    %r14d,%ebx
L2:
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %r15,%rsi
  mov    %rax,(%r15)
  mov    %ebx,%eax
  sub    %r12d,%eax
  mov    $0x0,%edx
L12:
  mov    (%rsi),%rcx
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,(%rcx,%rdx,1)
  add    $0x8,%rdx
  add    $0x1,%eax
  cmp    %ebx,%eax
  jne    L12
  add    $0x8,%r15
  add    $0x1,%ebx
  cmp    %r13d,%ebx
  jne    L2
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,0x10(%rsp)
  mov    %rax,%r15
  mov    %r12d,%ebx
L55:
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %r15,%rsi
  mov    %rax,(%r15)
  mov    %ebx,%eax
  sub    %r12d,%eax
  mov    $0x0,%edx
L128:
  mov    (%rsi),%rcx
  pxor   %xmm0,%xmm0
  cvtsi2sd %eax,%xmm0
  movsd  %xmm0,(%rcx,%rdx,1)
  add    $0x8,%rdx
  add    $0x1,%eax
  cmp    %ebx,%eax
  jne    L128
  add    $0x8,%r15
  add    $0x1,%ebx
  cmp    %r13d,%ebx
  jne    L55
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,%r13
  mov    %rax,%rbx
  mov    %r12d,%r12d
  lea    (%rax,%r12,8),%r12
L120:
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,(%rbx)
  add    $0x8,%rbx
  cmp    %rbx,%r12
  jne    L120
  mov    0x1c(%rsp),%r8d
  mov    %r14d,%ecx
  mov    %r13,%rdx
  mov    0x10(%rsp),%rsi
  mov    0x8(%rsp),%rdi
  call   <Matrix_Multiplication_Static@plt>
  movq   %xmm0,%rbx
  imul   %r14d,%r14d
  lea    (%r14,%r14,2),%eax
  cltq
  shl    $0x3,%rax
  js     L112
  pxor   %xmm0,%xmm0
  cvtsi2sd %rax,%xmm0
L66:
  mulsd  D119(%rip),%xmm0
  lea    D172(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  movq   %rbx,%xmm0
  lea    D12(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    D183(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D81(%rip),%rdi
  call   <puts@plt>
  mov    0x8(%rsp),%rdi
  call   <free@plt>
  mov    0x10(%rsp),%rdi
  call   <free@plt>
  mov    %r13,%rdi
  call   <free@plt>
  mov    $0x0,%eax
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L103:
  mov    0x8(%rbp),%r13
  mov    0x10(%rbp),%rdi
  call   <atoi@plt>
  mov    %eax,0x1c(%rsp)
  jmp    L27
L80:
  lea    D89(%rip),%rsi
  mov    %r13,%rdi
  call   <strcmp@plt>
  mov    $0x800,%r14d
  test   %rax,%rax
  je     L126
  lea    D49(%rip),%rsi
  mov    %r13,%rdi
  call   <strcmp@plt>
  mov    $0x1000,%r14d
  test   %rax,%rax
  je     L126
  lea    D164(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
  jmp    L126
L112:
  shr    %rax
  pxor   %xmm0,%xmm0
  cvtsi2sd %rax,%xmm0
  addsd  %xmm0,%xmm0
  jmp    L66
```

tool_calls: name: unpack_data
arguments: label: D178
type_guessed: string
name: unpack_data
arguments: label: D93
type_guessed: string
name: unpack_data
arguments: label: D110
type_guessed: string
name: unpack_data
arguments: label: D187
type_guessed: string
name: unpack_data
arguments: label: D71
type_guessed: string
name: unpack_data
arguments: label: D81
type_guessed: string
name: unpack_data
arguments: label: D192
type_guessed: string
name: unpack_data
arguments: label: D109
type_guessed: string
name: unpack_data
arguments: label: D121
type_guessed: string
name: unpack_data
arguments: label: D99
type_guessed: string
name: unpack_data
arguments: label: D179
type_guessed: string
name: unpack_data
arguments: label: D125
type_guessed: string
name: unpack_data
arguments: label: D119
type_guessed: f32[2]
name: unpack_data
arguments: label: D172
type_guessed: string
name: unpack_data
arguments: label: D12
type_guessed: string
name: unpack_data
arguments: label: D183
type_guessed: string
name: unpack_data
arguments: label: D89
type_guessed: string
name: unpack_data
arguments: label: D49
type_guessed: string
name: unpack_data
arguments: label: D164
type_guessed: string

tool: D178: 
		---------------------------------------------------------------------------

tool: D93: 
		 Email : RarchK

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

tool: D187: 
		 Matrix into Matrix Multiplication using 

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

tool: D81: 
		..........................................................................

tool: D192: 		 Very Few Arguments
 

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

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

tool: D99: A

tool: D179: 
		 Matrix Size :  %d

tool: D125: 
		 Threads     :  %d

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

tool: D172: 
		 Memory Utilized            : %lf MB 


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


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

tool: D89: B

tool: D49: C

tool: D164: 
		 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);
}
```