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

```asm
<XXH32_SSE4>:
  endbr64
  push   %r15
  movslq %esi,%rsi
  push   %r14
  lea    (%rdi,%rsi,1),%r15
  push   %r13
  mov    %rdi,%r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rsi,-0x10(%rsp)
  cmp    $0x1f,%esi
  jle    L52
  lea    -0x20(%r15),%rbx
  lea    -0x7a143589(%rdx),%edi
  mov    %edx,%r12d
  mov    %r13,%rax
  lea    0x24234428(%rdx),%r8d
  lea    0x61c8864f(%rdx),%ecx
  mov    %r15,-0x8(%rsp)
  mov    %edi,%ebp
  mov    %ecx,%r14d
  mov    %r8d,%esi
  mov    %rbx,%r15
  nopl   0x0(%rax,%rax,1)
L41:
  imul   $0x85ebca77,(%rax),%r9d
  imul   $0x85ebca77,0x14(%rax),%ebx
  imul   $0x85ebca77,0x18(%rax),%r11d
  add    %r9d,%r8d
  imul   $0x85ebca77,0x4(%rax),%r9d
  imul   $0x85ebca77,0x1c(%rax),%r10d
  add    %ebp,%ebx
  rol    $0xd,%r8d
  add    %r12d,%r11d
  rol    $0xd,%ebx
  imul   $0x9e3779b1,%r8d,%r8d
  add    %r9d,%edi
  imul   $0x85ebca77,0x8(%rax),%r9d
  rol    $0xd,%r11d
  add    %r14d,%r10d
  rol    $0xd,%edi
  imul   $0x9e3779b1,%ebx,%ebp
  rol    $0xd,%r10d
  imul   $0x9e3779b1,%edi,%edi
  add    %r9d,%edx
  imul   $0x85ebca77,0xc(%rax),%r9d
  rol    $0xd,%edx
  imul   $0x9e3779b1,%r11d,%r12d
  imul   $0x9e3779b1,%edx,%edx
  add    %r9d,%ecx
  imul   $0x85ebca77,0x10(%rax),%r9d
  rol    $0xd,%ecx
  imul   $0x9e3779b1,%r10d,%r14d
  imul   $0x9e3779b1,%ecx,%ecx
  add    %esi,%r9d
  rol    $0xd,%r9d
  imul   $0x9e3779b1,%r9d,%esi
  add    $0x20,%rax
  cmp    %rax,%r15
  jae    L41
  mov    -0x10(%rsp),%rax
  mov    -0x8(%rsp),%r15
  lea    0x1(%r13),%rsi
  sub    $0x20,%rax
  lea    -0x1f(%r15),%rbp
  and    $0xffffffffffffffe0,%rax
  add    $0x20,%rax
  cmp    %rsi,%rbp
  mov    $0x20,%esi
  cmovb  %rsi,%rax
  imul   $0xfc4a3b47,%r11d,%r11d
  imul   $0xfc4a3b47,%r9d,%r9d
  imul   $0xfc4a3b47,%ebx,%ebx
  add    %rax,%r13
  add    %edx,%r11d
  imul   $0xfc4a3b47,%r10d,%edx
  add    %r8d,%r9d
  rol    $0xd,%r11d
  add    %edi,%ebx
  rol    $0xd,%r9d
  imul   $0x9e3779b1,%r11d,%r11d
  rol    $0xd,%ebx
  add    %ecx,%edx
  imul   $0x9e3779b1,%ebx,%ebx
  rol    $0xd,%edx
  imul   $0x9e3779b1,%r9d,%ecx
  rol    $0xc,%r11d
  imul   $0x9e3779b1,%edx,%edx
  rol    $0x7,%ebx
  rol    %ecx
  add    %ebx,%ecx
  ror    $0xe,%edx
  add    %r11d,%ecx
  add    %edx,%ecx
L25:
  lea    -0x4(%r15),%rsi
  add    %ecx,%eax
  cmp    %rsi,%r13
  ja     L4
  mov    %r13,%rcx
  mov    %eax,%edx
  nopw   0x0(%rax,%rax,1)
L61:
  imul   $0xc2b2ae3d,(%rcx),%eax
  add    $0x4,%rcx
  add    %edx,%eax
  ror    $0xf,%eax
  imul   $0x27d4eb2f,%eax,%edx
  cmp    %rcx,%rsi
  jae    L61
  sub    %r13,%rsi
  mov    %edx,%eax
  shr    $0x2,%rsi
  lea    0x4(%r13,%rsi,4),%r13
L4:
  cmp    %r15,%r13
  jae    L89
  movzbl 0x0(%r13),%edx
  imul   $0x165667b1,%edx,%edx
  add    %edx,%eax
  lea    0x1(%r13),%rdx
  rol    $0xb,%eax
  imul   $0x9e3779b1,%eax,%eax
  cmp    %rdx,%r15
  jbe    L89
  movzbl 0x1(%r13),%edx
  imul   $0x165667b1,%edx,%edx
  add    %edx,%eax
  lea    0x2(%r13),%rdx
  rol    $0xb,%eax
  imul   $0x9e3779b1,%eax,%eax
  cmp    %rdx,%r15
  jbe    L89
  movzbl 0x2(%r13),%edx
  imul   $0x165667b1,%edx,%edx
  add    %edx,%eax
  lea    0x3(%r13),%rdx
  rol    $0xb,%eax
  imul   $0x9e3779b1,%eax,%eax
  cmp    %rdx,%r15
  jbe    L89
  movzbl 0x3(%r13),%edx
  imul   $0x165667b1,%edx,%edx
  add    %edx,%eax
  rol    $0xb,%eax
  imul   $0x9e3779b1,%eax,%eax
L89:
  mov    %eax,%edx
  pop    %rbx
  pop    %rbp
  shr    $0xf,%edx
  pop    %r12
  pop    %r13
  xor    %edx,%eax
  pop    %r14
  pop    %r15
  imul   $0x85ebca77,%eax,%eax
  mov    %eax,%edx
  shr    $0xd,%edx
  xor    %eax,%edx
  imul   $0xc2b2ae3d,%edx,%edx
  mov    %edx,%eax
  shr    $0x10,%eax
  xor    %edx,%eax
  ret
  nopl   0x0(%rax)
L52:
  mov    %rsi,%rax
  lea    0x165667b1(%rdx),%ecx
  jmp    L25
```

