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

```asm
<matrix_ij_GT>:
  endbr64
  movsd  D9(%rip),%xmm6
  push   %rbp
  movslq %edi,%rdx
  add    %edi,%edi
  push   %rbx
  shl    $0x3,%rdx
  movapd %xmm4,%xmm8
  movslq %edi,%rdi
  mulsd  %xmm3,%xmm6
  lea    (%rsi,%rdx,1),%r10
  movapd %xmm8,%xmm14
  mov    %rsi,%rax
  lea    (%r10,%rdx,1),%rbx
  mulsd  %xmm0,%xmm14
  lea    0x8(%rax,%rdx,1),%r11
  lea    0x0(,%rdi,8),%r8
  addsd  %xmm4,%xmm4
  movapd %xmm8,%xmm10
  mulsd  %xmm2,%xmm10
  movapd %xmm0,%xmm11
  movapd %xmm1,%xmm9
  lea    0x18(,%rdi,8),%rbp
  mulsd  %xmm1,%xmm11
  movapd %xmm1,%xmm7
  movapd %xmm6,%xmm5
  movapd %xmm6,%xmm15
  subsd  %xmm4,%xmm3
  mulsd  %xmm0,%xmm5
  movapd %xmm0,%xmm4
  lea    (%rax,%rbp,1),%rdi
  mulsd  %xmm2,%xmm6
  mulsd  %xmm1,%xmm15
  mulsd  %xmm0,%xmm4
  mulsd  %xmm11,%xmm9
  mulsd  %xmm2,%xmm11
  movq   %xmm5,%rcx
  movapd %xmm8,%xmm5
  mulsd  %xmm1,%xmm5
  movq   %xmm6,%r9
  movq   %rcx,%xmm6
  addsd  (%rsi),%xmm6
  mulsd  %xmm1,%xmm7
  movapd %xmm4,%xmm13
  movapd %xmm4,%xmm12
  mulsd  %xmm0,%xmm4
  movsd  %xmm6,(%rsi)
  movsd  (%r10),%xmm6
  mulsd  %xmm1,%xmm13
  mulsd  %xmm2,%xmm12
  addsd  %xmm15,%xmm6
  mulsd  %xmm3,%xmm9
  movapd %xmm7,%xmm8
  mulsd  %xmm3,%xmm11
  mulsd  %xmm3,%xmm4
  movsd  %xmm6,(%r10)
  mulsd  %xmm3,%xmm13
  movq   %r9,%xmm6
  addsd  (%rbx),%xmm6
  mulsd  %xmm3,%xmm12
  mulsd  %xmm2,%xmm0
  movsd  %xmm6,(%rbx)
  mulsd  %xmm2,%xmm8
  movq   %rcx,%xmm6
  addsd  0x20(%rsi),%xmm6
  lea    0x20(%rsi,%rdx,1),%rcx
  movsd  %xmm6,0x20(%rsi)
  addsd  (%rcx),%xmm15
  lea    0x20(%rsi,%r8,1),%rsi
  movq   %r9,%xmm6
  lea    0x10(%rax,%r8,1),%r9
  lea    0x18(%rax,%rdx,1),%r8
  mulsd  %xmm2,%xmm0
  lea    0x10(%rax,%rdx,1),%rdx
  mulsd  %xmm3,%xmm8
  movsd  %xmm15,(%rcx)
  addsd  (%rsi),%xmm6
  movsd  %xmm6,(%rsi)
  movapd %xmm14,%xmm6
  movupd (%rax),%xmm15
  addsd  %xmm14,%xmm6
  mulsd  %xmm3,%xmm0
  unpcklpd %xmm5,%xmm6
  addpd  %xmm15,%xmm6
  movups %xmm6,(%rax)
  movsd  (%r11),%xmm6
  addsd  %xmm14,%xmm6
  movsd  %xmm6,(%r11)
  movsd  0x10(%rax),%xmm6
  addsd  %xmm10,%xmm6
  movsd  %xmm6,0x10(%rax)
  addsd  (%r9),%xmm14
  movsd  %xmm14,(%r9)
  addsd  (%r8),%xmm10
  movsd  %xmm10,(%r8)
  movsd  (%rdi),%xmm6
  addsd  %xmm5,%xmm6
  addsd  %xmm5,%xmm5
  movsd  %xmm6,(%rdi)
  addsd  (%rcx),%xmm5
  movsd  %xmm5,(%rcx)
  addsd  (%rax),%xmm4
  movsd  %xmm4,(%rax)
  movsd  (%r10),%xmm4
  addsd  %xmm13,%xmm4
  movsd  %xmm4,(%r10)
  movsd  (%rbx),%xmm4
  lea    -0x10(%rax,%rbp,1),%r10
  addsd  %xmm12,%xmm4
  movsd  %xmm4,(%rbx)
  addsd  0x8(%rax),%xmm13
  movsd  %xmm13,0x8(%rax)
  movsd  (%r11),%xmm4
  addsd  %xmm9,%xmm4
  movsd  %xmm4,(%r11)
  movsd  (%r10),%xmm4
  addsd  %xmm11,%xmm4
  movsd  %xmm4,(%r10)
  addsd  0x10(%rax),%xmm12
  movsd  %xmm12,0x10(%rax)
  movsd  (%rdx),%xmm4
  addsd  %xmm11,%xmm4
  movsd  %xmm4,(%rdx)
  addsd  (%r9),%xmm0
  movsd  %xmm0,(%r9)
  addsd  0x18(%rax),%xmm11
  movsd  %xmm11,0x18(%rax)
  movsd  (%r8),%xmm0
  addsd  %xmm8,%xmm0
  movsd  %xmm0,(%r8)
  movapd %xmm1,%xmm0
  mulsd  %xmm2,%xmm0
  mulsd  %xmm7,%xmm1
  mulsd  %xmm2,%xmm0
  mulsd  %xmm3,%xmm1
  mulsd  %xmm3,%xmm0
  addsd  (%rdi),%xmm0
  movsd  %xmm0,(%rdi)
  addsd  0x20(%rax),%xmm9
  movsd  %xmm9,0x20(%rax)
  addsd  (%rcx),%xmm1
  movsd  %xmm1,(%rcx)
  addsd  (%rsi),%xmm8
  movsd  %xmm8,(%rsi)
  pop    %rbx
  pop    %rbp
  ret
```

