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

```asm
<boxfilter1CC>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rdi,-0x8(%rsp)
  mov    %rsi,-0x30(%rsp)
  mov    %rdx,%r10
  mov    %rcx,-0x10(%rsp)
  mov    %r8d,%r15d
  mov    %r9d,%ecx
  mov    0x38(%rsp),%edi
  mov    0x40(%rsp),%r8d
  test   %r8d,%r8d
  jle    L65
  mov    %edi,%eax
  imul   %r9d,%eax
  mov    %eax,-0x18(%rsp)
  movslq %r9d,%rax
  shl    $0x2,%rax
  mov    %rax,-0x40(%rsp)
  movslq %r15d,%rax
  mov    %rax,-0x38(%rsp)
  neg    %rax
  shl    $0x2,%rax
  mov    %rax,-0x48(%rsp)
  movl   $0x0,-0x28(%rsp)
  movl   $0x0,-0x24(%rsp)
  mov    %r15d,%r13d
  neg    %r13d
  lea    0x1(%r15),%r14d
  lea    -0x1(%r15),%r12d
  mov    %rdx,-0x20(%rsp)
  mov    %r8d,0x40(%rsp)
  jmp    L69
L129:
  add    $0x1,%rax
  cmp    %eax,%r15d
  jl     L372
L410:
  addss  (%r10,%rax,4),%xmm0
  test   %eax,%eax
  js     L129
  movss  %xmm0,(%rsi,%rax,4)
  jmp    L129
L372:
  mov    %r14d,%edx
L248:
  lea    (%r15,%rdx,1),%r9d
  cmp    %r9d,%ecx
  jle    L42
  lea    0x1(%rdx),%eax
  cltq
  movslq %edx,%rdx
  movslq %r9d,%r9
  sub    %rdx,%r9
  lea    (%r11,%r9,4),%r11
L383:
  subss  -0x8(%r8,%rax,4),%xmm0
  addss  -0x4(%r11,%rax,4),%xmm0
  movss  %xmm0,-0x4(%rsi,%rax,4)
  mov    %eax,%edx
  add    $0x1,%rax
  lea    (%r12,%rax,1),%r9d
  cmp    %r9d,%ecx
  jg     L383
L42:
  cmp    %edx,%ecx
  jle    L288
  movslq %edx,%rdx
L165:
  subss  -0x4(%r8,%rdx,4),%xmm0
  movss  %xmm0,(%rsi,%rdx,4)
  add    $0x1,%rdx
  cmp    %edx,%ecx
  jg     L165
L288:
  add    $0x1,%ebp
  mov    -0x40(%rsp),%rax
  add    %rax,%r8
  add    %rax,%rbx
  add    %rax,%r10
  cmp    %ebp,%edi
  je     L127
L75:
  mov    -0x48(%rsp),%rax
  lea    (%rax,%r10,1),%r11
  mov    %rbx,%rsi
  mov    %r13d,%edx
  cmp    %r13d,%r15d
  jl     L189
  movslq %r13d,%rax
  pxor   %xmm0,%xmm0
  jmp    L410
L189:
  pxor   %xmm0,%xmm0
  jmp    L248
L127:
  mov    -0x24(%rsp),%eax
  add    $0x1,%eax
  mov    -0x18(%rsp),%esi
  add    %esi,-0x28(%rsp)
  cmp    %eax,0x40(%rsp)
  je     L10
  mov    %eax,-0x24(%rsp)
L69:
  test   %edi,%edi
  jle    L127
  movslq -0x28(%rsp),%rax
  lea    0x0(,%rax,4),%rbx
  mov    -0x48(%rsp),%rsi
  lea    (%rbx,%rsi,1),%r8
  mov    -0x30(%rsp),%rsi
  add    %rsi,%r8
  add    -0x10(%rsp),%rbx
  add    -0x38(%rsp),%rax
  lea    (%rsi,%rax,4),%r10
  mov    $0x0,%ebp
  jmp    L75
L10:
  mov    -0x20(%rsp),%r10
  mov    %r15d,%ebp
  mov    %r15d,%eax
  imul   %ecx,%eax
  neg    %eax
  mov    %eax,-0x38(%rsp)
  mov    %r15d,%eax
  neg    %eax
  mov    %eax,-0x28(%rsp)
  movl   $0x0,-0x14(%rsp)
  movl   $0x0,-0x20(%rsp)
  mov    %ecx,%eax
  mov    %rax,-0x30(%rsp)
  lea    0x1(%r15),%r12d
  mov    -0x40(%rsp),%rsi
  mov    %r15d,-0x48(%rsp)
  mov    -0x10(%rsp),%r15
  jmp    L387
L348:
  movslq %r8d,%r9
  movss  %xmm0,(%r10,%r9,4)
L192:
  add    $0x1,%eax
  add    %rsi,%rdx
  add    %ecx,%r8d
  cmp    %r12d,%eax
  je     L38
L55:
  addss  (%rdx),%xmm0
  test   %eax,%eax
  jns    L348
  jmp    L192
L21:
  mov    -0x28(%rsp),%eax
  pxor   %xmm0,%xmm0
L38:
  mov    -0x48(%rsp),%ebx
  lea    (%rbx,%rax,1),%edx
  cmp    %edx,%edi
  jle    L396
  mov    -0x40(%rsp),%r11
  lea    0x0(%r13,%r11,1),%r8
  mov    %eax,%r9d
  sub    %ebx,%r9d
  sub    $0x1,%r9d
  imul   %ecx,%r9d
  movslq %r9d,%r9
  add    %r8,%r9
  lea    (%r15,%r9,4),%rbx
  imul   %ecx,%edx
  movslq %edx,%rdx
  add    %r8,%rdx
  lea    (%r15,%rdx,4),%r11
  mov    %ecx,%edx
  imul   %eax,%edx
  movslq %edx,%rdx
  add    %r8,%rdx
  lea    (%r10,%rdx,4),%r9
  mov    $0x0,%edx
L312:
  subss  (%rbx,%rdx,1),%xmm0
  addss  (%r11,%rdx,1),%xmm0
  movss  %xmm0,(%r9,%rdx,1)
  add    $0x1,%eax
  add    %rsi,%rdx
  lea    (%rax,%rbp,1),%r8d
  cmp    %r8d,%edi
  jg     L312
L396:
  cmp    %eax,%edi
  jle    L4
  mov    -0x40(%rsp),%rbx
  lea    0x0(%r13,%rbx,1),%r8
  mov    %eax,%edx
  sub    -0x48(%rsp),%edx
  sub    $0x1,%edx
  imul   %ecx,%edx
  movslq %edx,%rdx
  add    %r8,%rdx
  lea    (%r15,%rdx,4),%r9
  mov    %ecx,%edx
  imul   %eax,%edx
  movslq %edx,%rdx
  add    %r8,%rdx
  lea    (%r10,%rdx,4),%r8
  mov    $0x0,%edx
L233:
  subss  (%r9,%rdx,1),%xmm0
  movss  %xmm0,(%r8,%rdx,1)
  add    $0x1,%eax
  add    %rsi,%rdx
  cmp    %eax,%edi
  jne    L233
L4:
  add    $0x1,%r13
  add    $0x4,%r14
  cmp    -0x30(%rsp),%r13
  je     L255
L90:
  mov    -0x28(%rsp),%eax
  cmp    %eax,-0x48(%rsp)
  jl     L21
  mov    -0x38(%rsp),%ebx
  lea    (%rbx,%r13,1),%r8d
  mov    %r14,%rdx
  pxor   %xmm0,%xmm0
  jmp    L55
L255:
  mov    -0x20(%rsp),%ebx
  lea    0x1(%rbx),%eax
  mov    -0x18(%rsp),%r14d
  add    %r14d,-0x14(%rsp)
  add    %r14d,-0x38(%rsp)
  cmp    %ebx,-0x24(%rsp)
  je     L67
  mov    %eax,-0x20(%rsp)
L387:
  test   %ecx,%ecx
  jle    L255
  movslq -0x14(%rsp),%rax
  mov    %rax,-0x40(%rsp)
  lea    (%r15,%rax,4),%r14
  mov    $0x0,%r13d
  jmp    L90
L67:
  mov    -0x48(%rsp),%r15d
  mov    0x40(%rsp),%r8d
L65:
  cmp    $0x1,%r8d
  mov    $0x0,%eax
  cmovle %eax,%r15d
  test   %edi,%edi
  jle    L219
  mov    %r15d,%r12d
  mov    %edi,%ebx
  imul   %ecx,%ebx
  mov    %ebx,-0x48(%rsp)
  mov    %ebx,%eax
  imul   %r15d,%eax
  neg    %eax
  mov    %eax,-0x20(%rsp)
  mov    %r15d,%eax
  neg    %eax
  mov    %eax,-0x38(%rsp)
  movslq %ebx,%rsi
  shl    $0x2,%rsi
  mov    %ecx,-0x28(%rsp)
  movl   $0x0,-0x18(%rsp)
  movl   $0x0,-0x24(%rsp)
  lea    0x1(%r15),%r13d
  mov    %r15d,-0x40(%rsp)
  mov    -0x8(%rsp),%r15
  jmp    L16
L93:
  add    $0x1,%eax
  add    %rsi,%rdx
  add    -0x48(%rsp),%r9d
  cmp    %r13d,%eax
  je     L389
L294:
  addss  (%rdx),%xmm0
  test   %eax,%eax
  js     L93
  movslq %r9d,%r11
  movss  %xmm0,(%r15,%r11,4)
  jmp    L93
L73:
  mov    -0x38(%rsp),%eax
  pxor   %xmm0,%xmm0
L389:
  mov    -0x40(%rsp),%ebx
  lea    (%rbx,%rax,1),%edx
  cmp    %edx,%r8d
  jle    L305
  movslq %r14d,%r9
  mov    %eax,%r11d
  sub    %ebx,%r11d
  sub    $0x1,%r11d
  imul   %ecx,%r11d
  imul   %edi,%r11d
  movslq %r11d,%r11
  add    %r9,%r11
  lea    (%r10,%r11,4),%rbp
  imul   %ecx,%edx
  imul   %edi,%edx
  movslq %edx,%rdx
  add    %r9,%rdx
  lea    (%r10,%rdx,4),%rbx
  mov    %ecx,%edx
  imul   %eax,%edx
  imul   %edi,%edx
  movslq %edx,%rdx
  add    %r9,%rdx
  lea    (%r15,%rdx,4),%r11
  mov    $0x0,%edx
L46:
  subss  0x0(%rbp,%rdx,1),%xmm0
  addss  (%rbx,%rdx,1),%xmm0
  movss  %xmm0,(%r11,%rdx,1)
  add    $0x1,%eax
  add    %rsi,%rdx
  lea    (%rax,%r12,1),%r9d
  cmp    %r9d,%r8d
  jg     L46
L305:
  cmp    %eax,%r8d
  jle    L371
  movslq %r14d,%r9
  mov    %eax,%edx
  sub    -0x40(%rsp),%edx
  sub    $0x1,%edx
  imul   %ecx,%edx
  imul   %edi,%edx
  movslq %edx,%rdx
  add    %r9,%rdx
  lea    (%r10,%rdx,4),%r11
  mov    %ecx,%edx
  imul   %eax,%edx
  imul   %edi,%edx
  movslq %edx,%rdx
  add    %r9,%rdx
  lea    (%r15,%rdx,4),%r9
  mov    $0x0,%edx
L226:
  subss  (%r11,%rdx,1),%xmm0
  movss  %xmm0,(%r9,%rdx,1)
  add    $0x1,%eax
  add    %rsi,%rdx
  cmp    %eax,%r8d
  jne    L226
L371:
  add    $0x1,%r14d
  cmp    -0x28(%rsp),%r14d
  je     L338
L447:
  mov    -0x38(%rsp),%ebx
  cmp    %ebx,-0x40(%rsp)
  jl     L73
  movslq %r14d,%rax
  lea    (%r10,%rax,4),%rdx
  mov    -0x30(%rsp),%eax
  lea    (%rax,%r14,1),%r9d
  mov    %ebx,%eax
  pxor   %xmm0,%xmm0
  jmp    L294
L338:
  addl   $0x1,-0x24(%rsp)
  mov    -0x24(%rsp),%eax
  add    %ecx,-0x28(%rsp)
  add    %ecx,-0x18(%rsp)
  add    %ecx,-0x20(%rsp)
  cmp    %eax,%edi
  je     L219
L16:
  mov    -0x18(%rsp),%ebx
  mov    %ebx,%r14d
  mov    -0x20(%rsp),%eax
  sub    %ebx,%eax
  mov    %eax,-0x30(%rsp)
  test   %ecx,%ecx
  jg     L447
  jmp    L338
L219:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
void boxfilter1CC(float *output, float *input, float *temp1, float *temp2, int hw, int m, int n, int o) {
  const int RANGE = hw;
  const int sz = m * n * o;
  for (int k = 0; k < o; k++) {
    for (int j = 0; j < n; j++) {
      float sumA = 0;
      const float *inRow = input + j * m + k * m * n;
      float *outRow = temp2 + j * m + k * m * n;
      int x = -RANGE;
      for (; x <= RANGE; x++) {
        sumA += inRow[x + RANGE];
        ;
        if (x >= 0)
          outRow[x] = sumA;
      }
      for (; x + RANGE < m; x++) {
        sumA -= inRow[x - RANGE - 1];
        sumA += inRow[x + RANGE];
        outRow[x] = sumA;
      }
      for (; x < m; x++) {
        sumA -= inRow[x - RANGE - 1];
        outRow[x] = sumA;
      }
    }
  }
  for (int k = 0; k < o; k++) {
    for (int i = 0; i < m; i++) {
      float sumA = 0;
      int x = -RANGE;
      for (; x <= RANGE; x++) {
        sumA += temp2[i + (x + RANGE) * m + k * m * n];
        if (x >= 0)
          temp1[i + x * m + k * m * n] = sumA;
      }
      for (; x + RANGE < n; x++) {
        sumA -= temp2[i + (x - RANGE - 1) * m + k * m * n];
        sumA += temp2[i + (x + RANGE) * m + k * m * n];
        temp1[i + x * m + k * m * n] = sumA;
      }
      for (; x < n; x++) {
        sumA -= temp2[i + (x - RANGE - 1) * m + k * m * n];
        temp1[i + x * m + k * m * n] = sumA;
      }
    }
  }
  const int ORANGE = o > 1 ? RANGE : 0;
  for (int j = 0; j < n; j++) {
    for (int i = 0; i < m; i++) {
      float sumA = 0;
      int x = -ORANGE;
      for (; x <= ORANGE; x++) {
        sumA += temp1[i + j * m + (x + ORANGE) * m * n];
        if (x >= 0)
          output[i + j * m + x * m * n] = sumA;
      }
      for (; x + ORANGE < o; x++) {
        sumA -= temp1[i + j * m + (x - ORANGE - 1) * m * n];
        sumA += temp1[i + j * m + (x + ORANGE) * m * n];
        output[i + j * m + x * m * n] = sumA;
      }
      for (; x < o; x++) {
        sumA -= temp1[i + j * m + (x - ORANGE - 1) * m * n];
        output[i + j * m + x * m * n] = sumA;
      }
    }
  }
}
```