assistant: ```c
unsigned int XXH32_SSE4(const void *input, int len, unsigned int seed) {
  const unsigned char *p = (const unsigned char *)input;
  const unsigned char *p1 = p;
  const unsigned char *const bEnd = p + len;
  unsigned int h32;
  if (len >= 32) {
    const unsigned char *const limit = bEnd - 32;
    unsigned int v1 = seed + 2654435761U + 2246822519U;
    unsigned int v2 = seed + 2246822519U;
    unsigned int v3 = seed + 0;
    unsigned int v4 = seed - 2654435761U;
    unsigned int vx1 = seed + 2654435761U + 2246822519U;
    unsigned int vx2 = seed + 2246822519U;
    unsigned int vx3 = seed + 0;
    unsigned int vx4 = seed - 2654435761U;
    do {
      v1 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      v1 = ((v1 << 13) | (v1 >> (32 - 13)));
      v1 *= 2654435761U;
      p += 4;
      v2 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      v2 = ((v2 << 13) | (v2 >> (32 - 13)));
      v2 *= 2654435761U;
      p += 4;
      v3 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      v3 = ((v3 << 13) | (v3 >> (32 - 13)));
      v3 *= 2654435761U;
      p += 4;
      v4 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      v4 = ((v4 << 13) | (v4 >> (32 - 13)));
      v4 *= 2654435761U;
      p += 4;
      vx1 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      vx1 = ((vx1 << 13) | (vx1 >> (32 - 13)));
      vx1 *= 2654435761U;
      p += 4;
      vx2 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      vx2 = ((vx2 << 13) | (vx2 >> (32 - 13)));
      vx2 *= 2654435761U;
      p += 4;
      vx3 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      vx3 = ((vx3 << 13) | (vx3 >> (32 - 13)));
      vx3 *= 2654435761U;
      p += 4;
      vx4 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 2246822519U;
      vx4 = ((vx4 << 13) | (vx4 >> (32 - 13)));
      vx4 *= 2654435761U;
      p += 4;
    } while (p <= limit);
    v1 += vx1 * 2246822519U;
    v1 = ((v1 << 13) | (v1 >> (32 - 13)));
    v1 *= 2654435761U;
    v2 += vx2 * 2246822519U;
    v2 = ((v2 << 13) | (v2 >> (32 - 13)));
    v2 *= 2654435761U;
    v3 += vx3 * 2246822519U;
    v3 = ((v3 << 13) | (v3 >> (32 - 13)));
    v3 *= 2654435761U;
    v4 += vx4 * 2246822519U;
    v4 = ((v4 << 13) | (v4 >> (32 - 13)));
    v4 *= 2654435761U;
    h32 = ((v1 << 1) | (v1 >> (32 - 1))) + ((v2 << 7) | (v2 >> (32 - 7))) + ((v3 << 12) | (v3 >> (32 - 12))) + ((v4 << 18) | (v4 >> (32 - 18)));
    len = p - p1;
  } else {
    h32 = seed + 374761393U;
  }
  h32 += (unsigned int)len;
  while (p <= bEnd - 4) {
    h32 += (0 ? __builtin_bswap32(*(unsigned int *)(p)) : *(unsigned int *)(p)) * 3266489917U;
    h32 = ((h32 << 17) | (h32 >> (32 - 17))) * 668265263U;
    p += 4;
  }
  while (p < bEnd) {
    h32 += (*p) * 374761393U;
    h32 = ((h32 << 11) | (h32 >> (32 - 11))) * 2654435761U;
    p++;
  }
  h32 ^= h32 >> 15;
  h32 *= 2246822519U;
  h32 ^= h32 >> 13;
  h32 *= 3266489917U;
  h32 ^= h32 >> 16;
  return h32;
}
```