user: 下面的汇编指令对应的C源代码是什么:

```asm
<quatVectLoopf>:
  endbr64
  push   %r15
  mov    %rdx,%rax
  xor    %r15d,%r15d
  mov    %rdi,%r10
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %r9d,%ebp
  push   %rbx
  sub    $0xb8,%rsp
  mov    %fs:0x28,%rdx
  mov    %rdx,0xa8(%rsp)
  xor    %edx,%edx
  cmp    $0x1,%rcx
  setne  %r15b
  lea    0x0(,%r15,4),%rdx
  cmp    $0x1,%r8
  je     L63
  cmp    $0x1,%rcx
  jbe    L78
  cmp    $0x1,%r8
  jbe    L78
  cmp    %r8,%rcx
  mov    $0x3,%r15d
  cmovbe %rcx,%r8
  mov    %r8,0x8(%rsp)
L125:
  mov    %rsi,%r9
  lea    0x60(%rsp),%r14
  lea    0x40(%rsp),%r13
  mov    %rax,%r8
  lea    0x0(,%rdx,4),%rdi
  lea    0x0(,%r15,4),%rbx
  xor    %r15d,%r15d
  mov    %rdi,0x38(%rsp)
  lea    0x80(%rsp),%r12
  nopl   0x0(%rax)
L101:
  movq   (%r9),%xmm0
  movlps 0x8(%r10),%xmm1
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  mov    %r8,0x30(%rsp)
  add    $0x1,%r15
  cvtps2pd %xmm0,%xmm0
  movaps %xmm0,0x40(%rsp)
  pxor   %xmm0,%xmm0
  cvtss2sd 0x8(%r9),%xmm0
  mov    %r9,0x28(%rsp)
  mov    %r10,0x20(%rsp)
  movsd  %xmm0,0x50(%rsp)
  cvtps2pd (%r10),%xmm0
  movaps %xmm1,0x10(%rsp)
  movaps %xmm0,0x80(%rsp)
  cvtps2pd %xmm1,%xmm0
  movaps %xmm0,0x90(%rsp)
  call   <quatVector@plt>
  mov    0x30(%rsp),%r8
  mov    0x28(%rsp),%r9
  cvtpd2ps 0x60(%rsp),%xmm0
  mov    0x20(%rsp),%r10
  add    0x38(%rsp),%r10
  movlps %xmm0,(%r8)
  pxor   %xmm0,%xmm0
  add    %rbx,%r9
  add    $0xc,%r8
  cvtsd2ss 0x70(%rsp),%xmm0
  movss  %xmm0,-0x4(%r8)
  cmp    0x8(%rsp),%r15
  movaps 0x10(%rsp),%xmm1
  jne    L101
L13:
  mov    0xa8(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L30
  add    $0xb8,%rsp
  mov    $0x1,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L63:
  test   %rcx,%rcx
  mov    $0x1,%ebx
  cmovne %rcx,%rbx
  mov    %rbx,0x8(%rsp)
  cmp    $0x1,%rcx
  jbe    L149
  movq   (%rsi),%xmm1
  mov    %r15,%rbx
  mov    %rax,%r8
  xor    %r15d,%r15d
  shl    $0x4,%rbx
  lea    0x60(%rsp),%r14
  lea    0x40(%rsp),%r13
  cvtps2pd %xmm1,%xmm1
  movaps %xmm1,0x40(%rsp)
  pxor   %xmm1,%xmm1
  lea    0x80(%rsp),%r12
  cvtss2sd 0x8(%rsi),%xmm1
  movsd  %xmm1,0x50(%rsp)
  nopl   (%rax)
L57:
  movlps 0x8(%r10),%xmm0
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  cvtps2pd (%r10),%xmm1
  mov    %r8,0x28(%rsp)
  add    $0x1,%r15
  mov    %r10,0x20(%rsp)
  movaps %xmm1,0x80(%rsp)
  cvtps2pd %xmm0,%xmm1
  movaps %xmm0,0x10(%rsp)
  movaps %xmm1,0x90(%rsp)
  call   <quatVector@plt>
  mov    0x28(%rsp),%r8
  mov    0x20(%rsp),%r10
  cvtpd2ps 0x60(%rsp),%xmm1
  movaps 0x10(%rsp),%xmm0
  movlps %xmm1,(%r8)
  pxor   %xmm1,%xmm1
  add    %rbx,%r10
  add    $0xc,%r8
  cvtsd2ss 0x70(%rsp),%xmm1
  movss  %xmm1,-0x4(%r8)
  cmp    %r15,0x8(%rsp)
  ja     L57
  jmp    L13
L78:
  cmp    %r8,%rcx
  cmovae %rcx,%r8
  mov    %r8,0x8(%rsp)
  cmp    $0x1,%r8
  jbe    L22
  cmp    $0x1,%rcx
  jne    L22
  movups (%r10),%xmm1
  mov    %rsi,%r8
  mov    %rax,%r15
  xor    %ebx,%ebx
  lea    0x60(%rsp),%r14
  lea    0x40(%rsp),%r13
  cvtps2pd %xmm1,%xmm0
  movaps %xmm0,0x80(%rsp)
  pxor   %xmm0,%xmm0
  lea    0x80(%rsp),%r12
  movhlps %xmm1,%xmm0
  cvtps2pd %xmm0,%xmm0
  movaps %xmm0,0x90(%rsp)
  xchg   %ax,%ax
L39:
  movq   (%r8),%xmm0
  mov    %ebp,%ecx
  mov    %r14,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  mov    %r8,0x10(%rsp)
  add    $0x1,%rbx
  add    $0xc,%r15
  cvtps2pd %xmm0,%xmm0
  movaps %xmm0,0x40(%rsp)
  pxor   %xmm0,%xmm0
  cvtss2sd 0x8(%r8),%xmm0
  movsd  %xmm0,0x50(%rsp)
  call   <quatVector@plt>
  mov    0x10(%rsp),%r8
  cvtpd2ps 0x60(%rsp),%xmm0
  movlps %xmm0,-0xc(%r15)
  pxor   %xmm0,%xmm0
  cvtsd2ss 0x70(%rsp),%xmm0
  add    $0xc,%r8
  movss  %xmm0,-0x4(%r15)
  cmp    %rbx,0x8(%rsp)
  ja     L39
  jmp    L13
L22:
  cmpq   $0x0,0x8(%rsp)
  je     L13
  mov    $0x3,%r15d
  jmp    L125
L149:
  xor    %r15d,%r15d
  jmp    L125
L30:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
int quatVectLoopf(float *q, float *v, float *vout, unsigned long long nq, unsigned long long nv, int p) {
  unsigned long long i, j, qstep, vstep, voutstep, n, istep;
  int trash;
  double qtemp[4], vtemp[3], vouttemp[3];
  voutstep = 3;
  qstep = (nq == 1) ? 0 : 4;
  vstep = (nv == 1) ? 0 : 3;
  if ((nq > 1) && (nv > 1)) {
    n = (nq <= nv) ? nq : nv;
  } else {
    n = (nq >= nv) ? nq : nv;
  }
  if ((nq == 1) && (n > 1)) {
#pragma omp parallel shared(q, v, vout) private(i, j, trash, qtemp, vtemp, vouttemp) firstprivate(qstep, vstep, voutstep, n, p)
    {
      for (j = 0; j < 4; j++)
        qtemp[j] = (double)q[j];
#pragma omp for schedule(static) nowait
      for (i = 0; i < n; i++) {
        for (j = 0; j < 3; j++)
          vtemp[j] = (double)v[i * vstep + j];
        trash = quatVector(qtemp, vtemp, vouttemp, p);
        for (j = 0; j < 3; j++)
          vout[i * voutstep + j] = (float)vouttemp[j];
      }
    }
  } else if ((nv == 1) && n > 1) {
#pragma omp parallel shared(q, v, vout) private(i, j, trash, qtemp, vtemp, vouttemp) firstprivate(qstep, vstep, voutstep, n, p)
    {
      for (j = 0; j < 3; j++)
        vtemp[j] = (double)v[j];
#pragma omp for schedule(static) nowait
      for (i = 0; i < n; i++) {
        for (j = 0; j < 4; j++)
          qtemp[j] = (double)q[i * qstep + j];
        trash = quatVector(qtemp, vtemp, vouttemp, p);
        for (j = 0; j < 3; j++)
          vout[i * voutstep + j] = (float)vouttemp[j];
      }
    }
  } else {
#pragma omp parallel shared(q, v, vout) private(i, j, trash, qtemp, vtemp, vouttemp) firstprivate(qstep, vstep, voutstep, n, p)
    {
#pragma omp for schedule(static) nowait
      for (i = 0; i < n; i++) {
        for (j = 0; j < 3; j++) {
          vtemp[j] = (double)v[i * vstep + j];
        }
        for (j = 0; j < 4; j++) {
          qtemp[j] = (double)q[i * qstep + j];
        }
        trash = quatVector(qtemp, vtemp, vouttemp, p);
        for (j = 0; j < 3; j++)
          vout[i * voutstep + j] = (float)vouttemp[j];
      }
    }
  }
  return 1;
}
```