user: 请从给定的汇编指令推导出C源代码：

```asm
<rotate_model_openmp>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  mov    %rdi,%r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x68,%rsp
  mov    %rcx,0x28(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x58(%rsp)
  mov    %edx,%eax
  shr    $0x1f,%eax
  add    %edx,%eax
  mov    %eax,%edi
  mov    %edx,%eax
  sar    %edi
  mov    %edi,%ebx
  sub    %edi,%eax
  mov    %edi,0x3c(%rsp)
  neg    %ebx
  lea    -0x1(%rax),%ebp
  mov    %ebx,0x24(%rsp)
  cmp    %ebx,%ebp
  jle    L47
  mov    %edx,%eax
  pxor   %xmm6,%xmm6
  lea    -0x1(%rdx),%r14d
  mov    %ebx,0x30(%rsp)
  imul   %edx,%eax
  movl   $0x0,0x34(%rsp)
  mov    %rsi,%r10
  mov    %edx,%ebx
  cvtsi2sd %edi,%xmm6
  lea    0x48(%r13),%rsi
  pxor   %xmm2,%xmm2
  mov    %r13,%r15
  movsd  D5(%rip),%xmm7
  lea    0x40(%rsp),%r11
  mov    %r14d,%r13d
  mov    %eax,0x38(%rsp)
L101:
  mov    0x3c(%rsp),%eax
  add    0x34(%rsp),%eax
  pxor   %xmm5,%xmm5
  mov    %eax,0x18(%rsp)
  mov    0x24(%rsp),%eax
  cvtsi2sdl 0x30(%rsp),%xmm5
  mov    %eax,0xc(%rsp)
  nopl   (%rax)
L7:
  pxor   %xmm4,%xmm4
  mov    0x24(%rsp),%ecx
  cvtsi2sdl 0xc(%rsp),%xmm4
  xchg   %ax,%ax
L74:
  pxor   %xmm3,%xmm3
  mov    %r15,%rax
  mov    %r11,%rdx
  cvtsi2sd %ecx,%xmm3
L95:
  movsd  (%rax),%xmm0
  movsd  0x8(%rax),%xmm1
  add    $0x18,%rax
  add    $0x8,%rdx
  mulsd  %xmm4,%xmm1
  mulsd  %xmm5,%xmm0
  addsd  %xmm1,%xmm0
  movsd  -0x8(%rax),%xmm1
  mulsd  %xmm3,%xmm1
  addsd  %xmm1,%xmm0
  addsd  %xmm2,%xmm0
  addsd  %xmm6,%xmm0
  movsd  %xmm0,-0x8(%rdx)
  cmp    %rsi,%rax
  jne    L95
  movsd  0x40(%rsp),%xmm0
  comisd %xmm0,%xmm2
  ja     L115
  pxor   %xmm1,%xmm1
  cvtsi2sd %r13d,%xmm1
  comisd %xmm1,%xmm0
  jae    L115
  movsd  0x48(%rsp),%xmm3
  comisd %xmm3,%xmm2
  ja     L115
  comisd %xmm1,%xmm3
  jae    L115
  movsd  0x50(%rsp),%xmm8
  comisd %xmm8,%xmm2
  ja     L115
  comisd %xmm1,%xmm8
  jae    L115
  mov    0x18(%rsp),%eax
  cvttsd2si %xmm0,%r9d
  mov    0x28(%rsp),%rdi
  pxor   %xmm1,%xmm1
  cvttsd2si %xmm3,%r14d
  movapd %xmm7,%xmm11
  movapd %xmm7,%xmm10
  add    %ecx,%eax
  cvttsd2si %xmm8,%r8d
  movapd %xmm7,%xmm9
  cltq
  cvtsi2sd %r9d,%xmm1
  lea    (%rdi,%rax,8),%rax
  mov    %ebx,%edi
  imul   %r9d,%edi
  mov    %rax,0x10(%rsp)
  mov    %ebx,%eax
  imul   %r14d,%eax
  imul   %ebx,%edi
  subsd  %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  mov    %eax,0x1c(%rsp)
  cvtsi2sd %r14d,%xmm1
  lea    (%rdi,%rax,1),%r12d
  lea    0x1(%r8),%eax
  cltd
  subsd  %xmm0,%xmm11
  idiv   %ebx
  lea    0x1(%r14),%eax
  subsd  %xmm1,%xmm3
  pxor   %xmm1,%xmm1
  cvtsi2sd %r8d,%xmm1
  movapd %xmm11,%xmm12
  subsd  %xmm3,%xmm10
  mulsd  %xmm3,%xmm11
  subsd  %xmm1,%xmm8
  mulsd  %xmm10,%xmm12
  mulsd  %xmm0,%xmm10
  subsd  %xmm8,%xmm9
  mulsd  %xmm3,%xmm0
  movapd %xmm11,%xmm3
  mulsd  %xmm8,%xmm11
  mulsd  %xmm9,%xmm3
  movapd %xmm12,%xmm1
  mulsd  %xmm9,%xmm1
  mulsd  %xmm8,%xmm12
  mov    %edx,0x20(%rsp)
  cltd
  idiv   %ebx
  lea    0x1(%r9),%eax
  mov    0x1c(%rsp),%r9d
  imul   %ebx,%edx
  mov    %edx,%r14d
  add    %edx,%edi
  cltd
  idiv   %ebx
  imul   %ebx,%edx
  mov    %edx,%eax
  lea    (%r12,%r8,1),%edx
  imul   %ebx,%eax
  movslq %edx,%rdx
  mulsd  (%r10,%rdx,8),%xmm1
  lea    (%rdi,%r8,1),%edx
  movslq %edx,%rdx
  mulsd  (%r10,%rdx,8),%xmm3
  add    %eax,%r9d
  add    %r14d,%eax
  mov    0x20(%rsp),%r14d
  lea    (%r9,%r8,1),%edx
  add    %eax,%r8d
  add    %r14d,%r12d
  add    %r14d,%edi
  movslq %edx,%rdx
  add    %r14d,%r9d
  movslq %r12d,%r12
  movslq %edi,%rdi
  movslq %r9d,%r9
  movslq %r8d,%r8
  mulsd  (%r10,%r12,8),%xmm12
  add    %r14d,%eax
  mulsd  (%r10,%rdi,8),%xmm11
  cltq
  addsd  %xmm12,%xmm1
  addsd  %xmm3,%xmm1
  movapd %xmm10,%xmm3
  mulsd  %xmm9,%xmm3
  mulsd  (%r10,%rdx,8),%xmm3
  mulsd  %xmm8,%xmm10
  addsd  %xmm11,%xmm1
  mulsd  (%r10,%r9,8),%xmm10
  mulsd  %xmm0,%xmm9
  mulsd  (%r10,%r8,8),%xmm9
  addsd  %xmm3,%xmm1
  mulsd  %xmm8,%xmm0
  mulsd  (%r10,%rax,8),%xmm0
  mov    0x10(%rsp),%rax
  addsd  %xmm10,%xmm1
  addsd  %xmm9,%xmm1
  addsd  %xmm1,%xmm0
  addsd  (%rax),%xmm0
  movsd  %xmm0,(%rax)
  nopl   (%rax)
L115:
  add    $0x1,%ecx
  cmp    %ecx,%ebp
  jne    L74
  addl   $0x1,0xc(%rsp)
  mov    0xc(%rsp),%eax
  add    %ebx,0x18(%rsp)
  cmp    %eax,%ebp
  jne    L7
  addl   $0x1,0x30(%rsp)
  mov    0x30(%rsp),%eax
  mov    0x38(%rsp),%ecx
  add    %ecx,0x34(%rsp)
  cmp    %eax,%ebp
  jne    L101
L47:
  mov    0x58(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L81
  add    $0x68,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L81:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: tag: D5
datatype: f64

tool: D5: 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)];
        }
  }
}
```