user: 请显示与下面列出的汇编代码相匹配的C语言实现:

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x60,%rsp
  mov    %edi,-0x54(%rbp)
  mov    %rsi,-0x60(%rbp)
  pxor   %xmm0,%xmm0
  movsd  %xmm0,-0x28(%rbp)
  pxor   %xmm0,%xmm0
  movsd  %xmm0,-0x20(%rbp)
  lea    D115(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D174(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D115(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D66(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D124(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D188(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D118(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  cmpl   $0x3,-0x54(%rbp)
  je     L113
  lea    D57(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D202(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D0(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
  jmp    L149
L113:
  mov    -0x60(%rbp),%rax
  mov    0x8(%rax),%rax
  mov    %rax,-0x30(%rbp)
  mov    -0x60(%rbp),%rax
  add    $0x10,%rax
  mov    (%rax),%rax
  mov    %rax,%rdi
  call   <atoi@plt>
  mov    %eax,-0x3c(%rbp)
L149:
  mov    -0x30(%rbp),%rax
  lea    D28(%rip),%rdx
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L11
  movl   $0x400,-0x48(%rbp)
  jmp    L122
L11:
  mov    -0x30(%rbp),%rax
  lea    D164(%rip),%rdx
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L42
  movl   $0x800,-0x48(%rbp)
  jmp    L122
L42:
  mov    -0x30(%rbp),%rax
  lea    D196(%rip),%rdx
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L20
  movl   $0x1000,-0x48(%rbp)
  jmp    L122
L20:
  lea    D190(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
L122:
  mov    -0x48(%rbp),%eax
  mov    %eax,-0x38(%rbp)
  mov    -0x3c(%rbp),%eax
  mov    %eax,-0x34(%rbp)
  mov    -0x38(%rbp),%eax
  mov    %eax,%esi
  lea    D70(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x34(%rbp),%eax
  mov    %eax,%esi
  lea    D112(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0xa,%edi
  call   <putchar@plt>
  mov    -0x38(%rbp),%eax
  cltq
  shl    $0x3,%eax
  mov    %eax,%edi
  call   <malloc@plt>
  mov    %rax,-0x18(%rbp)
  movl   $0x0,-0x44(%rbp)
  jmp    L29
L100:
  mov    -0x38(%rbp),%eax
  cltq
  shl    $0x3,%eax
  mov    %eax,%edi
  call   <malloc@plt>
  mov    -0x44(%rbp),%edx
  movslq %edx,%rdx
  lea    0x0(,%rdx,8),%rcx
  mov    -0x18(%rbp),%rdx
  add    %rcx,%rdx
  mov    %rax,(%rdx)
  movl   $0x0,-0x40(%rbp)
  jmp    L64
L152:
  mov    -0x44(%rbp),%edx
  mov    -0x40(%rbp),%eax
  lea    (%rdx,%rax,1),%ecx
  mov    -0x44(%rbp),%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  mov    -0x18(%rbp),%rax
  add    %rdx,%rax
  mov    (%rax),%rdx
  mov    -0x40(%rbp),%eax
  cltq
  shl    $0x3,%rax
  add    %rdx,%rax
  pxor   %xmm0,%xmm0
  cvtsi2sd %ecx,%xmm0
  movsd  %xmm0,(%rax)
  addl   $0x1,-0x40(%rbp)
L64:
  mov    -0x40(%rbp),%eax
  cmp    -0x38(%rbp),%eax
  jl     L152
  addl   $0x1,-0x44(%rbp)
L29:
  mov    -0x44(%rbp),%eax
  cmp    -0x38(%rbp),%eax
  jl     L100
  mov    -0x38(%rbp),%eax
  cltq
  shl    $0x3,%eax
  mov    %eax,%edi
  call   <malloc@plt>
  mov    %rax,-0x10(%rbp)
  movl   $0x0,-0x44(%rbp)
  jmp    L22
L123:
  mov    -0x38(%rbp),%eax
  cltq
  shl    $0x3,%eax
  mov    %eax,%edi
  call   <malloc@plt>
  mov    -0x44(%rbp),%edx
  movslq %edx,%rdx
  lea    0x0(,%rdx,8),%rcx
  mov    -0x10(%rbp),%rdx
  add    %rcx,%rdx
  mov    %rax,(%rdx)
  movl   $0x0,-0x40(%rbp)
  jmp    L19
L68:
  mov    -0x44(%rbp),%edx
  mov    -0x40(%rbp),%eax
  lea    (%rdx,%rax,1),%ecx
  mov    -0x44(%rbp),%eax
  cltq
  lea    0x0(,%rax,8),%rdx
  mov    -0x10(%rbp),%rax
  add    %rdx,%rax
  mov    (%rax),%rdx
  mov    -0x40(%rbp),%eax
  cltq
  shl    $0x3,%rax
  add    %rdx,%rax
  pxor   %xmm0,%xmm0
  cvtsi2sd %ecx,%xmm0
  movsd  %xmm0,(%rax)
  addl   $0x1,-0x40(%rbp)
L19:
  mov    -0x40(%rbp),%eax
  cmp    -0x38(%rbp),%eax
  jl     L68
  addl   $0x1,-0x44(%rbp)
L22:
  mov    -0x44(%rbp),%eax
  cmp    -0x38(%rbp),%eax
  jl     L123
  mov    -0x38(%rbp),%eax
  cltq
  shl    $0x3,%eax
  mov    %eax,%edi
  call   <malloc@plt>
  mov    %rax,-0x8(%rbp)
  movl   $0x0,-0x44(%rbp)
  jmp    L104
L187:
  mov    -0x38(%rbp),%eax
  cltq
  shl    $0x3,%eax
  mov    %eax,%edi
  call   <malloc@plt>
  mov    -0x44(%rbp),%edx
  movslq %edx,%rdx
  lea    0x0(,%rdx,8),%rcx
  mov    -0x8(%rbp),%rdx
  add    %rcx,%rdx
  mov    %rax,(%rdx)
  addl   $0x1,-0x44(%rbp)
L104:
  mov    -0x44(%rbp),%eax
  cmp    -0x38(%rbp),%eax
  jl     L187
  mov    -0x38(%rbp),%eax
  imul   %eax,%eax
  mov    %eax,%edx
  mov    %edx,%eax
  add    %eax,%eax
  add    %edx,%eax
  cltq
  shl    $0x3,%rax
  test   %rax,%rax
  js     L150
  pxor   %xmm0,%xmm0
  cvtsi2sd %rax,%xmm0
  jmp    L86
L150:
  mov    %rax,%rdx
  shr    %rdx
  and    $0x1,%eax
  or     %rax,%rdx
  pxor   %xmm0,%xmm0
  cvtsi2sd %rdx,%xmm0
  addsd  %xmm0,%xmm0
L86:
  movsd  %xmm0,-0x20(%rbp)
  mov    -0x34(%rbp),%edi
  mov    -0x38(%rbp),%ecx
  mov    -0x8(%rbp),%rdx
  mov    -0x10(%rbp),%rsi
  mov    -0x18(%rbp),%rax
  mov    %edi,%r8d
  mov    %rax,%rdi
  call   <Matrix_Multiplication_Static@plt>
  movq   %xmm0,%rax
  mov    %rax,-0x28(%rbp)
  movsd  -0x20(%rbp),%xmm0
  movsd  D107(%rip),%xmm1
  divsd  %xmm1,%xmm0
  movq   %xmm0,%rax
  movq   %rax,%xmm0
  lea    D155(%rip),%rax
  mov    %rax,%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  mov    -0x28(%rbp),%rax
  movq   %rax,%xmm0
  lea    D168(%rip),%rax
  mov    %rax,%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    D91(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D118(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x18(%rbp),%rax
  mov    %rax,%rdi
  call   <free@plt>
  mov    -0x10(%rbp),%rax
  mov    %rax,%rdi
  call   <free@plt>
  mov    -0x8(%rbp),%rax
  mov    %rax,%rdi
  call   <free@plt>
  mov    $0x0,%eax
  leave
  ret
```

tool_calls: name: retrieve_data
arguments: tag: D115
data_type: string
name: retrieve_data
arguments: tag: D174
data_type: string
name: retrieve_data
arguments: tag: D66
data_type: string
name: retrieve_data
arguments: tag: D124
data_type: string
name: retrieve_data
arguments: tag: D188
data_type: string
name: retrieve_data
arguments: tag: D118
data_type: string
name: retrieve_data
arguments: tag: D57
data_type: string
name: retrieve_data
arguments: tag: D202
data_type: string
name: retrieve_data
arguments: tag: D0
data_type: string
name: retrieve_data
arguments: tag: D28
data_type: string
name: retrieve_data
arguments: tag: D164
data_type: string
name: retrieve_data
arguments: tag: D196
data_type: string
name: retrieve_data
arguments: tag: D190
data_type: string
name: retrieve_data
arguments: tag: D70
data_type: string
name: retrieve_data
arguments: tag: D112
data_type: string
name: retrieve_data
arguments: tag: D107
data_type: f32[2]
name: retrieve_data
arguments: tag: D155
data_type: string
name: retrieve_data
arguments: tag: D168
data_type: string
name: retrieve_data
arguments: tag: D91
data_type: string

tool: D115: 
		---------------------------------------------------------------------------

tool: D174: 
		 Email : RarchK

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

tool: D124: 
		 Matrix into Matrix Multiplication using 

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

tool: D118: 
		..........................................................................

tool: D57: 		 Very Few Arguments
 

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

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

tool: D28: A

tool: D164: B

tool: D196: C

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

tool: D70: 
		 Matrix Size :  %d

tool: D112: 
		 Threads     :  %d

tool: {"D107": [0.0,11.0]}

tool: D155: 
		 Memory Utilized            : %lf MB 


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


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

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