tool_calls: name: unpack_data
arguments: tag: D9
type_guessed: byte[8]

tool: {"D9": [0x55,0x55,0x55,0x55,0x55,0x55,0xd5,0xbf]}

assistant: ```c
void matrix_ij_GT(int n, double *mat, double ex, double ey, double ez, double xg, double yg) {
  double g1, g2, g3;
  double g1x, g1y, g1z;
  double g2x, g2y, g2z;
  double g3xxx, g3xxy, g3xxz, g3xyy, g3xyz, g3yyy, g3yyz, g3yzz, g3xzz, g3zzz;
  double exx, eyy, ezz, exy, eyz, exz;
  double exxx, exxy, exxz, exyy, exyz, exzz, eyyy, eyyz, eyzz, ezzz;
  g1 = -1.0 / 3.0 * xg;
  g2 = yg;
  g3 = xg - 2.0 * yg;
  exx = ex * ex;
  eyy = ey * ey;
  ezz = ez * ez;
  exy = ex * ey;
  eyz = ey * ez;
  exz = ez * ex;
  exxx = exx * ex;
  exxy = exx * ey;
  exxz = exx * ez;
  exyy = exy * ey;
  exyz = exy * ez;
  exzz = exz * ez;
  eyyy = eyy * ey;
  eyyz = eyy * ez;
  eyzz = eyz * ez;
  ezzz = ezz * ez;
  g1x = g1 * ex;
  g1y = g1 * ey;
  g1z = g1 * ez;
  g2x = g2 * ex;
  g2y = g2 * ey;
  g2z = g2 * ez;
  g3xxx = g3 * exxx;
  g3xxy = g3 * exxy;
  g3xxz = g3 * exxz;
  g3xyy = g3 * exyy;
  g3xyz = g3 * exyz;
  g3xzz = g3 * exzz;
  g3yyy = g3 * eyyy;
  g3yyz = g3 * eyyz;
  g3yzz = g3 * eyzz;
  g3zzz = g3 * ezzz;
  mat[0 * n + 0] += g1x;
  mat[1 * n + 0] += g1y;
  mat[2 * n + 0] += g1z;
  mat[0 * n + 4] += g1x;
  mat[1 * n + 4] += g1y;
  mat[2 * n + 4] += g1z;
  mat[0 * n + 0] += 2.0 * g2x;
  mat[0 * n + 1] += g2y;
  mat[1 * n + 1] += g2x;
  mat[0 * n + 2] += g2z;
  mat[2 * n + 2] += g2x;
  mat[1 * n + 3] += g2z;
  mat[2 * n + 3] += g2y;
  mat[1 * n + 4] += 2.0 * g2y;
  mat[0 * n + 0] += g3xxx;
  mat[1 * n + 0] += g3xxy;
  mat[2 * n + 0] += g3xxz;
  mat[0 * n + 1] += g3xxy;
  mat[1 * n + 1] += g3xyy;
  mat[2 * n + 1] += g3xyz;
  mat[0 * n + 2] += g3xxz;
  mat[1 * n + 2] += g3xyz;
  mat[2 * n + 2] += g3xzz;
  mat[0 * n + 3] += g3xyz;
  mat[1 * n + 3] += g3yyz;
  mat[2 * n + 3] += g3yzz;
  mat[0 * n + 4] += g3xyy;
  mat[1 * n + 4] += g3yyy;
  mat[2 * n + 4] += g3yyz;
}
```