user: Converte this assembly snippet into its equivalent C code:

```asm
<upsample_component_line_lanczos>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x18,%rsp
  cmpl   $0x1,0x58(%rsp)
  mov    0x60(%rsp),%r14d
  jle    L23
  mov    %rdi,%r12
  mov    %rsi,%rbx
  mov    %rdx,%rbp
  mov    %r8d,%r15d
  mov    %r9d,%r13d
  test   %r9d,%r9d
  jle    L117
  movslq %r9d,%rsi
  lea    0x0(,%rsi,4),%rdx
  lea    (%rbx,%rdx,1),%rax
  cmp    %rax,%rbp
  jae    L190
  lea    0x0(%rbp,%rdx,1),%rax
  cmp    %rax,%rbx
  jb     L84
L190:
  xor    %esi,%esi
  mov    %rbp,%rdi
  mov    %rcx,0x8(%rsp)
  mov    %rdx,(%rsp)
  call   <memset@plt>
  mov    (%rsp),%rdx
  xor    %esi,%esi
  mov    %rbx,%rdi
  call   <memset@plt>
  mov    0x8(%rsp),%rcx
L207:
  test   %r14d,%r14d
  jle    L29
L6:
  lea    -0x1(%r15),%esi
  mov    %esi,%eax
  shr    $0x1f,%eax
  add    %esi,%eax
  sar    %eax
  neg    %eax
  test   %r15d,%r15d
  jle    L170
  movslq 0x58(%rsp),%r15
  cltq
  xor    %r8d,%r8d
  lea    0x1(%rax,%rsi,1),%rdx
  neg    %rax
  mov    %r15,%rdi
  lea    (%rcx,%rax,4),%rcx
  neg    %rdi
  shl    $0x2,%rdi
  nop
L92:
  mov    %rdx,%rax
  sub    %rsi,%rax
  sub    $0x1,%rax
  nopw   0x0(%rax,%rax,1)
L61:
  test   %eax,%eax
  js     L194
  cmp    %eax,%r13d
  jle    L194
  movss  0x0(%rbp,%rax,4),%xmm0
  addss  (%rcx,%rax,4),%xmm0
  movss  %xmm0,0x0(%rbp,%rax,4)
  movss  (%r12,%r8,4),%xmm0
  mulss  (%rcx,%rax,4),%xmm0
  addss  (%rbx,%rax,4),%xmm0
  movss  %xmm0,(%rbx,%rax,4)
L194:
  add    $0x1,%rax
  cmp    %rdx,%rax
  jne    L61
  add    $0x1,%r8
  add    %r15,%rdx
  add    %rdi,%rcx
  cmp    %r8d,%r14d
  jg     L92
L170:
  test   %r13d,%r13d
  jle    L23
L29:
  lea    0x4(%rbp),%rdx
  mov    %rbx,%rax
  sub    %rdx,%rax
  cmp    $0x8,%rax
  jbe    L150
  cmp    $0x3,%r13d
  jle    L150
  test   %r13d,%r13d
  mov    $0x1,%ecx
  cmovg  %r13d,%ecx
  xor    %eax,%eax
  mov    %ecx,%edx
  shr    $0x2,%edx
  shl    $0x4,%rdx
  nopl   (%rax)
L185:
  movups (%rbx,%rax,1),%xmm0
  movups 0x0(%rbp,%rax,1),%xmm1
  divps  %xmm1,%xmm0
  movups %xmm0,(%rbx,%rax,1)
  add    $0x10,%rax
  cmp    %rax,%rdx
  jne    L185
  mov    %ecx,%eax
  and    $0xfffffffc,%eax
  and    $0x3,%ecx
  je     L23
  mov    %eax,%esi
  lea    0x0(,%rsi,4),%rdx
  lea    (%rbx,%rdx,1),%rcx
  movss  (%rcx),%xmm0
  divss  0x0(%rbp,%rsi,4),%xmm0
  movss  %xmm0,(%rcx)
  lea    0x1(%rax),%ecx
  cmp    %ecx,%r13d
  jle    L23
  lea    0x4(%rbx,%rdx,1),%rcx
  add    $0x2,%eax
  movss  (%rcx),%xmm0
  divss  0x4(%rbp,%rdx,1),%xmm0
  movss  %xmm0,(%rcx)
  cmp    %eax,%r13d
  jle    L23
  lea    0x8(%rbx,%rdx,1),%rax
  movss  (%rax),%xmm0
  divss  0x8(%rbp,%rdx,1),%xmm0
  movss  %xmm0,(%rax)
L23:
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L150:
  xor    %eax,%eax
  xchg   %ax,%ax
L9:
  movss  (%rbx,%rax,4),%xmm0
  divss  0x0(%rbp,%rax,4),%xmm0
  movss  %xmm0,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    %eax,%r13d
  jg     L9
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L117:
  test   %r14d,%r14d
  jg     L6
  jmp    L23
L84:
  xor    %eax,%eax
  nopl   (%rax)
L189:
  movl   $0x0,0x0(%rbp,%rax,4)
  movl   $0x0,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%rsi
  jne    L189
  jmp    L207
```

assistant: ```c
void upsample_component_line_lanczos(const float *x_in_buff, float *x_out_buff, float *weight_x_out_buff, const float *x_contrib, const int x_contrib_size, const int width, const int xpos, const int xstep, const int compressed_width) {
  int i;
  int rpos;
  int wpos;
  int cpos;
  int weight_shift;
  weight_shift = 0 - ((x_contrib_size - 1) / 2);
  if (xstep > 1) {
    for (i = 0; i < width; i++)
      x_out_buff[i] = weight_x_out_buff[i] = 0;
    for (rpos = 0; rpos < compressed_width; rpos++) {
      wpos = (rpos * xstep) + weight_shift;
      for (cpos = 0; cpos < x_contrib_size; cpos++) {
        if ((wpos >= 0) && (wpos < width)) {
          weight_x_out_buff[wpos] += x_contrib[cpos];
          x_out_buff[wpos] += x_in_buff[rpos] * x_contrib[cpos];
        }
        wpos++;
      }
    }
    for (i = 0; i < width; i++)
      x_out_buff[i] = x_out_buff[i] / weight_x_out_buff[i];
  }
}
```