user: Translate the below assembly code into C programming language:

```asm
<main>:
  endbr64
  push   %r15
  lea    D83(%rip),%rdi
  xor    %r15d,%r15d
  push   %r14
  push   %r13
  xor    %r13d,%r13d
  push   %r12
  lea    D173(%rip),%r12
  push   %rbp
  lea    D139(%rip),%rbp
  push   %rbx
  sub    $0x698,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x688(%rsp)
  xor    %eax,%eax
  call   <printf@plt>
  lea    0x30(%rsp),%rsi
  lea    D62(%rip),%rdi
  xor    %eax,%eax
  call   <scanf@plt>
  lea    D3(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    0x34(%rsp),%rsi
  lea    D62(%rip),%rdi
  xor    %eax,%eax
  call   <scanf@plt>
  mov    0x30(%rsp),%esi
  lea    0x40(%rsp),%rax
  mov    %rax,0x8(%rsp)
  test   %esi,%esi
  jle    L324
  xchg   %ax,%ax
L164:
  mov    0x8(%rsp),%rax
  mov    0x34(%rsp),%ecx
  xor    %ebx,%ebx
  lea    (%rax,%r13,4),%r14
  test   %ecx,%ecx
  jle    L157
  nopl   0x0(%rax,%rax,1)
L76:
  mov    %ebx,%edx
  mov    %r15d,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <scanf@plt>
  add    $0x1,%ebx
  add    $0x4,%r14
  cmp    %ebx,0x34(%rsp)
  jg     L76
L157:
  add    $0x1,%r15d
  add    $0xa,%r13
  cmp    %r15d,0x30(%rsp)
  jg     L164
L324:
  lea    D77(%rip),%rdi
  xor    %eax,%eax
  xor    %r14d,%r14d
  xor    %ebp,%ebp
  call   <printf@plt>
  lea    0x38(%rsp),%rsi
  xor    %eax,%eax
  lea    D62(%rip),%rdi
  call   <scanf@plt>
  lea    D3(%rip),%rdi
  xor    %eax,%eax
  lea    D139(%rip),%r13
  call   <printf@plt>
  lea    0x3c(%rsp),%rsi
  xor    %eax,%eax
  lea    D62(%rip),%rdi
  call   <scanf@plt>
  mov    0x38(%rsp),%ecx
  lea    0x1d0(%rsp),%rax
  lea    D50(%rip),%r12
  mov    %rax,0x8(%rsp)
  test   %ecx,%ecx
  jle    L375
  nopw   0x0(%rax,%rax,1)
L356:
  mov    0x8(%rsp),%rax
  mov    0x3c(%rsp),%edx
  xor    %r15d,%r15d
  lea    (%rax,%r14,4),%rbx
  test   %edx,%edx
  jle    L83
  nopl   0x0(%rax)
L32:
  mov    %r15d,%edx
  mov    %ebp,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %rbx,%rsi
  mov    %r13,%rdi
  xor    %eax,%eax
  call   <scanf@plt>
  add    $0x1,%r15d
  add    $0x4,%rbx
  cmp    %r15d,0x3c(%rsp)
  jg     L32
  mov    0x38(%rsp),%ecx
L83:
  add    $0x1,%ebp
  add    $0xa,%r14
  cmp    %ebp,%ecx
  jg     L356
L375:
  mov    0x34(%rsp),%eax
  mov    0x30(%rsp),%ebx
  mov    %eax,0x20(%rsp)
  cmp    %ecx,%ebx
  je     L365
  cmp    0x20(%rsp),%ecx
  je     L58
L193:
  lea    D47(%rip),%rdi
  call   <puts@plt>
L159:
  mov    0x38(%rsp),%eax
  cmp    %eax,0x34(%rsp)
  je     L277
  lea    D53(%rip),%rdi
  call   <puts@plt>
L33:
  mov    0x688(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L156
  add    $0x698,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L365:
  mov    0x3c(%rsp),%eax
  mov    %eax,0x8(%rsp)
  mov    %eax,0x2c(%rsp)
  cmp    0x20(%rsp),%eax
  je     L352
  cmp    0x20(%rsp),%ecx
  jne    L193
L299:
  mov    0x8(%rsp),%eax
  mov    %eax,0x2c(%rsp)
  test   %ebx,%ebx
  jle    L236
  lea    0x40(%rsp),%r13
  lea    0x1d0(%rsp),%r15
L261:
  mov    0x8(%rsp),%eax
  xor    %ebp,%ebp
  mov    %r15,0x18(%rsp)
  lea    0x4f0(%rsp),%rdi
  mov    %ecx,%r15d
  lea    -0x1(%rax),%edx
  lea    -0x1(%rcx),%eax
  imul   $0x28,%rax,%rax
  lea    0x1d4(%rsp,%rdx,4),%r14
  lea    0x4(,%rdx,4),%r12
  lea    0x1f8(%rsp,%rax,1),%rax
  mov    %rax,0x10(%rsp)
  mov    %r13,%rax
  mov    %ebp,%r13d
  mov    %r14,%rbp
  mov    %rax,%r14
  nop
L273:
  mov    0x8(%rsp),%eax
  test   %eax,%eax
  jle    L302
  xor    %esi,%esi
  mov    %r12,%rdx
  call   <memset@plt>
  mov    0x10(%rsp),%rsi
  mov    0x18(%rsp),%r10
  mov    %rax,%rdi
  mov    %rax,%r11
  nopw   0x0(%rax,%rax,1)
L178:
  test   %r15d,%r15d
  jle    L92
  mov    %r10,%rax
  mov    %r14,%rdx
  pxor   %xmm1,%xmm1
  nopw   0x0(%rax,%rax,1)
L56:
  movss  (%rdx),%xmm0
  mulss  (%rax),%xmm0
  add    $0x28,%rax
  add    $0x4,%rdx
  addss  %xmm0,%xmm1
  cmp    %rsi,%rax
  jne    L56
  movss  %xmm1,(%r11)
L92:
  add    $0x4,%r10
  add    $0x4,%r11
  add    $0x4,%rsi
  cmp    %rbp,%r10
  jne    L178
L302:
  add    $0x1,%r13d
  add    $0x28,%rdi
  add    $0x28,%r14
  cmp    %r13d,%ebx
  jg     L273
  mov    %r15d,%ecx
L236:
  cmp    %ecx,%ebx
  jne    L193
L369:
  mov    0x20(%rsp),%eax
  cmp    %eax,0x3c(%rsp)
  jne    L193
  lea    D69(%rip),%rdi
  call   <puts@plt>
  mov    0x28(%rsp),%eax
  test   %eax,%eax
  jle    L159
  sub    $0x1,%eax
  mov    0x24(%rsp),%r15d
  mov    %ebx,0x8(%rsp)
  mov    $0xfffffffffffffffc,%r13
  imul   $0xa,%rax,%rax
  lea    D94(%rip),%r12
  lea    -0x1(%r15),%ecx
  lea    0x0(,%rcx,4),%rdx
  add    %rcx,%rax
  lea    0x364(%rsp,%rdx,1),%rbp
  sub    %rdx,%r13
  lea    0x38c(%rsp,%rax,4),%r14
L405:
  lea    0x0(%r13,%rbp,1),%rbx
  test   %r15d,%r15d
  jle    L340
  nopl   0x0(%rax,%rax,1)
L231:
  pxor   %xmm0,%xmm0
  mov    %r12,%rdi
  mov    $0x1,%eax
  add    $0x4,%rbx
  cvtss2sd -0x4(%rbx),%xmm0
  call   <printf@plt>
  cmp    %rbp,%rbx
  jne    L231
L340:
  mov    $0xa,%edi
  add    $0x28,%rbp
  call   <putchar@plt>
  cmp    %r14,%rbp
  jne    L405
  mov    0x8(%rsp),%ebx
  jmp    L159
L277:
  lea    D157(%rip),%rdi
  call   <puts@plt>
  test   %ebx,%ebx
  jle    L33
  lea    -0x1(%rbx),%eax
  mov    0x2c(%rsp),%r15d
  mov    $0xfffffffffffffffc,%r13
  lea    D94(%rip),%r12
  imul   $0xa,%rax,%rax
  lea    -0x1(%r15),%ecx
  lea    0x0(,%rcx,4),%rdx
  add    %rcx,%rax
  lea    0x4f4(%rsp,%rdx,1),%rbp
  sub    %rdx,%r13
  lea    0x51c(%rsp,%rax,4),%r14
  nopl   0x0(%rax,%rax,1)
L120:
  lea    0x0(%r13,%rbp,1),%rbx
  test   %r15d,%r15d
  jle    L224
  nopw   0x0(%rax,%rax,1)
L105:
  pxor   %xmm0,%xmm0
  mov    %r12,%rdi
  mov    $0x1,%eax
  add    $0x4,%rbx
  cvtss2sd -0x4(%rbx),%xmm0
  call   <printf@plt>
  cmp    %rbx,%rbp
  jne    L105
L224:
  mov    $0xa,%edi
  add    $0x28,%rbp
  call   <putchar@plt>
  cmp    %rbp,%r14
  jne    L120
  jmp    L33
L58:
  mov    0x3c(%rsp),%eax
  mov    %eax,0x8(%rsp)
  jmp    L299
L352:
  test   %ecx,%ecx
  jle    L191
  mov    %ecx,%eax
  lea    0x40(%rsp),%r13
  lea    0x1d0(%rsp),%r15
  imul   $0x2c,%rax,%r8
  lea    0x0(,%rax,4),%rdx
  neg    %rax
  lea    0x360(%rsp),%rsi
  lea    0x0(,%rax,4),%rdi
L30:
  lea    (%rdi,%rdx,1),%rax
  nopw   0x0(%rax,%rax,1)
L248:
  movss  (%rax,%r13,1),%xmm0
  addss  (%r15,%rax,1),%xmm0
  movss  %xmm0,(%rsi,%rax,1)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L248
  lea    0x28(%rax),%rdx
  cmp    %r8,%rdx
  jne    L30
  mov    %ecx,0x24(%rsp)
  mov    %ecx,0x28(%rsp)
  cmp    0x20(%rsp),%ecx
  je     L261
  jmp    L35
L191:
  cmp    0x8(%rsp),%ecx
  je     L296
L35:
  mov    0x20(%rsp),%eax
  mov    %ecx,0x28(%rsp)
  mov    %eax,0x24(%rsp)
  jmp    L369
L156:
  call   <__stack_chk_fail@plt>
L296:
  mov    %ecx,0x24(%rsp)
  mov    %ecx,0x28(%rsp)
  jmp    L299
```

