user: 请从给定的汇编指令推导出C源代码：

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x68,%rsp
  mov    %edi,%ebx
  mov    %rsi,%rbp
  mov    %fs:0x28,%rax
  mov    %rax,0x58(%rsp)
  xor    %eax,%eax
  lea    D217(%rip),%r12
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D24(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D76(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D72(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D18(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D164(%rip),%rdi
  call   <puts@plt>
  cmp    $0x6,%ebx
  jne    L235
L47:
  mov    0x8(%rbp),%rdi
  call   <atoi@plt>
  mov    %eax,%ebx
  mov    %eax,0x20(%rsp)
  cmp    $0x10,%eax
  ja     L339
  mov    $0x10116,%eax
  mov    %ebx,%ecx
  shr    %cl,%rax
  test   $0x1,%al
  je     L339
L250:
  mov    0x10(%rbp),%rdi
  call   <atoi@plt>
  mov    %eax,%r13d
  mov    0x18(%rbp),%rdi
  call   <atoi@plt>
  mov    %eax,%ebx
  mov    0x20(%rbp),%rdi
  call   <atoi@plt>
  mov    %eax,%r14d
  mov    %eax,(%rsp)
  mov    0x28(%rbp),%rdi
  call   <atoi@plt>
  mov    %eax,%r15d
  mov    0x20(%rsp),%esi
  lea    D65(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %ebx,%edx
  mov    %r13d,%esi
  lea    D95(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r15d,%edx
  mov    %r14d,%esi
  lea    D143(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  test   %r13d,%r13d
  jle    L508
  test   %ebx,%ebx
  jle    L508
  test   %r14d,%r14d
  jle    L23
  test   %r15d,%r15d
  jle    L23
  cmp    (%rsp),%ebx
  jne    L221
  lea    0x0(,%r13,8),%eax
  mov    %eax,0x8(%rsp)
  mov    %eax,%edi
  call   <malloc@plt>
  mov    %rax,0x18(%rsp)
  jmp    L21
L235:
  lea    D208(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D89(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
  jmp    L47
L339:
  lea    D93(%rip),%rdi
  call   <puts@plt>
  mov    $0xffffffff,%edi
  call   <exit@plt>
  jmp    L250
L508:
  lea    D0(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  cmp    (%rsp),%ebx
  je     L118
L221:
  lea    D168(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%edi
  call   <exit@plt>
L118:
  lea    0x0(,%r13,8),%eax
  mov    %eax,0x8(%rsp)
  mov    %eax,%edi
  call   <malloc@plt>
  mov    %rax,0x18(%rsp)
  test   %r13d,%r13d
  jle    L363
L21:
  lea    0x0(,%rbx,4),%eax
  mov    0x18(%rsp),%r12
  mov    %ebx,%ebp
  mov    $0x0,%r14d
  mov    %r15d,0x10(%rsp)
  mov    %eax,%r15d
L114:
  mov    %r15d,%edi
  call   <malloc@plt>
  mov    %r12,%rsi
  mov    %rax,(%r12)
  test   %ebx,%ebx
  jle    L386
  mov    %r14d,%eax
  mov    $0x0,%edx
L205:
  mov    (%rsi),%rcx
  pxor   %xmm0,%xmm0
  cvtsi2ss %eax,%xmm0
  movss  %xmm0,(%rcx,%rdx,1)
  add    $0x4,%rdx
  add    $0x1,%eax
  cmp    %ebp,%eax
  jne    L205
L386:
  add    $0x1,%r14d
  add    $0x8,%r12
  add    $0x1,%ebp
  cmp    %r14d,%r13d
  jg     L114
  mov    0x10(%rsp),%r15d
L363:
  mov    (%rsp),%ebp
  lea    0x0(,%rbp,8),%edi
  call   <malloc@plt>
  mov    %rax,%r14
  mov    %ebp,%eax
  test   %ebp,%ebp
  jle    L485
  lea    0x0(,%r15,4),%edi
  mov    %r14,%r12
  add    %r15d,%eax
  mov    %r15d,%ebp
  mov    %r14,(%rsp)
  mov    %r13d,0x10(%rsp)
  mov    %edi,%r13d
  mov    %eax,%r14d
L39:
  mov    %r13d,%edi
  call   <malloc@plt>
  mov    %r12,%rsi
  mov    %rax,(%r12)
  test   %r15d,%r15d
  jle    L360
  mov    %ebp,%eax
  sub    %r15d,%eax
  mov    $0x0,%edx
L192:
  mov    (%rsi),%rcx
  pxor   %xmm0,%xmm0
  cvtsi2ss %eax,%xmm0
  movss  %xmm0,(%rcx,%rdx,1)
  add    $0x4,%rdx
  add    $0x1,%eax
  cmp    %ebp,%eax
  jne    L192
L360:
  add    $0x8,%r12
  add    $0x1,%ebp
  cmp    %r14d,%ebp
  jne    L39
  mov    (%rsp),%r14
  mov    0x10(%rsp),%r13d
L485:
  mov    0x8(%rsp),%ebp
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,%r12
  mov    %rax,0x8(%rsp)
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,%rdx
  mov    %rax,(%rsp)
  test   %r13d,%r13d
  jle    L515
  lea    0x0(,%r15,4),%ebp
  mov    %r13d,%r13d
  lea    0x0(,%r13,8),%rsi
  mov    %rsi,0x28(%rsp)
  add    %r12,%rsi
  lea    -0x1(%r15),%eax
  lea    0x4(,%rax,4),%r13
  sub    %r12,%rdx
  mov    %rdx,0x10(%rsp)
  mov    %r14,0x30(%rsp)
  mov    %ebx,0x3c(%rsp)
  mov    %rsi,%r14
L454:
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %r12,%rbx
  mov    %rax,(%r12)
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    0x10(%rsp),%rdi
  lea    (%rdi,%r12,1),%rcx
  mov    %rax,(%rcx)
  test   %r15d,%r15d
  jle    L164
  mov    $0x0,%eax
L198:
  mov    (%rbx),%rdx
  movl   $0x0,(%rdx,%rax,1)
  mov    (%rcx),%rdx
  movl   $0x0,(%rdx,%rax,1)
  add    $0x4,%rax
  cmp    %r13,%rax
  jne    L198
L164:
  add    $0x8,%r12
  cmp    %r14,%r12
  jne    L454
  mov    0x30(%rsp),%r14
  mov    0x3c(%rsp),%ebx
  lea    0x40(%rsp),%rsi
  lea    0x48(%rsp),%rdi
  call   <gettimeofday@plt>
  mov    0x20(%rsp),%edi
  call   <omp_set_num_threads@plt>
  mov    0x18(%rsp),%rdi
  mov    %rdi,0x10(%rsp)
  mov    0x28(%rsp),%r12
  add    %rdi,%r12
  lea    -0x1(%rbx),%eax
  lea    0x4(,%rax,4),%rbp
  mov    0x8(%rsp),%r9
  sub    %rdi,%r9
  jmp    L518
L203:
  mov    %rsi,%rcx
  add    (%r8),%rcx
  mov    (%rdi),%r11
  mov    (%rdx),%r10
  movss  (%r11,%rax,1),%xmm0
  mulss  (%r10,%rsi,1),%xmm0
  addss  (%rcx),%xmm0
  movss  %xmm0,(%rcx)
  add    $0x4,%rax
  add    $0x8,%rdx
  cmp    %rbp,%rax
  jne    L203
L258:
  add    $0x4,%rsi
  cmp    %r13,%rsi
  je     L230
L428:
  mov    %r14,%rdx
  mov    $0x0,%eax
  test   %ebx,%ebx
  jg     L203
  jmp    L258
L230:
  add    $0x8,%rdi
  cmp    %r12,%rdi
  je     L493
L518:
  test   %r15d,%r15d
  jle    L230
  lea    (%r9,%rdi,1),%r8
  mov    $0x0,%esi
  jmp    L428
L494:
  mov    %rsi,%rcx
  add    (%r8),%rcx
  mov    (%rdi),%r11
  mov    (%rdx),%r10
  movss  (%r11,%rax,1),%xmm0
  mulss  (%r10,%rsi,1),%xmm0
  addss  (%rcx),%xmm0
  movss  %xmm0,(%rcx)
  add    $0x4,%rax
  add    $0x8,%rdx
  cmp    %rbp,%rax
  jne    L494
L439:
  add    $0x4,%rsi
  cmp    %r13,%rsi
  je     L136
L156:
  mov    %r14,%rdx
  mov    $0x0,%eax
  test   %ebx,%ebx
  jg     L494
  jmp    L439
L136:
  add    $0x8,%rdi
  cmp    %r12,%rdi
  je     L436
L112:
  test   %r15d,%r15d
  jle    L136
  lea    (%r9,%rdi,1),%r8
  mov    $0x0,%esi
  jmp    L156
L436:
  mov    0x28(%rsp),%rax
  mov    (%rsp),%rbx
  add    %rbx,%rax
  mov    %rax,0x10(%rsp)
  mov    %r14,0x28(%rsp)
  mov    %rbx,%r14
  jmp    L16
L414:
  lea    D204(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%edi
  call   <exit@plt>
L401:
  add    $0x4,%rbx
  cmp    %r13,%rbx
  je     L294
L356:
  mov    (%r12),%rdx
  mov    0x0(%rbp),%rax
  movss  (%rdx,%rbx,1),%xmm0
  ucomiss (%rax,%rbx,1),%xmm0
  jp     L414
  je     L401
  jmp    L414
L294:
  add    $0x8,%r14
  cmp    %r14,0x10(%rsp)
  je     L284
L16:
  test   %r15d,%r15d
  jle    L294
  mov    %r14,%r12
  mov    0x8(%rsp),%rbp
  sub    (%rsp),%rbp
  add    %r14,%rbp
  mov    $0x0,%ebx
  jmp    L356
L284:
  mov    0x28(%rsp),%r14
L109:
  lea    D191(%rip),%rdi
  call   <puts@plt>
  movsd  0x20(%rsp),%xmm0
  lea    D40(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    D50(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D164(%rip),%rdi
  call   <puts@plt>
  mov    0x18(%rsp),%rdi
  call   <free@plt>
  mov    %r14,%rdi
  call   <free@plt>
  mov    0x8(%rsp),%rdi
  call   <free@plt>
  mov    (%rsp),%rdi
  call   <free@plt>
  mov    0x58(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L30
  mov    $0x0,%eax
  add    $0x68,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L493:
  lea    0x44(%rsp),%rsi
  lea    0x50(%rsp),%rdi
  call   <gettimeofday@plt>
  imul   $0xf4240,0x50(%rsp),%eax
  add    0x54(%rsp),%eax
  cltq
  imul   $0xf4240,0x48(%rsp),%edx
  add    0x4c(%rsp),%edx
  movslq %edx,%rdx
  sub    %rdx,%rax
  pxor   %xmm0,%xmm0
  cvtsi2sd %rax,%xmm0
  divsd  D200(%rip),%xmm0
  movsd  %xmm0,0x20(%rsp)
  mov    0x10(%rsp),%rax
  mov    %rax,%rdi
  mov    (%rsp),%r9
  sub    %rax,%r9
  jmp    L112
L515:
  lea    0x40(%rsp),%rsi
  lea    0x48(%rsp),%rdi
  call   <gettimeofday@plt>
  mov    0x20(%rsp),%edi
  call   <omp_set_num_threads@plt>
  lea    0x44(%rsp),%rsi
  lea    0x50(%rsp),%rdi
  call   <gettimeofday@plt>
  imul   $0xf4240,0x50(%rsp),%eax
  add    0x54(%rsp),%eax
  cltq
  imul   $0xf4240,0x48(%rsp),%edx
  add    0x4c(%rsp),%edx
  movslq %edx,%rdx
  sub    %rdx,%rax
  pxor   %xmm0,%xmm0
  cvtsi2sd %rax,%xmm0
  divsd  D200(%rip),%xmm0
  movsd  %xmm0,0x20(%rsp)
  jmp    L109
L23:
  lea    D0(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%edi
  call   <exit@plt>
  cmp    (%rsp),%ebx
  jne    L221
  lea    0x0(,%r13,8),%eax
  mov    %eax,0x8(%rsp)
  mov    %eax,%edi
  call   <malloc@plt>
  mov    %rax,0x18(%rsp)
  jmp    L21
L30:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: label: D217
type: string
name: disassemble_data
arguments: label: D24
type: string
name: disassemble_data
arguments: label: D76
type: string
name: disassemble_data
arguments: label: D72
type: string
name: disassemble_data
arguments: label: D18
type: string
name: disassemble_data
arguments: label: D164
type: string
name: disassemble_data
arguments: label: D65
type: string
name: disassemble_data
arguments: label: D95
type: string
name: disassemble_data
arguments: label: D143
type: string
name: disassemble_data
arguments: label: D208
type: string
name: disassemble_data
arguments: label: D89
type: string
name: disassemble_data
arguments: label: D93
type: string
name: disassemble_data
arguments: label: D0
type: string
name: disassemble_data
arguments: label: D168
type: string
name: disassemble_data
arguments: label: D204
type: string
name: disassemble_data
arguments: label: D191
type: string
name: disassemble_data
arguments: label: D40
type: string
name: disassemble_data
arguments: label: D50
type: string
name: disassemble_data
arguments: label: D200
type: f64

tool: D217: 
		---------------------------------------------------------------------------

tool: D24: 
		 Email : RarchK

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

tool: D72: 
		 Matrix into Matrix Multiplication using 

tool: D18: 
		 OpenMP one PARALLEL for directive and Private Clause;

tool: D164: 
		..........................................................................

tool: D65: 
		 Threads        : %d 

tool: D95: 
		 Matrix A Size  : %d X %d 

tool: D143: 
		 Matrix B Size  : %d X %d 

tool: D208: 		 Very Few Arguments
 

tool: D89: 		 Syntax : exec <Threads> <NoOfRows A> <NoOfCols A>  <NoOfRows B> <NoOfCols B>

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


tool: D0: 
		 The NoofRows And NoofCols Should Be Of Positive Sign

tool: D168: 
		 Matrix Matrix Computation Is Not Possible 

tool: D204: 
		 There Is A Difference In Parallel Calculation 

tool: D191: 

		 Matrix into Matrix Multiplication using Parallel for directive......Done 

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


tool: D50: 
		   ( T represents the Time taken for computation )

tool: D200: 1000000

assistant: ```c
main(int argc, char **argv) {
  int NoofRows_A, NoofCols_A, NoofRows_B, NoofCols_B, i, j, k, Noofthreads;
  float **Matrix_A, **Matrix_B, **Result, **Checkoutput, flops;
  struct timeval TimeValue_Start;
  struct timezone TimeZone_Start;
  struct timeval TimeValue_Final;
  struct timezone TimeZone_Final;
  long time_start, time_end;
  double time_overhead;
  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 and Private Clause;");
  printf("\n\t\t..........................................................................\n");
  if (argc != 6) {
    printf("\t\t Very Few Arguments\n ");
    printf("\t\t Syntax : exec <Threads> <NoOfRows A> <NoOfCols A>  <NoOfRows B> <NoOfCols B>\n");
    exit(-1);
  }
  Noofthreads = atoi(argv[1]);
  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);
  }
  NoofRows_A = atoi(argv[2]);
  NoofCols_A = atoi(argv[3]);
  NoofRows_B = atoi(argv[4]);
  NoofCols_B = atoi(argv[5]);
  printf("\n\t\t Threads        : %d ", Noofthreads);
  printf("\n\t\t Matrix A Size  : %d X %d ", NoofRows_A, NoofCols_A);
  printf("\n\t\t Matrix B Size  : %d X %d ", NoofRows_B, NoofCols_B);
  if (NoofRows_A <= 0 || NoofCols_A <= 0 || NoofRows_B <= 0 || NoofCols_B <= 0) {
    printf("\n\t\t The NoofRows And NoofCols Should Be Of Positive Sign\n");
    exit(1);
  }
  if (NoofCols_A != NoofRows_B) {
    printf("\n\t\t Matrix Matrix Computation Is Not Possible \n");
    exit(1);
  }
  Matrix_A = (float **)malloc(sizeof(float *) * NoofRows_A);
  for (i = 0; i < NoofRows_A; i++) {
    Matrix_A[i] = (float *)malloc(sizeof(float) * NoofCols_A);
    for (j = 0; j < NoofCols_A; j++)
      Matrix_A[i][j] = i + j;
  }
  Matrix_B = (float **)malloc(sizeof(float *) * NoofRows_B);
  for (i = 0; i < NoofRows_B; i++) {
    Matrix_B[i] = (float *)malloc(sizeof(float) * NoofCols_B);
    for (j = 0; j < NoofCols_B; j++)
      Matrix_B[i][j] = i + j;
  }
  Result = (float **)malloc(sizeof(float *) * NoofRows_A);
  Checkoutput = (float **)malloc(sizeof(float *) * NoofRows_A);
  for (i = 0; i < NoofRows_A; i++) {
    Result[i] = (float *)malloc(sizeof(float) * NoofCols_B);
    Checkoutput[i] = (float *)malloc(sizeof(float) * NoofCols_B);
    for (j = 0; j < NoofCols_B; j++) {
      Result[i][j] = 0.0;
      Checkoutput[i][j] = 0.0;
    }
  }
  gettimeofday(&TimeValue_Start, &TimeZone_Start);
  omp_set_num_threads(Noofthreads);
#pragma omp parallel for private(j, k)
  for (i = 0; i < NoofRows_A; i = i + 1)
    for (j = 0; j < NoofCols_B; j = j + 1)
      for (k = 0; k < NoofCols_A; k = k + 1)
        Result[i][j] = Result[i][j] + Matrix_A[i][k] * Matrix_B[k][j];
  gettimeofday(&TimeValue_Final, &TimeZone_Final);
  time_start = TimeValue_Start.tv_sec * 1000000 + TimeValue_Start.tv_usec;
  time_end = TimeValue_Final.tv_sec * 1000000 + TimeValue_Final.tv_usec;
  time_overhead = (time_end - time_start) / 1000000.0;
  for (i = 0; i < NoofRows_A; i = i + 1)
    for (j = 0; j < NoofCols_B; j = j + 1)
      for (k = 0; k < NoofCols_A; k = k + 1)
        Checkoutput[i][j] = Checkoutput[i][j] + Matrix_A[i][k] * Matrix_B[k][j];
  for (i = 0; i < NoofRows_A; i = i + 1)
    for (j = 0; j < NoofCols_B; j = j + 1)
      if (Checkoutput[i][j] == Result[i][j])
        continue;
      else {
        printf("\n\t\t There Is A Difference In Parallel Calculation \n");
        exit(1);
      }
  printf("\n\n\t\t Matrix into Matrix Multiplication using Parallel for directive......Done \n");
  printf("\n\t\t Time in Seconds (T)        : %lf Seconds \n", time_overhead);
  printf("\n\t\t   ( T represents the Time taken for computation )");
  printf("\n\t\t..........................................................................\n");
  free(Matrix_A);
  free(Matrix_B);
  free(Result);
  free(Checkoutput);
}
```