user: 请将这段汇编代码片段转换成等效的C代码:

```asm
<_jenkins_little2_step>:
  endbr64
  mov    (%rdx),%r9d
  mov    0x4(%rdx),%ecx
  mov    %rdi,%rax
  mov    %rsi,%r8
  mov    %rdx,%rdi
  mov    0x8(%rdx),%edx
  cmp    $0xb,%rsi
  jbe    L0
L15:
  mov    0x4(%rax),%esi
  add    (%rax),%r9d
  add    0x10(%rax),%ecx
  add    0x20(%rax),%edx
  shl    $0x8,%esi
  add    %esi,%r9d
  mov    0x8(%rax),%esi
  shl    $0x10,%esi
  add    %r9d,%esi
  mov    0xc(%rax),%r9d
  shl    $0x18,%r9d
  add    %esi,%r9d
  mov    0x14(%rax),%esi
  shl    $0x8,%esi
  add    %ecx,%esi
  mov    0x18(%rax),%ecx
  shl    $0x10,%ecx
  add    %esi,%ecx
  mov    0x1c(%rax),%esi
  shl    $0x18,%esi
  add    %ecx,%esi
  mov    0x24(%rax),%ecx
  shl    $0x8,%ecx
  add    %edx,%ecx
  mov    0x28(%rax),%edx
  shl    $0x10,%edx
  add    %ecx,%edx
  mov    0x2c(%rax),%ecx
  shl    $0x18,%ecx
  add    %edx,%ecx
  mov    %ecx,%edx
  mov    %ecx,%r10d
  sub    %ecx,%r9d
  sar    $0x1c,%r10d
  shl    $0x4,%edx
  or     %r10d,%edx
  xor    %r9d,%edx
  lea    (%rsi,%rcx,1),%r9d
  mov    %edx,%r10d
  mov    %edx,%ecx
  sub    %edx,%esi
  sar    $0x1a,%r10d
  shl    $0x6,%ecx
  or     %r10d,%ecx
  xor    %esi,%ecx
  lea    (%rdx,%r9,1),%esi
  mov    %ecx,%r10d
  mov    %ecx,%edx
  sub    %ecx,%r9d
  shl    $0x8,%edx
  sar    $0x18,%r10d
  add    %esi,%ecx
  sub    $0xc,%r8
  or     %r10d,%edx
  add    $0x30,%rax
  xor    %r9d,%edx
  mov    %edx,%r9d
  mov    %edx,%r10d
  sub    %edx,%esi
  add    %ecx,%edx
  sar    $0x10,%r10d
  shl    $0x10,%r9d
  or     %r10d,%r9d
  xor    %esi,%r9d
  mov    %r9d,%esi
  mov    %r9d,%r10d
  sub    %r9d,%ecx
  add    %edx,%r9d
  sar    $0xd,%r10d
  shl    $0x13,%esi
  or     %r10d,%esi
  xor    %esi,%ecx
  mov    %ecx,%esi
  mov    %ecx,%r10d
  sub    %ecx,%edx
  add    %r9d,%ecx
  shl    $0x4,%esi
  sar    $0x1c,%r10d
  or     %r10d,%esi
  xor    %esi,%edx
  cmp    $0xb,%r8
  ja     L15
L0:
  lea    D5(%rip),%r10
  movslq (%r10,%r8,4),%rsi
  add    %r10,%rsi
  notrack jmp *%rsi
  cs nopw 0x0(%rax,%rax,1)
  mov    0x28(%rax),%esi
  shl    $0x10,%esi
  add    %esi,%edx
  mov    0x24(%rax),%esi
  shl    $0x8,%esi
  add    %esi,%edx
  add    0x20(%rax),%edx
  mov    0x1c(%rax),%esi
  shl    $0x18,%esi
  add    %esi,%ecx
  mov    0x18(%rax),%esi
  shl    $0x10,%esi
  add    %esi,%ecx
  mov    0x14(%rax),%esi
  shl    $0x8,%esi
  add    %esi,%ecx
  add    0x10(%rax),%ecx
  mov    0xc(%rax),%esi
  shl    $0x18,%esi
  add    %esi,%r9d
  mov    0x8(%rax),%esi
  shl    $0x10,%esi
  add    %esi,%r9d
  mov    0x4(%rax),%esi
  shl    $0x8,%esi
  add    %esi,%r9d
  add    (%rax),%r9d
  mov    %r9d,(%rdi)
  mov    %r8,%rax
  mov    %ecx,0x4(%rdi)
  mov    %edx,0x8(%rdi)
  ret
```

