user: Please show me the C implementation that matches the assembly code listed below:

```asm
<yc_poly_emulator>:
  endbr64
  test   %edx,%edx
  je     L211
  push   %r13
  lea    -0x1(%rdx),%eax
  mov    %rdi,%r8
  mov    %rsi,%r10
  push   %r12
  lea    0x1(%rsi,%rax,1),%r13
  lea    D6(%rip),%r9
  push   %rbp
  push   %rbx
  mov    %edx,%ebx
  add    %esi,%ebx
  nopl   0x0(%rax,%rax,1)
L120:
  mov    %ebx,%r11d
  mov    %r10d,%r12d
  movzbl (%r10),%edi
  xor    %edx,%edx
  sub    %r10d,%r11d
  sub    %ebx,%r12d
  mov    %r11d,%ebp
  and    $0x7,%ebp
  nopl   0x0(%rax,%rax,1)
L170:
  mov    %edx,%eax
  lea    0x1(%rdx),%esi
  movzbl (%r8,%rax,1),%eax
  cmp    $0x34,%al
  jg     L205
  cmp    $0xfe,%al
  jl     L181
  add    $0x2,%eax
  cmp    $0x36,%al
  ja     L205
  movzbl %al,%eax
  movslq (%r9,%rax,4),%rax
  add    %r9,%rax
  notrack jmp *%rax
  cs nopw 0x0(%rax,%rax,1)
L181:
  cmp    $0xd2,%al
  je     L150
  cmp    $0xeb,%al
  jne    L201
  mov    %esi,%eax
  movsbl (%r8,%rax,1),%eax
  lea    0x1(%rax,%rsi,1),%esi
  nopl   0x0(%rax,%rax,1)
L205:
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  nopw   0x0(%rax,%rax,1)
L124:
  mov    %dil,(%r10)
  add    $0x1,%r10
  cmp    %r13,%r10
  jne    L120
  pop    %rbx
  xor    %eax,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
  nopl   0x0(%rax)
  mov    %esi,%eax
  add    $0x1,%esi
  xor    (%r8,%rax,1),%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  cs nopw 0x0(%rax,%rax,1)
  mov    %esi,%eax
  add    $0x1,%esi
  add    (%r8,%rax,1),%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  cs nopw 0x0(%rax,%rax,1)
  add    $0x1,%esi
  add    %r11d,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  nopl   0x0(%rax,%rax,1)
  add    $0x1,%esi
  sub    $0x1,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  xchg   %ax,%ax
  mov    %esi,%eax
  add    $0x1,%esi
  sub    (%r8,%rax,1),%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  nopl   0x0(%rax)
  add    $0x1,%esi
  add    %r12d,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  cs nopw 0x0(%rax,%rax,1)
  add    $0x1,%esi
  xor    %r11d,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
L201:
  cmp    $0xc0,%al
  jne    L205
  lea    0x2(%rdx),%eax
  movzbl (%r8,%rax,1),%ecx
  mov    %rax,%rdx
  and    $0x7,%ecx
  cmpb   $0xc0,(%r8,%rsi,1)
  je     L19
L154:
  lea    0x1(%rdx),%esi
  ror    %cl,%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
  nopl   0x0(%rax)
L150:
  add    $0x2,%edx
  cmpb   $0xc8,(%r8,%rsi,1)
  mov    %ebp,%ecx
  je     L154
L19:
  lea    0x1(%rdx),%esi
  rol    %cl,%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L170
  jmp    L124
L211:
  xor    %eax,%eax
  ret
```

assistant: ```c
__attribute__((always_)) int yc_poly_emulator(char *decryptor_offset, char *code, unsigned int ecx) {
  unsigned char al;
  unsigned char cl = ecx & 0xff;
  unsigned int j, i;
  for (i = 0; i < ecx; i++) {
    al = code[i];
    for (j = 0; j < 0x30; j++) {
      switch (decryptor_offset[j]) {
      case '\xEB':
        j++;
        j = j + decryptor_offset[j];
        break;
      case '\xFE':
        al--;
        j++;
        break;
      case '\x2A':
        al = al - cl;
        j++;
        break;
      case '\x02':
        al = al + cl;
        j++;
        break;
      case '\x32':
        al = al ^ cl;
        j++;
        break;
        ;
      case '\x04':
        j++;
        al = al + decryptor_offset[j];
        break;
        ;
      case '\x34':
        j++;
        al = al ^ decryptor_offset[j];
        break;
      case '\x2C':
        j++;
        al = al - decryptor_offset[j];
        break;
      case '\xC0':
        j++;
        if (decryptor_offset[j] == '\xC0') {
          j++;
          al = (al << (decryptor_offset[j] % (sizeof(al) << 3))) | (al >> ((sizeof(al) << 3) - (decryptor_offset[j] % (sizeof(al) << 3))));
        } else {
          j++;
          al = (al >> (decryptor_offset[j] % (sizeof(al) << 3))) | (al << ((sizeof(al) << 3) - (decryptor_offset[j] % (sizeof(al) << 3))));
        }
        break;
      case '\xD2':
        j++;
        if (decryptor_offset[j] == '\xC8') {
          j++;
          al = (al >> (cl % (sizeof(al) << 3))) | (al << ((sizeof(al) << 3) - (cl % (sizeof(al) << 3))));
        } else {
          j++;
          al = (al << (cl % (sizeof(al) << 3))) | (al >> ((sizeof(al) << 3) - (cl % (sizeof(al) << 3))));
        }
        break;
      case '\x90':
      case '\xf8':
      case '\xf9':
        break;
      default:;
        break;
      }
    }
    cl--;
    code[i] = al;
  }
  return 0;
}
```