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

```asm
<rotate_model_openmp>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x58,%rsp
  mov    %rdi,%r13
  mov    %edx,%ebp
  mov    %rcx,0x20(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x48(%rsp)
  xor    %eax,%eax
  mov    %edx,%eax
  shr    $0x1f,%eax
  add    %edx,%eax
  mov    %eax,%edi
  sar    %edi
  mov    %edi,%ebx
  mov    %edi,0x1c(%rsp)
  neg    %edi
  mov    %edi,0x18(%rsp)
  mov    %edx,%eax
  sub    %ebx,%eax
  lea    -0x1(%rax),%edx
  cmp    %edx,%edi
  jge    L23
  mov    %rsi,%r10
  mov    %ebp,%ebx
  imul   %ebp,%ebx
  mov    %ebx,0x2c(%rsp)
  mov    %edx,%r14d
  mov    %edi,0x14(%rsp)
  movl   $0x0,0x28(%rsp)
  pxor   %xmm6,%xmm6
  movapd %xmm6,%xmm7
  lea    -0x1(%rbp),%eax
  mov    %eax,0x4(%rsp)
  movapd %xmm6,%xmm8
  movapd %xmm6,%xmm10
  movsd  D9(%rip),%xmm9
  jmp    L89
L99:
  add    $0x1,%ecx
  cmp    %r14d,%ecx
  je     L28
L158:
  mov    %r13,%rax
  lea    0x30(%rsp),%rdx
  pxor   %xmm2,%xmm2
  cvtsi2sd %ecx,%xmm2
L104:
  movapd %xmm5,%xmm0
  mulsd  (%rax),%xmm0
  movapd %xmm4,%xmm1
  mulsd  0x8(%rax),%xmm1
  addsd  %xmm1,%xmm0
  movapd %xmm2,%xmm1
  mulsd  0x10(%rax),%xmm1
  addsd  %xmm1,%xmm0
  addsd  %xmm6,%xmm0
  addsd  %xmm3,%xmm0
  movsd  %xmm0,(%rdx)
  add    $0x18,%rax
  add    $0x8,%rdx
  cmp    %rsi,%rax
  jne    L104
  movsd  0x30(%rsp),%xmm0
  comisd %xmm0,%xmm7
  ja     L99
  pxor   %xmm1,%xmm1
  cvtsi2sdl 0x4(%rsp),%xmm1
  comisd %xmm1,%xmm0
  jae    L99
  movsd  0x38(%rsp),%xmm11
  comisd %xmm11,%xmm8
  ja     L99
  comisd %xmm1,%xmm11
  jae    L99
  movsd  0x40(%rsp),%xmm2
  comisd %xmm2,%xmm10
  ja     L99
  comisd %xmm1,%xmm2
  jae    L99
  cvttsd2si %xmm0,%r11d
  cvttsd2si %xmm11,%r12d
  cvttsd2si %xmm2,%r8d
  pxor   %xmm1,%xmm1
  cvtsi2sd %r11d,%xmm1
  subsd  %xmm1,%xmm0
  pxor   %xmm12,%xmm12
  cvtsi2sd %r12d,%xmm12
  movapd %xmm11,%xmm1
  subsd  %xmm12,%xmm1
  pxor   %xmm11,%xmm11
  cvtsi2sd %r8d,%xmm11
  subsd  %xmm11,%xmm2
  movapd %xmm9,%xmm13
  subsd  %xmm0,%xmm13
  movapd %xmm9,%xmm12
  subsd  %xmm1,%xmm12
  movapd %xmm9,%xmm11
  subsd  %xmm2,%xmm11
  mov    0xc(%rsp),%eax
  add    %ecx,%eax
  cltq
  mov    0x20(%rsp),%rdi
  lea    (%rdi,%rax,8),%r15
  movapd %xmm13,%xmm14
  mulsd  %xmm12,%xmm14
  mov    %ebx,%edi
  imul   %r11d,%edi
  imul   %ebx,%edi
  mov    %ebx,%r9d
  imul   %r12d,%r9d
  lea    (%rdi,%r9,1),%ebp
  lea    0x1(%r8),%eax
  cltd
  idiv   %ebx
  mov    %edx,0x10(%rsp)
  mulsd  %xmm1,%xmm13
  lea    0x1(%r12),%eax
  cltd
  idiv   %ebx
  mov    %edx,%r12d
  imul   %ebx,%r12d
  add    %r12d,%edi
  mulsd  %xmm0,%xmm12
  lea    0x1(%r11),%eax
  cltd
  idiv   %ebx
  imul   %ebx,%edx
  imul   %ebx,%edx
  add    %edx,%r9d
  mulsd  %xmm1,%xmm0
  add    %r12d,%edx
  lea    0x0(%rbp,%r8,1),%eax
  cltq
  movapd %xmm14,%xmm1
  mulsd  %xmm11,%xmm1
  mulsd  (%r10,%rax,8),%xmm1
  mov    0x10(%rsp),%r11d
  add    %r11d,%ebp
  movslq %ebp,%rbp
  mulsd  %xmm2,%xmm14
  mulsd  (%r10,%rbp,8),%xmm14
  addsd  %xmm14,%xmm1
  lea    (%rdi,%r8,1),%eax
  cltq
  movapd %xmm13,%xmm14
  mulsd  %xmm11,%xmm14
  mulsd  (%r10,%rax,8),%xmm14
  addsd  %xmm14,%xmm1
  add    %r11d,%edi
  movslq %edi,%rdi
  mulsd  %xmm2,%xmm13
  mulsd  (%r10,%rdi,8),%xmm13
  addsd  %xmm13,%xmm1
  lea    (%r9,%r8,1),%eax
  cltq
  movapd %xmm12,%xmm13
  mulsd  %xmm11,%xmm13
  mulsd  (%r10,%rax,8),%xmm13
  addsd  %xmm13,%xmm1
  add    %r11d,%r9d
  movslq %r9d,%r9
  mulsd  %xmm2,%xmm12
  mulsd  (%r10,%r9,8),%xmm12
  addsd  %xmm12,%xmm1
  add    %edx,%r8d
  movslq %r8d,%r8
  mulsd  %xmm0,%xmm11
  mulsd  (%r10,%r8,8),%xmm11
  addsd  %xmm11,%xmm1
  mov    %r11d,%eax
  add    %edx,%eax
  cltq
  mulsd  %xmm2,%xmm0
  mulsd  (%r10,%rax,8),%xmm0
  addsd  %xmm1,%xmm0
  addsd  (%r15),%xmm0
  movsd  %xmm0,(%r15)
  jmp    L99
L28:
  addl   $0x1,0x8(%rsp)
  mov    0x8(%rsp),%eax
  add    %ebx,0xc(%rsp)
  cmp    %r14d,%eax
  je     L115
L128:
  mov    0x18(%rsp),%ecx
  lea    0x48(%r13),%rsi
  pxor   %xmm5,%xmm5
  cvtsi2sdl 0x14(%rsp),%xmm5
  pxor   %xmm4,%xmm4
  cvtsi2sdl 0x8(%rsp),%xmm4
  pxor   %xmm3,%xmm3
  cvtsi2sdl 0x1c(%rsp),%xmm3
  jmp    L158
L115:
  mov    %ebx,%ebp
  addl   $0x1,0x14(%rsp)
  mov    0x14(%rsp),%eax
  mov    0x2c(%rsp),%ebx
  add    %ebx,0x28(%rsp)
  cmp    %r14d,%eax
  je     L23
L89:
  mov    0x28(%rsp),%eax
  add    0x1c(%rsp),%eax
  mov    %eax,0xc(%rsp)
  mov    0x18(%rsp),%eax
  mov    %eax,0x8(%rsp)
  mov    %ebp,%ebx
  jmp    L128
L23:
  mov    0x48(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L24
  add    $0x58,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L24:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: data_label: D9
type_infered: f64

tool: D9: 1

assistant: ```c
void rotate_model_openmp(double rot[3][3], double *m, int s, double *rotmodel) {
#pragma omp parallel default(shared)
  {
    int x, y, z, i, c = s / 2, vx, vy, vz;
    double fx, fy, fz, cx, cy, cz;
    double rot_vox[3];
#pragma omp for schedule(static, 1)
    for (vx = -c; vx < s - c - 1; ++vx)
      for (vy = -c; vy < s - c - 1; ++vy)
        for (vz = -c; vz < s - c - 1; ++vz) {
          for (i = 0; i < 3; ++i) {
            rot_vox[i] = 0.;
            rot_vox[i] += rot[i][0] * vx + rot[i][1] * vy + rot[i][2] * vz;
            rot_vox[i] += c;
          }
          if (rot_vox[0] < 0 || rot_vox[0] >= s - 1)
            continue;
          if (rot_vox[1] < 0 || rot_vox[1] >= s - 1)
            continue;
          if (rot_vox[2] < 0 || rot_vox[2] >= s - 1)
            continue;
          x = (int)rot_vox[0];
          y = (int)rot_vox[1];
          z = (int)rot_vox[2];
          fx = rot_vox[0] - x;
          fy = rot_vox[1] - y;
          fz = rot_vox[2] - z;
          cx = 1. - fx;
          cy = 1. - fy;
          cz = 1. - fz;
          rotmodel[(vx + c) * s * s + (vy + c) * s + (vz + c)] += cx * cy * cz * m[x * s * s + y * s + z] + cx * cy * fz * m[x * s * s + y * s + ((z + 1) % s)] + cx * fy * cz * m[x * s * s + ((y + 1) % s) * s + z] + cx * fy * fz * m[x * s * s + ((y + 1) % s) * s + ((z + 1) % s)] + fx * cy * cz * m[((x + 1) % s) * s * s + y * s + z] + fx * cy * fz * m[((x + 1) % s) * s * s + y * s + ((z + 1) % s)] + fx * fy * cz * m[((x + 1) % s) * s * s + ((y + 1) % s) * s + z] + fx * fy * fz * m[((x + 1) % s) * s * s + ((y + 1) % s) * s + ((z + 1) % s)];
        }
  }
}
```