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

```asm
<gauss1>:
  endbr64
  push   %r15
  xor    %eax,%eax
  push   %r14
  mov    %edx,%r14d
  push   %r13
  push   %r12
  push   %rbp
  lea    0x1(%rdx),%ebp
  push   %rbx
  mov    %ebp,%ecx
  mov    %rdi,%rbx
  sub    $0x68,%rsp
  mov    %rsi,0x58(%rsp)
  mov    %rdi,%rsi
  lea    D3(%rip),%rdi
  call   <print_matrix@plt>
  lea    -0x1(%r14),%eax
  mov    %eax,0x44(%rsp)
  test   %r14d,%r14d
  jle    L81
  cmp    $0x1,%r14d
  je     L101
  movslq %ebp,%r12
  mov    %ebp,%r11d
  mov    %r14d,0x4(%rsp)
  mov    %rbx,%r13
  mov    %r12,0x20(%rsp)
  lea    0x8(,%r12,8),%rax
  lea    0x0(,%r12,8),%r15
  and    $0xfffffffe,%r11d
  mov    %rax,0x48(%rsp)
  movslq %r14d,%rax
  mov    $0x1,%ecx
  mov    %rbx,%r14
  mov    %rax,0x50(%rsp)
  lea    0x8(%rbx,%rax,8),%rax
  mov    %rax,0x38(%rsp)
  mov    %ebp,%eax
  shr    %eax
  movl   $0x0,0x40(%rsp)
  movq   $0x0,0x8(%rsp)
  shl    $0x4,%rax
  mov    %rax,0x28(%rsp)
  nopw   0x0(%rax,%rax,1)
L107:
  mov    0x40(%rsp),%esi
  mov    0x20(%rsp),%rdi
  mov    %ecx,0x30(%rsp)
  mov    %esi,%eax
  add    %ebp,%esi
  lea    0x0(,%rdi,8),%rdx
  mov    %r12,%rdi
  add    %r11d,%eax
  mov    %esi,0x40(%rsp)
  cltq
  lea    (%rbx,%rax,8),%r10
  mov    0x8(%rsp),%rax
  lea    (%rbx,%rax,1),%r9
  add    $0x10,%rax
  mov    %rax,0x18(%rsp)
  jmp    L85
  nopl   (%rax)
L120:
  add    $0x1,%ecx
  add    %ebp,%esi
  add    %r12,%rdi
  add    %r15,%rdx
  cmp    %ecx,0x4(%rsp)
  jle    L125
L85:
  movsd  0x0(%r13,%rdx,1),%xmm0
  comisd (%r14),%xmm0
  jbe    L120
  lea    0x10(%rdx),%rax
  cmp    0x8(%rsp),%rax
  jle    L173
  cmp    0x18(%rsp),%rdx
  jl     L313
L173:
  mov    %rdx,0x10(%rsp)
  lea    (%rbx,%rdx,1),%r8
  mov    0x28(%rsp),%rdx
  xor    %eax,%eax
  nopl   0x0(%rax)
L162:
  movupd (%r9,%rax,1),%xmm0
  movupd (%r8,%rax,1),%xmm4
  movups %xmm4,(%r9,%rax,1)
  movups %xmm0,(%r8,%rax,1)
  add    $0x10,%rax
  cmp    %rdx,%rax
  jne    L162
  mov    0x10(%rsp),%rdx
  cmp    %ebp,%r11d
  je     L120
  lea    (%rsi,%r11,1),%eax
  movsd  (%r10),%xmm0
  cltq
  lea    (%rbx,%rax,8),%rax
  movsd  (%rax),%xmm1
  movsd  %xmm1,(%r10)
  movsd  %xmm0,(%rax)
  jmp    L120
  nopw   0x0(%rax,%rax,1)
L125:
  mov    0x30(%rsp),%ecx
  add    %r12,0x20(%rsp)
  add    $0x8,%r13
  add    %r15,0x38(%rsp)
  add    0x48(%rsp),%r14
  add    %r15,0x8(%rsp)
  add    $0x1,%ecx
  cmp    %ecx,0x4(%rsp)
  jne    L107
  mov    0x4(%rsp),%r14d
L182:
  mov    %ebp,%ecx
  mov    %r14d,%edx
  mov    %rbx,%rsi
  xor    %eax,%eax
  lea    D27(%rip),%rdi
  call   <print_matrix@plt>
  mov    0x44(%rsp),%eax
  test   %eax,%eax
  jle    L319
L168:
  lea    0x2(%r14),%eax
  movslq %ebp,%rdi
  mov    %ebp,0x40(%rsp)
  mov    %ebp,%esi
  mov    %eax,0x38(%rsp)
  and    $0xfffffffe,%esi
  xor    %r13d,%r13d
  lea    0x0(,%rdi,8),%rax
  mov    %rax,0x10(%rsp)
  mov    %ebp,%eax
  shr    %eax
  movl   $0x0,0x28(%rsp)
  lea    -0x1(%rax),%r8d
  mov    %r14d,%eax
  mov    %r14d,0x4(%rsp)
  mov    %rdi,%r14
  lea    0x8(,%rax,8),%rax
  movl   $0x0,0x20(%rsp)
  add    $0x1,%r8
  movl   $0x0,0x18(%rsp)
  shl    $0x4,%r8
  mov    %rax,0x30(%rsp)
  nopl   0x0(%rax)
L226:
  addl   $0x1,0x18(%rsp)
  mov    0x18(%rsp),%eax
  cmp    %eax,0x4(%rsp)
  jle    L284
  movslq 0x20(%rsp),%rdx
  movslq 0x28(%rsp),%rax
  movslq 0x40(%rsp),%rcx
  mov    0x18(%rsp),%r11d
  lea    0x8(,%rdx,8),%rdi
  mov    %rdx,%r10
  lea    (%rbx,%rax,8),%r15
  mov    %rdi,0x8(%rsp)
  lea    (%rbx,%rdx,8),%rdi
  lea    (%rsi,%rdx,1),%edx
  sub    %rcx,%r10
  movslq %edx,%rdx
  lea    (%rbx,%rcx,8),%rax
  lea    (%rbx,%rdx,8),%r9
L306:
  movsd  (%rax,%r13,8),%xmm0
  mov    %rax,%rdx
  sub    %rbx,%rdx
  movapd %xmm0,%xmm2
  divsd  (%r15),%xmm2
  cmp    %rdx,0x8(%rsp)
  je     L269
  movapd %xmm2,%xmm3
  xor    %edx,%edx
  unpcklpd %xmm3,%xmm3
  nopw   0x0(%rax,%rax,1)
L279:
  movupd (%rdi,%rdx,1),%xmm1
  movupd (%rax,%rdx,1),%xmm0
  mulpd  %xmm3,%xmm1
  subpd  %xmm1,%xmm0
  movups %xmm0,(%rax,%rdx,1)
  add    $0x10,%rdx
  cmp    %r8,%rdx
  jne    L279
  cmp    %ebp,%esi
  je     L61
  mulsd  (%r9),%xmm2
  lea    (%rcx,%rsi,1),%edx
  movslq %edx,%rdx
  lea    (%rbx,%rdx,8),%rdx
  movsd  (%rdx),%xmm1
  subsd  %xmm2,%xmm1
  movsd  %xmm1,(%rdx)
L61:
  add    $0x1,%r11d
  add    0x10(%rsp),%rax
  add    %ebp,%ecx
  sub    %r14,%r10
  cmp    %r11d,0x4(%rsp)
  jne    L306
L284:
  mov    0x38(%rsp),%edi
  add    %ebp,0x20(%rsp)
  add    $0x1,%r13
  add    %edi,0x28(%rsp)
  mov    0x44(%rsp),%edi
  add    %ebp,0x40(%rsp)
  cmp    %edi,0x18(%rsp)
  jl     L226
  mov    0x4(%rsp),%r14d
  mov    %edi,%r15d
L30:
  mov    %r15d,%esi
  mov    0x50(%rsp),%r12
  mov    %ebp,%r11d
  mov    0x58(%rsp),%r13
  imul   %ebp,%esi
  mov    %r14d,%r10d
  not    %r11d
  mov    %r15d,%ebp
  not    %r10d
  movslq %r11d,%r11
  movslq %r10d,%r9
  shl    $0x3,%r11
  movslq %esi,%rdx
  shl    $0x3,%r9
  lea    (%r12,%rdx,1),%rax
  lea    (%rbx,%rax,8),%r8
  movslq %r15d,%rax
  lea    0x0(%r13,%rax,8),%rcx
  add    %rdx,%rax
  lea    (%rbx,%rax,8),%rdi
  nopl   0x0(%rax,%rax,1)
L282:
  movsd  (%r8),%xmm1
  movsd  %xmm1,(%rcx)
  test   %r14d,%r14d
  jle    L10
  xor    %eax,%eax
L190:
  cmp    %eax,%ebp
  je     L145
  lea    (%rsi,%rax,1),%edx
  movslq %edx,%rdx
  movsd  (%rbx,%rdx,8),%xmm0
  mulsd  0x0(%r13,%rax,8),%xmm0
  subsd  %xmm0,%xmm1
  movsd  %xmm1,(%rcx)
L145:
  add    $0x1,%rax
  cmp    %rax,%r12
  jne    L190
L10:
  sub    $0x1,%ebp
  divsd  (%rdi),%xmm1
  add    %r9,%r8
  add    %r11,%rdi
  movsd  %xmm1,(%rcx)
  add    %r10d,%esi
  sub    $0x8,%rcx
  cmp    $0xffffffff,%ebp
  jne    L282
L26:
  mov    0x58(%rsp),%rsi
  add    $0x68,%rsp
  xor    %eax,%eax
  mov    $0x3,%ecx
  pop    %rbx
  mov    $0x1,%edx
  lea    D33(%rip),%rdi
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1050 <print_matrix@plt>
  nop
L269:
  mov    0x30(%rsp),%rdx
  lea    (%rdx,%rax,1),%r12
  mov    %rax,%rdx
  nopl   0x0(%rax)
L185:
  movsd  (%rdx,%r10,8),%xmm1
  movsd  (%rdx),%xmm0
  add    $0x8,%rdx
  mulsd  %xmm2,%xmm1
  subsd  %xmm1,%xmm0
  movsd  %xmm0,-0x8(%rdx)
  cmp    %r12,%rdx
  jne    L185
  jmp    L61
L313:
  mov    0x8(%rsp),%rax
  mov    0x38(%rsp),%r8
  add    %rbx,%rax
  nopw   0x0(%rax,%rax,1)
L193:
  movsd  (%rax),%xmm0
  movsd  (%rax,%rdi,8),%xmm1
  movsd  %xmm1,(%rax)
  movsd  %xmm0,(%rax,%rdi,8)
  add    $0x8,%rax
  cmp    %r8,%rax
  jne    L193
  jmp    L120
L81:
  mov    %r14d,%edx
  mov    %ebp,%ecx
  mov    %rbx,%rsi
  xor    %eax,%eax
  lea    D27(%rip),%rdi
  call   <print_matrix@plt>
  mov    0x44(%rsp),%edx
  test   %edx,%edx
  jg     L67
  jne    L26
  movslq %r14d,%rax
  mov    0x44(%rsp),%r15d
  mov    %rax,0x50(%rsp)
  jmp    L30
  xchg   %ax,%ax
L101:
  movq   $0x1,0x50(%rsp)
  jmp    L182
L67:
  movslq %r14d,%rax
  mov    %rax,0x50(%rsp)
  jmp    L168
L319:
  mov    0x44(%rsp),%r15d
  jmp    L30
```

