user: 请将以下的汇编代码转换成C语言代码：

```asm
<c_sscal>:
  endbr64
  test   %edx,%edx
  mov    %rsi,%rax
  mov    $0x0,%r8d
  setle  %sil
  ucomiss D8(%rip),%xmm0
  setnp  %cl
  cmovne %r8d,%ecx
  or     %cl,%sil
  jne    L101
  test   %edi,%edi
  jle    L101
  cmp    $0x1,%edx
  je     L129
  imul   %edx,%edi
  movslq %edx,%rsi
  xor    %ecx,%ecx
  shl    $0x2,%rsi
  nopl   0x0(%rax,%rax,1)
L116:
  movss  (%rax),%xmm1
  add    %edx,%ecx
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%rax)
  add    %rsi,%rax
  cmp    %edi,%ecx
  jl     L116
L101:
  ret
  cs nopw 0x0(%rax,%rax,1)
L129:
  movslq %edi,%rcx
  mov    %edi,%edx
  imul   $0x66666667,%rcx,%rcx
  sar    $0x1f,%edx
  sar    $0x21,%rcx
  sub    %edx,%ecx
  lea    (%rcx,%rcx,4),%edx
  mov    %edi,%ecx
  sub    %edx,%ecx
  je     L93
  cmp    $0x4,%ecx
  jne    L115
  movups (%rax),%xmm7
  movaps %xmm0,%xmm1
  shufps $0x0,%xmm1,%xmm1
  mulps  %xmm7,%xmm1
  movups %xmm1,(%rax)
  nopw   0x0(%rax,%rax,1)
L93:
  cmp    $0x4,%edi
  jle    L101
  lea    -0x1(%rdi),%edx
  mov    $0xcccccccd,%esi
  sub    %ecx,%edx
  mov    %edx,%r8d
  imul   %rsi,%r8
  shr    $0x22,%r8
  lea    0x1(%r8),%r9d
  cmp    $0xe,%edx
  jbe    L15
  mov    %r9d,%esi
  movslq %ecx,%rdx
  movaps %xmm0,%xmm1
  shr    $0x2,%esi
  lea    (%rax,%rdx,4),%rdx
  shufps $0x0,%xmm1,%xmm1
  sub    $0x1,%esi
  lea    (%rsi,%rsi,4),%rdi
  lea    0x50(%rdx),%rsi
  shl    $0x4,%rdi
  add    %rsi,%rdi
  jmp    L19
  nop
L36:
  add    $0x50,%rsi
L19:
  movups 0x10(%rdx),%xmm5
  movups 0x20(%rdx),%xmm4
  movups 0x30(%rdx),%xmm3
  movups 0x40(%rdx),%xmm2
  movups (%rdx),%xmm6
  mulps  %xmm1,%xmm5
  mulps  %xmm1,%xmm4
  mulps  %xmm1,%xmm3
  mulps  %xmm1,%xmm2
  mulps  %xmm1,%xmm6
  movups %xmm5,0x10(%rdx)
  movups %xmm4,0x20(%rdx)
  movups %xmm3,0x30(%rdx)
  movups %xmm2,0x40(%rdx)
  movups %xmm6,(%rdx)
  mov    %rsi,%rdx
  cmp    %rsi,%rdi
  jne    L36
  mov    %r9d,%esi
  and    $0xfffffffc,%esi
  lea    (%rsi,%rsi,4),%edx
  add    %ecx,%edx
  cmp    %r9d,%esi
  je     L23
L26:
  mov    %r9d,%edi
  sub    %esi,%edi
  cmp    %esi,%r8d
  je     L46
  lea    (%rsi,%rsi,4),%rsi
  movslq %ecx,%rcx
  movaps %xmm0,%xmm1
  add    %rsi,%rcx
  shufps $0xe0,%xmm1,%xmm1
  lea    (%rax,%rcx,4),%rcx
  movq   0x8(%rcx),%xmm2
  movq   (%rcx),%xmm6
  mulps  %xmm1,%xmm6
  movaps %xmm2,%xmm5
  movq   0x10(%rcx),%xmm2
  mulps  %xmm1,%xmm5
  movaps %xmm2,%xmm4
  movq   0x18(%rcx),%xmm2
  mulps  %xmm1,%xmm4
  movaps %xmm2,%xmm3
  movq   0x20(%rcx),%xmm2
  mulps  %xmm1,%xmm3
  movlps %xmm6,(%rcx)
  mulps  %xmm1,%xmm2
  movlps %xmm5,0x8(%rcx)
  movlps %xmm4,0x10(%rcx)
  movlps %xmm3,0x18(%rcx)
  movlps %xmm2,0x20(%rcx)
  mov    %edi,%ecx
  and    $0xfffffffe,%ecx
  lea    (%rcx,%rcx,4),%esi
  add    %esi,%edx
  cmp    %ecx,%edi
  je     L101
L46:
  movslq %edx,%rdx
  shl    $0x2,%rdx
  lea    (%rax,%rdx,1),%rcx
  movss  (%rcx),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%rcx)
  lea    0x4(%rax,%rdx,1),%rcx
  movss  (%rcx),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%rcx)
  lea    0x8(%rax,%rdx,1),%rcx
  movss  (%rcx),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%rcx)
  lea    0xc(%rax,%rdx,1),%rcx
  lea    0x10(%rax,%rdx,1),%rax
  movss  (%rcx),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%rcx)
  mulss  (%rax),%xmm0
  movss  %xmm0,(%rax)
  ret
L115:
  cmp    $0x1,%ecx
  je     L82
  movq   (%rax),%xmm1
  movaps %xmm0,%xmm2
  mov    $0x2,%edx
  shufps $0xe0,%xmm2,%xmm2
  mulps  %xmm2,%xmm1
  movlps %xmm1,(%rax)
  cmp    $0x2,%ecx
  je     L93
L175:
  lea    (%rax,%rdx,4),%rdx
  movss  (%rdx),%xmm1
  mulss  %xmm0,%xmm1
  movss  %xmm1,(%rdx)
  jmp    L93
L23:
  ret
L15:
  mov    %ecx,%edx
  xor    %esi,%esi
  jmp    L26
L82:
  xor    %edx,%edx
  jmp    L175
```

tool_calls: name: retrieve_data
arguments: label: D8
type: byte[4]

tool: {"D8": [0x00,0x00,0x80,0x3f]}

assistant: ```c
void c_sscal(const int N, const float alpha, float *X, const int stride) {
  int i;
  int m;
  if (N <= 0 || stride <= 0 || alpha == 1.0f) {
    return;
  }
  if (stride == 1) {
    m = N % 5;
    if (m > 0) {
      for (i = 0; i < m; i++) {
        X[i] *= alpha;
      }
    }
    if (N < 5) {
      return;
    }
    for (i = m; i < N; i += 5) {
      X[i] *= alpha;
      X[i + 1] *= alpha;
      X[i + 2] *= alpha;
      X[i + 3] *= alpha;
      X[i + 4] *= alpha;
    }
    return;
  }
  for (i = 0; i < N * stride; i += stride) {
    X[i] *= alpha;
  }
  return;
}
```