user: Demonstrate the C code that generates the assembly output below:

```asm
<pseudoinverse>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0xb8,%rsp
  mov    %rdi,%r11
  mov    %rsi,0x8(%rsp)
  mov    %edx,%ebp
  mov    %fs:0x28,%rax
  mov    %rax,0xa8(%rsp)
  xor    %eax,%eax
  lea    0x10(%rsp),%r12
  mov    %rdi,%rdx
  lea    -0x1(%rbp),%eax
  lea    (%rax,%rax,2),%rax
  lea    0x18(%rdi,%rax,8),%r13
  mov    %r13,%rsi
  mov    %r12,%r9
  mov    $0x3,%r10d
  mov    $0x3,%r8d
  movsd  D9(%rip),%xmm2
  pxor   %xmm3,%xmm3
  jmp    L29
L14:
  movsd  %xmm0,(%r9,%rax,8)
  add    $0x1,%rax
  cmp    $0x6,%rax
  je     L236
L33:
  movapd %xmm2,%xmm0
  cmp    %eax,%r10d
  je     L14
  movapd %xmm3,%xmm0
  jmp    L14
L236:
  lea    -0x3(%r8),%rcx
  mov    %r9,%rdi
L114:
  test   %ebp,%ebp
  jle    L92
  mov    %rdi,%rbx
  movsd  (%rdi),%xmm1
  mov    %r11,%rax
L199:
  movsd  (%rax),%xmm0
  mulsd  (%rax,%rcx,8),%xmm0
  addsd  %xmm0,%xmm1
  add    $0x18,%rax
  cmp    %rsi,%rax
  jne    L199
  movsd  %xmm1,(%rbx)
L92:
  add    $0x8,%rdi
  add    $0x1,%rcx
  cmp    %r8,%rcx
  jne    L114
  add    $0x30,%r9
  add    $0x1,%r10d
  add    $0x8,%r11
  add    $0x8,%rsi
  sub    $0x1,%r8
  je     L196
L29:
  mov    $0x0,%eax
  jmp    L33
L196:
  lea    0x30(%r12),%r15
  mov    %r15,%r11
  mov    %r8,%r9
  mov    %r12,%r14
  mov    %r8,%rbx
  jmp    L223
L56:
  add    $0x1,%edi
  sub    $0x30,%rsi
  add    $0x30,%rcx
  cmp    $0x3,%edi
  je     L131
L159:
  cmp    %ebx,%edi
  je     L56
  movsd  -0x30(%rcx,%rbx,8),%xmm2
  lea    -0x30(%rcx),%rax
L233:
  lea    (%rax,%rsi,1),%r10
  movapd %xmm2,%xmm1
  mulsd  (%r10,%r9,1),%xmm1
  movsd  (%rax),%xmm0
  subsd  %xmm1,%xmm0
  movsd  %xmm0,(%rax)
  add    $0x8,%rax
  cmp    %rcx,%rax
  jne    L233
  jmp    L56
L131:
  add    $0x1,%rbx
  add    $0x38,%r14
  add    $0x30,%r9
  add    $0x30,%r11
  cmp    $0x3,%rbx
  je     L99
L223:
  movsd  (%r14),%xmm1
  lea    -0x30(%r11),%rax
L5:
  movsd  (%rax),%xmm0
  divsd  %xmm1,%xmm0
  movsd  %xmm0,(%rax)
  add    $0x8,%rax
  cmp    %r11,%rax
  jne    L5
  mov    %r15,%rcx
  mov    %r8,%rsi
  mov    $0x0,%edi
  jmp    L159
L99:
  test   %ebp,%ebp
  jle    L237
  mov    0x8(%rsp),%r9
  lea    0x90(%r12),%r10
  jmp    L82
L154:
  add    $0x18,%rdx
  add    $0x18,%r9
  cmp    %r13,%rdx
  je     L237
L82:
  mov    %r12,%rsi
  mov    %r9,%rdi
L102:
  mov    %rdi,%rcx
  movq   $0x0,(%rdi)
  mov    %r8,%rax
L210:
  movsd  0x18(%rsi,%rax,1),%xmm0
  mulsd  (%rdx,%rax,1),%xmm0
  addsd  (%rcx),%xmm0
  movsd  %xmm0,(%rcx)
  add    $0x8,%rax
  cmp    $0x18,%rax
  jne    L210
  add    $0x8,%rdi
  add    $0x30,%rsi
  cmp    %r10,%rsi
  jne    L102
  jmp    L154
L237:
  mov    0xa8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L105
  add    $0xb8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L105:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: label: D9
type_infered: byte[8]

tool: {"D9": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

assistant: ```c
void pseudoinverse(double (*in)[3], double (*out)[3], int size) {
  double work[3][6], num;
  int i, j, k;
  for (i = 0; i < 3; i++) {
    for (j = 0; j < 6; j++)
      work[i][j] = j == i + 3;
    for (j = 0; j < 3; j++)
      for (k = 0; k < size; k++)
        work[i][j] += in[k][i] * in[k][j];
  }
  for (i = 0; i < 3; i++) {
    num = work[i][i];
    for (j = 0; j < 6; j++)
      work[i][j] /= num;
    for (k = 0; k < 3; k++) {
      if (k == i)
        continue;
      num = work[k][i];
      for (j = 0; j < 6; j++)
        work[k][j] -= work[i][j] * num;
    }
  }
  for (i = 0; i < size; i++)
    for (j = 0; j < 3; j++)
      for (out[i][j] = k = 0; k < 3; k++)
        out[i][j] += work[j][k + 3] * in[i][k];
}
```