user: Demonstrate the C code that generates the assembly output below:

```asm
<my_hashword2>:
  endbr64
  mov    (%rdx),%eax
  mov    %rsi,%r8
  mov    %rdx,%rsi
  lea    -0x21524111(%rax,%r8,4),%edx
  mov    (%rcx),%eax
  mov    %edx,%r10d
  add    %edx,%eax
  cmp    $0x3,%r8
  jbe    L39
  nopl   (%rax)
L30:
  add    0x8(%rdi),%eax
  add    (%rdi),%edx
  mov    %eax,%r9d
  mov    %eax,%r11d
  sub    %eax,%edx
  add    0x4(%rdi),%r10d
  sar    $0x1c,%r11d
  shl    $0x4,%r9d
  add    %r10d,%eax
  or     %r11d,%r9d
  xor    %r9d,%edx
  mov    %edx,%r9d
  mov    %edx,%r11d
  sub    %edx,%r10d
  sar    $0x1a,%r11d
  shl    $0x6,%r9d
  or     %r11d,%r9d
  lea    (%rdx,%rax,1),%r11d
  xor    %r10d,%r9d
  mov    %r9d,%edx
  mov    %r9d,%r10d
  sub    %r9d,%eax
  sar    $0x18,%r10d
  shl    $0x8,%edx
  or     %r10d,%edx
  lea    (%r9,%r11,1),%r10d
  xor    %eax,%edx
  mov    %edx,%eax
  mov    %edx,%r9d
  sub    %edx,%r11d
  sar    $0x10,%r9d
  shl    $0x10,%eax
  or     %r9d,%eax
  lea    (%rdx,%r10,1),%r9d
  xor    %r11d,%eax
  mov    %eax,%edx
  mov    %eax,%r11d
  sub    %eax,%r10d
  sar    $0xd,%r11d
  shl    $0x13,%edx
  or     %r11d,%edx
  xor    %edx,%r10d
  lea    (%rax,%r9,1),%edx
  mov    %r10d,%r11d
  mov    %r10d,%eax
  sub    %r10d,%r9d
  shl    $0x4,%eax
  sar    $0x1c,%r11d
  or     %r11d,%eax
  sub    $0x3,%r8
  add    %edx,%r10d
  add    $0xc,%rdi
  xor    %r9d,%eax
  cmp    $0x3,%r8
  ja     L30
L39:
  cmp    $0x2,%r8
  je     L22
  cmp    $0x3,%r8
  je     L32
  cmp    $0x1,%r8
  je     L37
  mov    %eax,(%rsi)
  mov    %r10d,(%rcx)
  ret
  nopl   0x0(%rax,%rax,1)
L32:
  add    0x8(%rdi),%eax
L22:
  add    0x4(%rdi),%r10d
L37:
  add    (%rdi),%edx
  mov    %r10d,%r8d
  mov    %r10d,%edi
  xor    %r10d,%eax
  sar    $0x12,%r8d
  shl    $0xe,%edi
  or     %r8d,%edi
  sub    %edi,%eax
  mov    %eax,%edi
  mov    %eax,%r8d
  xor    %eax,%edx
  sar    $0x15,%r8d
  shl    $0xb,%edi
  or     %r8d,%edi
  sub    %edi,%edx
  mov    %edx,%edi
  mov    %edx,%r8d
  xor    %edx,%r10d
  sar    $0x7,%r8d
  shl    $0x19,%edi
  or     %r8d,%edi
  sub    %edi,%r10d
  mov    %r10d,%edi
  mov    %r10d,%r8d
  xor    %r10d,%eax
  sar    $0x10,%r8d
  shl    $0x10,%edi
  or     %r8d,%edi
  sub    %edi,%eax
  mov    %eax,%edi
  mov    %eax,%r8d
  xor    %eax,%edx
  shl    $0x4,%edi
  sar    $0x1c,%r8d
  or     %r8d,%edi
  sub    %edi,%edx
  mov    %edx,%edi
  xor    %edx,%r10d
  sar    $0x12,%edx
  shl    $0xe,%edi
  or     %edi,%edx
  sub    %edx,%r10d
  mov    %r10d,%edx
  mov    %r10d,%edi
  xor    %r10d,%eax
  shl    $0x18,%edx
  sar    $0x8,%edi
  or     %edi,%edx
  sub    %edx,%eax
  mov    %eax,(%rsi)
  mov    %r10d,(%rcx)
  ret
```

assistant: ```c
void my_hashword2(const uint32_t *k, size_t length, uint32_t *pc, uint32_t *pb) {
  uint32_t a, b, c;
  a = b = c = 0xdeadbeef + ((uint32_t)(length << 2)) + *pc;
  c += *pb;
  while (length > 3) {
    a += k[0];
    b += k[1];
    c += k[2];
    {
      a -= c;
      a ^= (((c) << (4)) | ((c) >> (32 - (4))));
      c += b;
      b -= a;
      b ^= (((a) << (6)) | ((a) >> (32 - (6))));
      a += c;
      c -= b;
      c ^= (((b) << (8)) | ((b) >> (32 - (8))));
      b += a;
      a -= c;
      a ^= (((c) << (16)) | ((c) >> (32 - (16))));
      c += b;
      b -= a;
      b ^= (((a) << (19)) | ((a) >> (32 - (19))));
      a += c;
      c -= b;
      c ^= (((b) << (4)) | ((b) >> (32 - (4))));
      b += a;
    };
    length -= 3;
    k += 3;
  }
  switch (length) {
  case 3:
    c += k[2];
  case 2:
    b += k[1];
  case 1:
    a += k[0];
    {
      c ^= b;
      c -= (((b) << (14)) | ((b) >> (32 - (14))));
      a ^= c;
      a -= (((c) << (11)) | ((c) >> (32 - (11))));
      b ^= a;
      b -= (((a) << (25)) | ((a) >> (32 - (25))));
      c ^= b;
      c -= (((b) << (16)) | ((b) >> (32 - (16))));
      a ^= c;
      a -= (((c) << (4)) | ((c) >> (32 - (4))));
      b ^= a;
      b -= (((a) << (14)) | ((a) >> (32 - (14))));
      c ^= b;
      c -= (((b) << (24)) | ((b) >> (32 - (24))));
    };
  case 0:
    break;
  }
  *pc = c;
  *pb = b;
}
```