tool_calls: name: disassemble_data
arguments: data_label: D3
type: string
name: disassemble_data
arguments: data_label: D27
type: string
name: disassemble_data
arguments: data_label: D33
type: string

tool: D3: INPUT

tool: 

tool: D33: result

assistant: ```c
void gauss1(void *b, void *res, int eq) {
  int i, n, k, j;
  double t, temp;
  double *B = b;
  double *a = res;
  n = eq;
  print_matrix("INPUT", B, n, n + 1);
  for (i = 0; i < n; i++)
    for (k = i + 1; k < n; k++)
      if ((((double *)B)[(i) + (i) * (n + 1)]) < (((double *)B)[(i) + (k) * (n + 1)]))
        for (j = 0; j <= n; j++) {
          temp = (((double *)B)[(j) + (i) * (n + 1)]);
          (((double *)B)[(j) + (i) * (n + 1)]) = (((double *)B)[(j) + (k) * (n + 1)]);
          (((double *)B)[(j) + (k) * (n + 1)]) = temp;
        }
  print_matrix("", B, n, n + 1);
  for (i = 0; i < n - 1; i++) {
    for (k = i + 1; k < n; k++) {
      t = (((double *)B)[(i) + (k) * (n + 1)]) / (((double *)B)[(i) + (i) * (n + 1)]);
      for (j = 0; j <= n; j++)
        (((double *)B)[(j) + (k) * (n + 1)]) = (((double *)B)[(j) + (k) * (n + 1)]) - t * (((double *)B)[(j) + (i) * (n + 1)]);
    }
  }
  for (i = n - 1; i >= 0; i--) {
    a[i] = (((double *)B)[(n) + (i) * (n + 1)]);
    for (j = 0; j < n; j++)
      if (j != i)
        a[i] = a[i] - (((double *)B)[(j) + (i) * (n + 1)]) * a[j];
    a[i] = a[i] / (((double *)B)[(i) + (i) * (n + 1)]);
  }
  print_matrix("result", a, 1, 3);
}
```