user: Please show me the C implementation that matches the assembly code listed below:

```asm
<fromToRotation>:
  endbr64
  movss  0x4(%rdi),%xmm8
  movss  (%rsi),%xmm9
  pxor   %xmm2,%xmm2
  mov    %rdx,%rax
  movss  0x4(%rsi),%xmm0
  movss  (%rdi),%xmm10
  movaps %xmm9,%xmm3
  movaps %xmm8,%xmm1
  movss  0x8(%rsi),%xmm6
  movss  0x8(%rdi),%xmm4
  mulss  %xmm0,%xmm1
  mulss  %xmm10,%xmm3
  addss  %xmm1,%xmm3
  movaps %xmm6,%xmm1
  mulss  %xmm4,%xmm1
  addss  %xmm1,%xmm3
  movaps %xmm3,%xmm5
  movaps %xmm3,%xmm1
  xorps  D65(%rip),%xmm1
  cmpltss %xmm2,%xmm5
  andps  %xmm5,%xmm1
  andnps %xmm3,%xmm5
  orps   %xmm5,%xmm1
  cvtss2sd %xmm1,%xmm1
  comisd D45(%rip),%xmm1
  jbe    L57
  comiss %xmm2,%xmm10
  movaps %xmm10,%xmm3
  movss  D65(%rip),%xmm11
  jbe    L10
L26:
  comiss %xmm2,%xmm8
  movaps %xmm8,%xmm1
  ja     L66
  xorps  %xmm11,%xmm1
L66:
  comiss %xmm2,%xmm4
  movaps %xmm4,%xmm5
  ja     L14
  xorps  %xmm11,%xmm5
L14:
  comiss %xmm3,%xmm1
  jbe    L64
  comiss %xmm3,%xmm5
  ja     L38
L65:
  movss  D88(%rip),%xmm7
  movaps %xmm2,%xmm12
  movaps %xmm7,%xmm5
L34:
  movaps %xmm12,%xmm3
  movaps %xmm2,%xmm1
  subss  %xmm0,%xmm2
  subss  %xmm10,%xmm3
  subss  %xmm8,%xmm1
  movaps %xmm5,%xmm8
  subss  %xmm6,%xmm5
  subss  %xmm4,%xmm8
  subss  %xmm9,%xmm12
  movaps %xmm2,%xmm9
  movaps %xmm2,%xmm14
  movaps %xmm3,%xmm6
  movaps %xmm1,%xmm0
  movaps %xmm1,%xmm13
  mulss  %xmm1,%xmm0
  mulss  %xmm3,%xmm6
  movaps %xmm12,%xmm10
  mulss  %xmm2,%xmm9
  addss  %xmm0,%xmm6
  movaps %xmm8,%xmm0
  mulss  %xmm8,%xmm0
  addss  %xmm0,%xmm6
  movss  D4(%rip),%xmm0
  movaps %xmm0,%xmm4
  divss  %xmm6,%xmm4
  movaps %xmm12,%xmm6
  mulss  %xmm12,%xmm6
  addss  %xmm9,%xmm6
  movaps %xmm5,%xmm9
  mulss  %xmm5,%xmm9
  addss  %xmm9,%xmm6
  movaps %xmm1,%xmm9
  mulss  %xmm2,%xmm9
  divss  %xmm6,%xmm0
  movaps %xmm3,%xmm6
  mulss  %xmm12,%xmm6
  addss  %xmm9,%xmm6
  movaps %xmm8,%xmm9
  mulss  %xmm5,%xmm9
  addss  %xmm9,%xmm6
  movaps %xmm4,%xmm9
  xorps  %xmm11,%xmm4
  movaps %xmm10,%xmm11
  mulss  %xmm0,%xmm9
  mulss  %xmm0,%xmm12
  mulss  %xmm9,%xmm6
  movaps %xmm3,%xmm9
  mulss  %xmm4,%xmm9
  mulss  %xmm12,%xmm14
  mulss  %xmm6,%xmm11
  mulss  %xmm9,%xmm13
  subss  %xmm14,%xmm13
  movaps %xmm1,%xmm14
  mulss  %xmm11,%xmm14
  addss  %xmm14,%xmm13
  movaps %xmm5,%xmm14
  mulss  %xmm12,%xmm14
  mulss  %xmm10,%xmm12
  movss  %xmm13,0x4(%rax)
  movaps %xmm8,%xmm13
  mulss  %xmm9,%xmm13
  mulss  %xmm3,%xmm9
  subss  %xmm14,%xmm13
  movaps %xmm8,%xmm14
  mulss  %xmm11,%xmm14
  subss  %xmm12,%xmm9
  movaps %xmm2,%xmm12
  mulss  %xmm3,%xmm11
  mulss  %xmm0,%xmm12
  mulss  %xmm5,%xmm0
  addss  %xmm14,%xmm13
  movaps %xmm10,%xmm14
  addss  %xmm11,%xmm9
  movaps %xmm2,%xmm11
  mulss  %xmm12,%xmm14
  movss  %xmm13,0x8(%rax)
  mulss  %xmm6,%xmm11
  movaps %xmm3,%xmm13
  addss  %xmm7,%xmm9
  mulss  %xmm5,%xmm6
  mulss  %xmm0,%xmm10
  movss  %xmm9,(%rax)
  movaps %xmm1,%xmm9
  mulss  %xmm4,%xmm9
  mulss  %xmm8,%xmm4
  mulss  %xmm9,%xmm13
  subss  %xmm14,%xmm13
  movaps %xmm3,%xmm14
  mulss  %xmm11,%xmm14
  addss  %xmm14,%xmm13
  movaps %xmm5,%xmm14
  mulss  %xmm12,%xmm14
  mulss  %xmm2,%xmm12
  movss  %xmm13,0xc(%rax)
  mulss  %xmm0,%xmm5
  movaps %xmm8,%xmm13
  mulss  %xmm9,%xmm13
  mulss  %xmm1,%xmm9
  mulss  %xmm0,%xmm2
  movaps %xmm8,%xmm0
  mulss  %xmm6,%xmm0
  subss  %xmm14,%xmm13
  movaps %xmm8,%xmm14
  mulss  %xmm11,%xmm14
  subss  %xmm12,%xmm9
  mulss  %xmm1,%xmm11
  addss  %xmm14,%xmm13
  addss  %xmm11,%xmm9
  movss  %xmm13,0x14(%rax)
  addss  %xmm7,%xmm9
  movss  %xmm9,0x10(%rax)
  movaps %xmm3,%xmm9
  mulss  %xmm4,%xmm9
  mulss  %xmm6,%xmm3
  subss  %xmm10,%xmm9
  addss  %xmm3,%xmm9
  movaps %xmm1,%xmm3
  mulss  %xmm4,%xmm3
  mulss  %xmm8,%xmm4
  mulss  %xmm6,%xmm1
  movss  %xmm9,0x18(%rax)
  subss  %xmm2,%xmm3
  subss  %xmm5,%xmm4
  addss  %xmm1,%xmm3
  addss  %xmm0,%xmm4
  movss  %xmm3,0x1c(%rax)
  addss  %xmm7,%xmm4
  movss  %xmm4,0x20(%rax)
  ret
  nopl   0x0(%rax)
L10:
  movss  D65(%rip),%xmm11
  xorps  %xmm11,%xmm3
  jmp    L26
  nopw   0x0(%rax,%rax,1)
L57:
  movaps %xmm8,%xmm5
  movaps %xmm4,%xmm1
  pxor   %xmm2,%xmm2
  mulss  %xmm0,%xmm1
  cvtss2sd %xmm3,%xmm2
  mulss  %xmm6,%xmm5
  mulss  %xmm9,%xmm4
  mulss  %xmm10,%xmm6
  mulss  %xmm9,%xmm8
  mulss  %xmm10,%xmm0
  subss  %xmm1,%xmm5
  movsd  D7(%rip),%xmm1
  addsd  %xmm1,%xmm2
  subss  %xmm6,%xmm4
  subss  %xmm8,%xmm0
  divsd  %xmm2,%xmm1
  movaps %xmm5,%xmm2
  movaps %xmm4,%xmm9
  movaps %xmm4,%xmm8
  movaps %xmm4,%xmm10
  movaps %xmm0,%xmm6
  movaps %xmm0,%xmm7
  cvtsd2ss %xmm1,%xmm1
  mulss  %xmm1,%xmm2
  mulss  %xmm1,%xmm6
  mulss  %xmm4,%xmm1
  mulss  %xmm2,%xmm9
  mulss  %xmm2,%xmm7
  mulss  %xmm5,%xmm2
  mulss  %xmm6,%xmm8
  mulss  %xmm4,%xmm1
  movaps %xmm9,%xmm11
  addss  %xmm0,%xmm9
  subss  %xmm0,%xmm11
  addss  %xmm7,%xmm10
  mulss  %xmm6,%xmm0
  addss  %xmm3,%xmm2
  subss  %xmm4,%xmm7
  unpcklps %xmm9,%xmm10
  addss  %xmm3,%xmm1
  unpcklps %xmm11,%xmm2
  movlhps %xmm10,%xmm2
  addss  %xmm3,%xmm0
  movups %xmm2,(%rdx)
  movaps %xmm8,%xmm2
  subss  %xmm5,%xmm2
  addss  %xmm8,%xmm5
  movss  %xmm0,0x20(%rdx)
  unpcklps %xmm5,%xmm7
  unpcklps %xmm2,%xmm1
  movlhps %xmm7,%xmm1
  movups %xmm1,0x10(%rdx)
  ret
  nopl   0x0(%rax)
L64:
  comiss %xmm1,%xmm5
  jbe    L65
  movss  D88(%rip),%xmm7
  movaps %xmm2,%xmm5
  movaps %xmm5,%xmm12
  movaps %xmm7,%xmm2
  jmp    L34
L38:
  movss  D88(%rip),%xmm7
  movaps %xmm2,%xmm5
  movaps %xmm7,%xmm12
  jmp    L34
```