assistant: ```c
size_t _jenkins_little2_step(const void *key, size_t length, uint32_t st[3]) {
  uint32_t a = st[0], b = st[1], c = st[2];
  union {
    const void *ptr;
    size_t i;
  } u;
  u.ptr = key;
  if (0 && ((u.i & 0x3) == 0)) {
    const uint32_t *k = (const uint32_t *)key;
    while (length >= 12) {
      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 -= 12;
      k += 3;
    }
    switch (length) {
    case 12:
      c += k[2];
      b += k[1];
      a += k[0];
      break;
    case 11:
      c += k[2] & 0xffffff;
      b += k[1];
      a += k[0];
      break;
    case 10:
      c += k[2] & 0xffff;
      b += k[1];
      a += k[0];
      break;
    case 9:
      c += k[2] & 0xff;
      b += k[1];
      a += k[0];
      break;
    case 8:
      b += k[1];
      a += k[0];
      break;
    case 7:
      b += k[1] & 0xffffff;
      a += k[0];
      break;
    case 6:
      b += k[1] & 0xffff;
      a += k[0];
      break;
    case 5:
      b += k[1] & 0xff;
      a += k[0];
      break;
    case 4:
      a += k[0];
      break;
    case 3:
      a += k[0] & 0xffffff;
      break;
    case 2:
      a += k[0] & 0xffff;
      break;
    case 1:
      a += k[0] & 0xff;
      break;
    }
  } else if (0 && ((u.i & 0x1) == 0)) {
    const uint16_t *k = (const uint16_t *)key;
    const uint8_t *k8;
    while (length >= 12) {
      a += k[0] + (((uint32_t)k[1]) << 16);
      b += k[2] + (((uint32_t)k[3]) << 16);
      c += k[4] + (((uint32_t)k[5]) << 16);
      {
        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 -= 12;
      k += 6;
    }
    k8 = (const uint8_t *)k;
    switch (length) {
    case 12:
      c += k[4] + (((uint32_t)k[5]) << 16);
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 11:
      c += ((uint32_t)k8[10]) << 16;
    case 10:
      c += k[4];
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 9:
      c += k8[8];
    case 8:
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 7:
      b += ((uint32_t)k8[6]) << 16;
    case 6:
      b += k[2];
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 5:
      b += k8[4];
    case 4:
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 3:
      a += ((uint32_t)k8[2]) << 16;
    case 2:
      a += k[0];
      break;
    case 1:
      a += k8[0];
      break;
    }
  } else {
    const uint8_t *k = (const uint8_t *)key;
    while (length >= 12) {
      a += k[0];
      a += ((uint32_t)k[1]) << 8;
      a += ((uint32_t)k[2]) << 16;
      a += ((uint32_t)k[3]) << 24;
      b += k[4];
      b += ((uint32_t)k[5]) << 8;
      b += ((uint32_t)k[6]) << 16;
      b += ((uint32_t)k[7]) << 24;
      c += k[8];
      c += ((uint32_t)k[9]) << 8;
      c += ((uint32_t)k[10]) << 16;
      c += ((uint32_t)k[11]) << 24;
      {
        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 -= 12;
      k += 12;
    }
    switch (length) {
    case 12:
      c += ((uint32_t)k[11]) << 24;
    case 11:
      c += ((uint32_t)k[10]) << 16;
    case 10:
      c += ((uint32_t)k[9]) << 8;
    case 9:
      c += k[8];
    case 8:
      b += ((uint32_t)k[7]) << 24;
    case 7:
      b += ((uint32_t)k[6]) << 16;
    case 6:
      b += ((uint32_t)k[5]) << 8;
    case 5:
      b += k[4];
    case 4:
      a += ((uint32_t)k[3]) << 24;
    case 3:
      a += ((uint32_t)k[2]) << 16;
    case 2:
      a += ((uint32_t)k[1]) << 8;
    case 1:
      a += k[0];
      break;
    }
  }
  st[0] = a;
  st[1] = b;
  st[2] = c;
  return length;
}
```