tool_calls: name: parse_data
arguments: data_tag: D83
data_type: string
name: parse_data
arguments: data_tag: D173
data_type: string
name: parse_data
arguments: data_tag: D139
data_type: string
name: parse_data
arguments: data_tag: D62
data_type: string
name: parse_data
arguments: data_tag: D3
data_type: string
name: parse_data
arguments: data_tag: D77
data_type: string
name: parse_data
arguments: data_tag: D50
data_type: string
name: parse_data
arguments: data_tag: D47
data_type: string
name: parse_data
arguments: data_tag: D53
data_type: string
name: parse_data
arguments: data_tag: D69
data_type: string
name: parse_data
arguments: data_tag: D94
data_type: string
name: parse_data
arguments: data_tag: D157
data_type: string

tool: D83: filas de a  : 

tool: D173: Elementos (%d, %d): 

tool: D139: %f

tool: D62: %d

tool: D3: Columnas de a: 

tool: D77: Filas de a : 

tool: D50: Eelementos (%d, %d)

tool: D47: Matrices no compatibles para la suma

tool: D53: Matrices no compatible par el producto

tool: D69: Suma

tool: D94: %8.3f

tool: D157: Producto

assistant: ```c
int main(void) {
  float a[10][10], b[10][10];
  float s[10][10], p[10][10];
  int filas_a, columnas_a, filas_b, columnas_b;
  int filas_s, columnas_s, filas_p, columnas_p;
  int i, j, k;
  printf("filas de a  : ");
  scanf("%d", &filas_a);
  printf("Columnas de a: ");
  scanf("%d", &columnas_a);
  for (i = 0; i < filas_a; i++) {
    for (j = 0; j < columnas_a; j++) {
      printf("Elementos (%d, %d): ", i, j);
      scanf("%f", &a[i][j]);
    }
  }
  printf("Filas de a : ");
  scanf("%d", &filas_b);
  printf("Columnas de a: ");
  scanf("%d", &columnas_b);
  for (i = 0; i < filas_b; i++) {
    for (j = 0; j < columnas_b; j++) {
      printf("Eelementos (%d, %d)", i, j);
      scanf("%f", &b[i][j]);
    }
  }
  if (filas_a == filas_b && columnas_a == columnas_b) {
    filas_s = filas_a;
    columnas_s = columnas_a;
    for (i = 0; i < filas_s; i++) {
      for (j = 0; j < filas_a; j++) {
        s[i][j] = a[i][j] + b[i][j];
      }
    }
  }
  if (columnas_a == filas_b) {
    filas_p = filas_a;
    columnas_p = columnas_b;
    for (i = 0; i < filas_p; i++) {
      for (j = 0; j < columnas_p; j++) {
        p[i][j] = 0.0;
        for (k = 0; k < columnas_a; k++) {
          p[i][j] += a[i][k] * b[k][j];
        }
      }
    }
  }
  if (filas_a == filas_b && columnas_a == columnas_b) {
    printf("Suma\n");
    for (i = 0; i < filas_s; i++) {
      for (j = 0; j < columnas_s; j++) {
        printf("%8.3f", s[i][j]);
      }
      printf("\n");
    }
  } else {
    printf("Matrices no compatibles para la suma\n");
  }
  if (columnas_a == filas_b) {
    printf("Producto\n");
    for (i = 0; i < filas_p; i++) {
      for (j = 0; j < columnas_p; j++) {
        printf("%8.3f", p[i][j]);
      }
      printf("\n");
    }
  } else {
    printf("Matrices no compatible par el producto\n");
  }
  return 0;
}
```