user: Converte this assembly snippet into its equivalent C code:

```asm
<MatLibtest>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x2a8,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x298(%rsp)
  xor    %eax,%eax
  lea    D118(%rip),%rdi
  call   <puts@plt>
  mov    D153(%rip),%ebx
  mov    %ebx,0xc0(%rsp)
  mov    D186(%rip),%ebp
  mov    %ebp,0xc4(%rsp)
  mov    D29(%rip),%r12d
  mov    %r12d,0xc8(%rsp)
  mov    %ebx,0xcc(%rsp)
  mov    %ebp,0xd0(%rsp)
  mov    %r12d,0xd4(%rsp)
  mov    %ebx,0xd8(%rsp)
  mov    %ebp,0xdc(%rsp)
  mov    %r12d,0xe0(%rsp)
  mov    %ebp,0xf0(%rsp)
  movl   $0x0,0xf4(%rsp)
  movl   $0x0,0xf8(%rsp)
  movl   $0x0,0xfc(%rsp)
  mov    %ebp,0x100(%rsp)
  movl   $0x0,0x104(%rsp)
  movl   $0x0,0x108(%rsp)
  movl   $0x0,0x10c(%rsp)
  mov    %ebp,0x110(%rsp)
  movq   $0x0,0x120(%rsp)
  movq   $0x0,0x128(%rsp)
  movq   $0x0,0x130(%rsp)
  movq   $0x0,0x138(%rsp)
  movl   $0x0,0x140(%rsp)
  movl   $0x3,0x28(%rsp)
  movl   $0x3,0x2c(%rsp)
  movl   $0x3,0x30(%rsp)
  movl   $0x3,0x34(%rsp)
  lea    D10(%rip),%rdi
  call   <puts@plt>
  lea    0xc0(%rsp),%r14
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r14,%rdi
  call   <print@plt>
  lea    D123(%rip),%rdi
  call   <puts@plt>
  lea    0xf0(%rsp),%r13
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r13,%rdi
  call   <print@plt>
  lea    0x120(%rsp),%rax
  lea    0x30(%rsp),%rcx
  lea    0x28(%rsp),%r15
  mov    %rax,0x8(%rsp)
  mov    %rax,%r8
  mov    %rcx,0x10(%rsp)
  mov    %r13,%rdx
  mov    %r15,%rsi
  mov    %r14,%rdi
  call   <MatMultiplication@plt>
  lea    D96(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    0x8(%rsp),%rdi
  call   <print@plt>
  mov    0x8(%rsp),%rdi
  call   <MatDet3by3@plt>
  cvtss2sd %xmm0,%xmm0
  lea    D120(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    0x150(%rsp),%rax
  mov    %rax,0x8(%rsp)
  mov    %rax,%rcx
  mov    %r13,%rdx
  mov    %r15,%rsi
  mov    %r14,%rdi
  call   <MatAddition@plt>
  lea    D78(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    0x8(%rsp),%rdi
  call   <print@plt>
  lea    0x180(%rsp),%rax
  mov    %rax,0x8(%rsp)
  mov    %rax,%rdx
  mov    %r15,%rsi
  mov    %r14,%rdi
  call   <MatTranspose@plt>
  lea    D89(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    0x8(%rsp),%rdi
  call   <print@plt>
  lea    0x1e0(%rsp),%rax
  mov    %rax,0x8(%rsp)
  mov    %rax,%rsi
  mov    %r13,%rdi
  call   <MatInv3by3@plt>
  lea    D36(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    0x8(%rsp),%rdi
  call   <print@plt>
  mov    %ebp,0xa0(%rsp)
  mov    %r12d,0xa4(%rsp)
  movl   $0x40800000,0xa8(%rsp)
  mov    %ebp,0xac(%rsp)
  lea    D223(%rip),%rdi
  call   <puts@plt>
  lea    0xa0(%rsp),%rax
  mov    $0x2,%edx
  mov    $0x2,%esi
  mov    %rax,0x8(%rsp)
  mov    %rax,%rdi
  call   <print@plt>
  mov    0x8(%rsp),%rdi
  call   <MatDet2by2@plt>
  lea    D155(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    0xb0(%rsp),%rdx
  mov    %rdx,0x18(%rsp)
  mov    %rdx,%rsi
  mov    0x8(%rsp),%rdi
  call   <MatInv2by2@plt>
  lea    D68(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    $0x2,%esi
  mov    0x18(%rsp),%rdi
  call   <print@plt>
  lea    0x210(%rsp),%rax
  mov    %rax,0x8(%rsp)
  mov    %rax,%rdx
  movd   %ebp,%xmm0
  mov    %r15,%rsi
  mov    %r14,%rdi
  call   <MatScalarMult@plt>
  mov    D211(%rip),%rax
  movq   %rax,%xmm0
  lea    D189(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    0x8(%rsp),%rdi
  call   <print@plt>
  lea    D100(%rip),%rdi
  call   <puts@plt>
  lea    0x1b0(%rsp),%r14
  mov    %r14,%rdx
  mov    0x10(%rsp),%rsi
  mov    %r13,%rdi
  call   <NormalizeMatrix@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r14,%rdi
  call   <print@plt>
  mov    %ebx,0x70(%rsp)
  mov    %ebp,0x74(%rsp)
  mov    %r12d,0x78(%rsp)
  mov    %ebx,0x7c(%rsp)
  mov    %ebp,0x80(%rsp)
  mov    %r12d,0x84(%rsp)
  lea    D54(%rip),%r14
  mov    %r14,%rdi
  call   <puts@plt>
  lea    0x70(%rsp),%r15
  mov    $0x1,%edx
  mov    $0x3,%esi
  mov    %r15,%rdi
  call   <print@plt>
  mov    %r14,%rdi
  call   <puts@plt>
  lea    0x7c(%rsp),%rax
  mov    $0x3,%edx
  mov    $0x1,%esi
  mov    %rax,0x8(%rsp)
  mov    %rax,%rdi
  call   <print@plt>
  lea    0x240(%rsp),%r13
  mov    %r13,%rsi
  mov    %r15,%rdi
  call   <crossSkew@plt>
  lea    D79(%rip),%r15
  mov    %r15,%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r13,%rdi
  call   <print@plt>
  mov    %r13,%rsi
  mov    0x8(%rsp),%rdi
  call   <crossSkew@plt>
  mov    %r15,%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r13,%rdi
  call   <print@plt>
  mov    %ebx,0x270(%rsp)
  movl   $0x0,0x274(%rsp)
  movl   $0x0,0x278(%rsp)
  movl   $0x0,0x27c(%rsp)
  mov    %ebx,0x280(%rsp)
  movl   $0x0,0x284(%rsp)
  movl   $0x0,0x288(%rsp)
  movl   $0x0,0x28c(%rsp)
  mov    %ebx,0x290(%rsp)
  mov    %ebx,0x88(%rsp)
  mov    %ebp,0x8c(%rsp)
  mov    %r12d,0x90(%rsp)
  movl   $0x3,0x38(%rsp)
  movl   $0x3,0x3c(%rsp)
  movl   $0x3,0x40(%rsp)
  movl   $0x1,0x44(%rsp)
  lea    0x94(%rsp),%rbp
  lea    0x40(%rsp),%rcx
  lea    0x88(%rsp),%r12
  lea    0x38(%rsp),%rsi
  lea    0x270(%rsp),%r13
  mov    %rbp,%r8
  mov    %r12,%rdx
  mov    %r13,%rdi
  call   <MatMultiplication@plt>
  lea    D41(%rip),%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x3,%esi
  mov    %r13,%rdi
  call   <print@plt>
  mov    %r14,%rdi
  call   <puts@plt>
  mov    $0x3,%edx
  mov    $0x1,%esi
  mov    %r12,%rdi
  call   <print@plt>
  lea    D12(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%edx
  mov    $0x3,%esi
  mov    %rbp,%rdi
  call   <print@plt>
  mov    %ebx,0x48(%rsp)
  mov    %ebx,0x4c(%rsp)
  mov    %ebx,0x58(%rsp)
  mov    %ebx,0x5c(%rsp)
  movl   $0x1,0x60(%rsp)
  movl   $0x2,0x64(%rsp)
  movl   $0x2,0x68(%rsp)
  movl   $0x1,0x6c(%rsp)
  lea    0x68(%rsp),%rcx
  lea    0x58(%rsp),%rbp
  lea    0x60(%rsp),%r12
  lea    0x48(%rsp),%rbx
  lea    0x24(%rsp),%r8
  mov    %rbp,%rdx
  mov    %r12,%rsi
  mov    %rbx,%rdi
  call   <MatMultiplication@plt>
  mov    $0x2,%edx
  mov    $0x1,%esi
  mov    %rbx,%rdi
  call   <print@plt>
  mov    $0x1,%edx
  mov    $0x2,%esi
  mov    %rbp,%rdi
  call   <print@plt>
  pxor   %xmm0,%xmm0
  cvtss2sd 0x24(%rsp),%xmm0
  addsd  D211(%rip),%xmm0
  lea    D143(%rip),%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  lea    0x50(%rsp),%rbp
  mov    %rbp,%rdx
  mov    %r12,%rsi
  mov    %rbx,%rdi
  call   <NormalizeMatrix@plt>
  lea    D170(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%edx
  mov    $0x2,%esi
  mov    %rbp,%rdi
  call   <print@plt>
  mov    0x298(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L3
  add    $0x2a8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L3:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: tag: D118
type: string
name: extract_symbolic_data
arguments: tag: D153
type: byte[4]
name: extract_symbolic_data
arguments: tag: D186
type: f32
name: extract_symbolic_data
arguments: tag: D29
type: byte[4]
name: extract_symbolic_data
arguments: tag: D10
type: string
name: extract_symbolic_data
arguments: tag: D123
type: string
name: extract_symbolic_data
arguments: tag: D96
type: string
name: extract_symbolic_data
arguments: tag: D120
type: string
name: extract_symbolic_data
arguments: tag: D78
type: string
name: extract_symbolic_data
arguments: tag: D89
type: string
name: extract_symbolic_data
arguments: tag: D36
type: string
name: extract_symbolic_data
arguments: tag: D223
type: string
name: extract_symbolic_data
arguments: tag: D155
type: string
name: extract_symbolic_data
arguments: tag: D68
type: string
name: extract_symbolic_data
arguments: tag: D211
type: byte[8]
name: extract_symbolic_data
arguments: tag: D189
type: string
name: extract_symbolic_data
arguments: tag: D100
type: string
name: extract_symbolic_data
arguments: tag: D54
type: string
name: extract_symbolic_data
arguments: tag: D79
type: string
name: extract_symbolic_data
arguments: tag: D41
type: string
name: extract_symbolic_data
arguments: tag: D12
type: string
name: extract_symbolic_data
arguments: tag: D143
type: string
name: extract_symbolic_data
arguments: tag: D170
type: string

tool: D118: Matrix Library Test 

tool: {"D153": [0x00,0x00,0x80,0x3f]}

tool: D186: 2

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

tool: D10: Matrix A 

tool: D123: Matrix B 

tool: D96: Matrix A*B 

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


tool: D78: Addition of Matrix A and B 

tool: D89: Transpose of Matrix A 

tool: D36: Inverse of Matrix B 

tool: D223: Matrix C is 

tool: D155: Determinant of Matrix C is %f 


tool: D68: Inverse of Matrix C 

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

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


tool: D100: Normalized Matrix B is 

tool: D54: Vector 

tool: D79: SkewMatrix 

tool: D41: Rotation Matrix 

tool: D12: Matrix Array Multiplcation 

tool: D143: %f 


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