tool_calls: name: retrieve_data
arguments: data_tag: D65
type_infered: byte[16]
name: retrieve_data
arguments: data_tag: D45
type_infered: byte[16]
name: retrieve_data
arguments: data_tag: D88
type_infered: f32
name: retrieve_data
arguments: data_tag: D4
type_infered: f32
name: retrieve_data
arguments: data_tag: D7
type_infered: f32[2]

tool: {"D65": [0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]}

tool: {"D45": [0xe9,0x0b,0x21,0xe7,0xfd,0xff,0xef,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: D88: 1

tool: D4: 2

tool: {"D7": [0.0,1.875]}

assistant: ```c
void fromToRotation(float from[3], float to[3], float mtx[3][3]) {
  float v[3];
  float e, h, f;
  {
    v[0] = from[1] * to[2] - from[2] * to[1];
    v[1] = from[2] * to[0] - from[0] * to[2];
    v[2] = from[0] * to[1] - from[1] * to[0];
  };
  e = (from[0] * to[0] + from[1] * to[1] + from[2] * to[2]);
  f = (e < 0) ? -e : e;
  if (f > 1.0 - 0.000001) {
    float u[3], v[3];
    float x[3];
    float c1, c2, c3;
    int i, j;
    x[0] = (from[0] > 0.0) ? from[0] : -from[0];
    x[1] = (from[1] > 0.0) ? from[1] : -from[1];
    x[2] = (from[2] > 0.0) ? from[2] : -from[2];
    if (x[0] < x[1]) {
      if (x[0] < x[2]) {
        x[0] = 1.0;
        x[1] = x[2] = 0.0;
      } else {
        x[2] = 1.0;
        x[0] = x[1] = 0.0;
      }
    } else {
      if (x[1] < x[2]) {
        x[1] = 1.0;
        x[0] = x[2] = 0.0;
      } else {
        x[2] = 1.0;
        x[0] = x[1] = 0.0;
      }
    }
    u[0] = x[0] - from[0];
    u[1] = x[1] - from[1];
    u[2] = x[2] - from[2];
    v[0] = x[0] - to[0];
    v[1] = x[1] - to[1];
    v[2] = x[2] - to[2];
    c1 = 2.0 / (u[0] * u[0] + u[1] * u[1] + u[2] * u[2]);
    c2 = 2.0 / (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
    c3 = c1 * c2 * (u[0] * v[0] + u[1] * v[1] + u[2] * v[2]);
    for (i = 0; i < 3; i++) {
      for (j = 0; j < 3; j++) {
        mtx[i][j] = -c1 * u[i] * u[j] - c2 * v[i] * v[j] + c3 * v[i] * u[j];
      }
      mtx[i][i] += 1.0;
    }
  } else {
    float hvx, hvz, hvxy, hvxz, hvyz;
    h = 1.0 / (1.0 + e);
    hvx = h * v[0];
    hvz = h * v[2];
    hvxy = hvx * v[1];
    hvxz = hvx * v[2];
    hvyz = hvz * v[1];
    mtx[0][0] = e + hvx * v[0];
    mtx[0][1] = hvxy - v[2];
    mtx[0][2] = hvxz + v[1];
    mtx[1][0] = hvxy + v[2];
    mtx[1][1] = e + h * v[1] * v[1];
    mtx[1][2] = hvyz - v[0];
    mtx[2][0] = hvxz - v[1];
    mtx[2][1] = hvyz + v[0];
    mtx[2][2] = e + hvz * v[2];
  }
}
```