user: What would the C source look like for the assembly code provided here?

```asm
<MatLibtest>:
  endbr64
  push   %r15
  lea    D185(%rip),%rdi
  push   %r14
  movabs $0x300000003,%r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  movabs $0x400000003f800000,%rbx
  sub    $0x298,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x288(%rsp)
  xor    %eax,%eax
  lea    0xb0(%rsp),%r12
  lea    0xe0(%rsp),%rbp
  call   <puts@plt>
  pxor   %xmm0,%xmm0
  movabs $0x4040000040000000,%r10
  movabs $0x3f80000040400000,%rax
  lea    D58(%rip),%rdi
  mov    %r10,0xc0(%rsp)
  lea    0x18(%rsp),%r13
  movaps %xmm0,0x110(%rsp)
  lea    0x110(%rsp),%r15
  movaps %xmm0,0x120(%rsp)
  mov    %r14,0x18(%rsp)
  mov    %r14,0x20(%rsp)
  mov    %rbx,0xb0(%rsp)
  mov    %rax,0xb8(%rsp)
  mov    %rbx,0xc8(%rsp)
  movl   $0x40400000,0xd0(%rsp)
  movq   $0x40000000,0xe0(%rsp)
  movq   $0x0,0xe8(%rsp)
  movq   $0x40000000,0xf0(%rsp)
  movq   $0x0,0xf8(%rsp)
  movl   $0x40000000,0x100(%rsp)
  movl   $0x0,0x130(%rsp)
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r12,%rdi
  call   <print@plt>
  lea    D6(%rip),%rdi
  call   <puts@plt>
  mov    %rbp,%rdi
  mov    $0x3,%edx
  mov    $0x3,%esi
  call   <print@plt>
  lea    0x20(%rsp),%r9
  mov    %r15,%r8
  mov    %rbp,%rdx
  mov    %r9,%rcx
  mov    %r13,%rsi
  mov    %r12,%rdi
  mov    %r9,0x8(%rsp)
  call   <MatMultiplication@plt>
  lea    D163(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r15,%rdi
  call   <print@plt>
  mov    %r15,%rdi
  lea    0x90(%rsp),%r15
  call   <MatDet3by3@plt>
  lea    D71(%rip),%rdi
  mov    $0x1,%eax
  cvtss2sd %xmm0,%xmm0
  call   <printf@plt>
  mov    %rbp,%rdx
  mov    %r13,%rsi
  lea    0x140(%rsp),%r8
  mov    %r12,%rdi
  mov    %r8,%rcx
  mov    %r8,(%rsp)
  call   <MatAddition@plt>
  lea    D126(%rip),%rdi
  call   <puts@plt>
  mov    (%rsp),%rdi
  mov    $0x3,%edx
  mov    $0x3,%esi
  call   <print@plt>
  lea    0x170(%rsp),%r8
  mov    %r13,%rsi
  mov    %r12,%rdi
  mov    %r8,%rdx
  mov    %r8,(%rsp)
  call   <MatTranspose@plt>
  lea    D12(%rip),%rdi
  call   <puts@plt>
  mov    (%rsp),%rdi
  mov    $0x3,%edx
  mov    $0x3,%esi
  call   <print@plt>
  lea    0x1d0(%rsp),%r8
  mov    %rbp,%rdi
  mov    %r8,%rsi
  mov    %r8,(%rsp)
  call   <MatInv3by3@plt>
  lea    D184(%rip),%rdi
  call   <puts@plt>
  mov    (%rsp),%rdi
  mov    $0x3,%edx
  mov    $0x3,%esi
  call   <print@plt>
  lea    D77(%rip),%rdi
  movabs $0x4040000040000000,%r10
  movabs $0x4000000040800000,%rax
  mov    %r10,0x90(%rsp)
  mov    %rax,0x98(%rsp)
  call   <puts@plt>
  mov    $0x2,%edx
  mov    $0x2,%esi
  mov    %r15,%rdi
  call   <print@plt>
  mov    %r15,%rdi
  call   <MatDet2by2@plt>
  lea    D138(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    0xa0(%rsp),%r8
  mov    %r15,%rdi
  lea    0x200(%rsp),%r15
  mov    %r8,%rsi
  mov    %r8,(%rsp)
  call   <MatInv2by2@plt>
  lea    D35(%rip),%rdi
  call   <puts@plt>
  mov    (%rsp),%rdi
  mov    $0x2,%edx
  mov    $0x2,%esi
  call   <print@plt>
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  movss  D21(%rip),%xmm0
  lea    0x1a0(%rsp),%r12
  lea    0x60(%rsp),%r13
  call   <MatScalarMult@plt>
  mov    D48(%rip),%rax
  lea    D49(%rip),%rdi
  movq   %rax,%xmm0
  mov    $0x1,%eax
  call   <printf@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r15,%rdi
  call   <print@plt>
  lea    D89(%rip),%rdi
  lea    0x6c(%rsp),%r15
  call   <puts@plt>
  mov    0x8(%rsp),%rsi
  mov    %r12,%rdx
  mov    %rbp,%rdi
  lea    0x230(%rsp),%rbp
  call   <NormalizeMatrix@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r12,%rdi
  call   <print@plt>
  lea    D102(%rip),%r12
  mov    %rbx,0x60(%rsp)
  mov    %r12,%rdi
  movl   $0x40400000,0x68(%rsp)
  mov    %rbx,0x6c(%rsp)
  movl   $0x40400000,0x74(%rsp)
  call   <puts@plt>
  mov    $0x1,%edx
  mov    $0x3,%esi
  mov    %r13,%rdi
  call   <print@plt>
  mov    %r12,%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x1,%esi
  mov    %r15,%rdi
  call   <print@plt>
  mov    %rbp,%rsi
  mov    %r13,%rdi
  lea    D158(%rip),%r13
  call   <crossSkew@plt>
  mov    %r13,%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    %rbp,%rdi
  mov    $0x3,%esi
  call   <print@plt>
  mov    %rbp,%rsi
  mov    %r15,%rdi
  call   <crossSkew@plt>
  mov    %r13,%rdi
  lea    0x78(%rsp),%r13
  call   <puts@plt>
  mov    %rbp,%rdi
  mov    $0x3,%edx
  mov    $0x3,%esi
  call   <print@plt>
  lea    0x84(%rsp),%rbp
  mov    %r14,0x28(%rsp)
  mov    %r13,%rdx
  lea    0x260(%rsp),%r14
  mov    %rbp,%r8
  lea    0x30(%rsp),%rcx
  movabs $0x100000003,%rax
  lea    0x28(%rsp),%rsi
  mov    %r14,%rdi
  movq   $0x3f800000,0x260(%rsp)
  movq   $0x0,0x268(%rsp)
  movq   $0x3f800000,0x270(%rsp)
  movq   $0x0,0x278(%rsp)
  movl   $0x3f800000,0x280(%rsp)
  mov    %rbx,0x78(%rsp)
  movl   $0x40400000,0x80(%rsp)
  mov    %rax,0x30(%rsp)
  call   <MatMultiplication@plt>
  lea    D56(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r14,%rdi
  call   <print@plt>
  mov    %r12,%rdi
  lea    0x48(%rsp),%r12
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x1,%esi
  mov    %r13,%rdi
  call   <print@plt>
  lea    D157(%rip),%rdi
  lea    0x50(%rsp),%r13
  call   <puts@plt>
  mov    %rbp,%rdi
  mov    $0x1,%edx
  mov    $0x3,%esi
  call   <print@plt>
  lea    0x38(%rsp),%rbp
  mov    %r12,%rdx
  mov    %r13,%rsi
  lea    0x58(%rsp),%rcx
  lea    0x14(%rsp),%r8
  mov    %rbp,%rdi
  movabs $0x3f8000003f800000,%rax
  mov    %rax,0x38(%rsp)
  mov    %rax,0x48(%rsp)
  movabs $0x200000001,%rax
  mov    %rax,0x50(%rsp)
  movabs $0x100000002,%rax
  mov    %rax,0x58(%rsp)
  call   <MatMultiplication@plt>
  mov    $0x2,%edx
  mov    $0x1,%esi
  mov    %rbp,%rdi
  call   <print@plt>
  mov    $0x1,%edx
  mov    $0x2,%esi
  mov    %r12,%rdi
  call   <print@plt>
  pxor   %xmm0,%xmm0
  lea    0x40(%rsp),%r12
  lea    D74(%rip),%rdi
  cvtss2sd 0x14(%rsp),%xmm0
  addsd  D48(%rip),%xmm0
  mov    $0x1,%eax
  call   <printf@plt>
  mov    %r12,%rdx
  mov    %r13,%rsi
  mov    %rbp,%rdi
  call   <NormalizeMatrix@plt>
  lea    D83(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edx
  mov    $0x2,%esi
  mov    %r12,%rdi
  call   <print@plt>
  mov    0x288(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L0
  add    $0x298,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L0:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: tag: D185
datatype: string
name: parse_data
arguments: tag: D58
datatype: string
name: parse_data
arguments: tag: D6
datatype: string
name: parse_data
arguments: tag: D163
datatype: string
name: parse_data
arguments: tag: D71
datatype: string
name: parse_data
arguments: tag: D126
datatype: string
name: parse_data
arguments: tag: D12
datatype: string
name: parse_data
arguments: tag: D184
datatype: string
name: parse_data
arguments: tag: D77
datatype: string
name: parse_data
arguments: tag: D138
datatype: string
name: parse_data
arguments: tag: D35
datatype: string
name: parse_data
arguments: tag: D21
datatype: f32
name: parse_data
arguments: tag: D48
datatype: byte[8]
name: parse_data
arguments: tag: D49
datatype: string
name: parse_data
arguments: tag: D89
datatype: string
name: parse_data
arguments: tag: D102
datatype: string
name: parse_data
arguments: tag: D158
datatype: string
name: parse_data
arguments: tag: D56
datatype: string
name: parse_data
arguments: tag: D157
datatype: string
name: parse_data
arguments: tag: D74
datatype: string
name: parse_data
arguments: tag: D83
datatype: string

tool: D185: Matrix Library Test 

tool: D58: Matrix A 

tool: D6: Matrix B 

tool: D163: Matrix A*B 

tool: D71: Determinant of Matrix A*B %f 


tool: D126: Addition of Matrix A and B 

tool: D12: Transpose of Matrix A 

tool: D184: Inverse of Matrix B 

tool: D77: Matrix C is 

tool: D138: Determinant of Matrix C is %f 


tool: D35: Inverse of Matrix C 

tool: D21: 2

tool: {"D48": [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40]}

tool: D49: Scalar Multiplication of %f and Matrix A is 


tool: D89: Normalized Matrix B is 

tool: D102: Vector 

tool: D158: SkewMatrix 

tool: D56: Rotation Matrix 

tool: D157: Matrix Array Multiplcation 

tool: D74: %f 


tool: D83: Normalized Vector

assistant: ```c
void MatLibtest(void) {
  printf("Matrix Library Test \n");
  float arr1[3][3] = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
  float arr2[3][3] = {{2, 0, 0}, {0, 2, 0}, {0, 0, 2}};
  float multiCheck[3][3] = {{0}};
  float additionCheck[3][3];
  float transposeCheck[3][3];
  float normCheck[3][3];
  float matInverse[3][3];
  unsigned int sizearr1[2] = {3, 3};
  unsigned int sizearr2[2] = {3, 3};
  printf("Matrix A \n");
  print((float *)arr1, 3, 3);
  printf("Matrix B \n");
  print((float *)arr2, 3, 3);
  MatMultiplication((float *)arr1, sizearr1, (float *)arr2, sizearr2, (float *)multiCheck);
  printf("Matrix A*B \n");
  print((float *)multiCheck, 3, 3);
  float det = MatDet3by3((float *)multiCheck);
  printf("Determinant of Matrix A*B %f \n", det);
  MatAddition((float *)arr1, sizearr1, (float *)arr2, (float *)additionCheck);
  printf("Addition of Matrix A and B \n");
  print((float *)additionCheck, 3, 3);
  MatTranspose((float *)arr1, sizearr1, (float *)transposeCheck);
  printf("Transpose of Matrix A \n");
  print((float *)transposeCheck, 3, 3);
  MatInv3by3((float *)arr2, (float *)matInverse);
  printf("Inverse of Matrix B \n");
  print((float *)matInverse, 3, 3);
  float arr3[2][2] = {{2, 3}, {4, 2}};
  float invMat2by2[2][2];
  printf("Matrix C is \n");
  print((float *)arr3, 2, 2);
  printf("Determinant of Matrix C is %f \n", MatDet2by2((float *)arr3));
  MatInv2by2((float *)arr3, (float *)invMat2by2);
  printf("Inverse of Matrix C \n");
  print((float *)invMat2by2, 2, 2);
  float scalarMulti[3][3];
  float scalar = 2.0;
  MatScalarMult((float *)arr1, sizearr1, scalar, (float *)scalarMulti);
  printf("Scalar Multiplication of %f and Matrix A is \n", scalar);
  print((float *)scalarMulti, 3, 3);
  printf("Normalized Matrix B is \n");
  NormalizeMatrix((float *)arr2, sizearr2, (float *)normCheck);
  print((float *)normCheck, 3, 3);
  float omegaVec[3][1] = {{1}, {2}, {3}};
  float omegaVecT[1][3] = {{1, 2, 3}};
  float omegaSkew[3][3];
  printf("Vector \n");
  print((float *)omegaVec, 3, 1);
  printf("Vector \n");
  print((float *)omegaVecT, 1, 3);
  crossSkew((float *)omegaVec, (float *)omegaSkew);
  printf("SkewMatrix \n");
  print((float *)omegaSkew, 3, 3);
  crossSkew((float *)omegaVecT, (float *)omegaSkew);
  printf("SkewMatrix \n");
  print((float *)omegaSkew, 3, 3);
  float rotMat[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
  float accVec[3] = {1, 2, 3};
  unsigned int sizerotMat[2] = {3, 3};
  unsigned int sizeaccVec[2] = {3, 1};
  float op[3][1];
  MatMultiplication((float *)rotMat, sizerotMat, (float *)accVec, sizeaccVec, (float *)op);
  printf("Rotation Matrix \n");
  print((float *)rotMat, 3, 3);
  printf("Vector \n");
  print((float *)accVec, 1, 3);
  printf("Matrix Array Multiplcation \n");
  print((float *)op, 3, 1);
  float xVec[1][2] = {{1, 1}};
  float xVecnorm[1][2];
  float yVec[2][1] = {{1}, {1}};
  float xyelem[1][1];
  unsigned int xSize[2] = {1, 2};
  unsigned int ySize[2] = {2, 1};
  MatMultiplication((float *)xVec, xSize, (float *)yVec, ySize, (float *)xyelem);
  print((float *)xVec, 1, 2);
  print((float *)yVec, 2, 1);
  printf("%f \n", (xyelem[0][0] + 2.0));
  NormalizeMatrix((float *)xVec, xSize, (float *)xVecnorm);
  printf("Normalized Vector");
  print((float *)xVecnorm, 2, 1);
}
```