user: What would the C source look like for the assembly code provided here?

```asm
<yc_poly_emulator>:
  endbr64
  test   %edx,%edx
  je     L92
  push   %r13
  lea    -0x1(%rdx),%eax
  mov    %rdi,%r8
  mov    %rsi,%r10
  push   %r12
  lea    0x1(%rsi,%rax,1),%r13
  lea    D0(%rip),%r9
  push   %rbp
  push   %rbx
  mov    %edx,%ebx
  add    %esi,%ebx
  nopl   0x0(%rax,%rax,1)
L173:
  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)
L194:
  mov    %edx,%eax
  lea    0x1(%rdx),%esi
  movzbl (%r8,%rax,1),%eax
  cmp    $0x34,%al
  jg     L29
  cmp    $0xfe,%al
  jl     L1
  add    $0x2,%eax
  cmp    $0x36,%al
  ja     L29
  movzbl %al,%eax
  movslq (%r9,%rax,4),%rax
  add    %r9,%rax
  notrack jmp *%rax
  cs nopw 0x0(%rax,%rax,1)
L1:
  cmp    $0xd2,%al
  je     L273
  cmp    $0xeb,%al
  jne    L201
  mov    %esi,%eax
  movsbl (%r8,%rax,1),%eax
  lea    0x1(%rax,%rsi,1),%esi
  nopl   0x0(%rax,%rax,1)
L29:
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  nopw   0x0(%rax,%rax,1)
L63:
  mov    %dil,(%r10)
  add    $0x1,%r10
  cmp    %r10,%r13
  jne    L173
  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    L194
  jmp    L63
  cs nopw 0x0(%rax,%rax,1)
  mov    %esi,%eax
  add    $0x1,%esi
  add    (%r8,%rax,1),%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
  cs nopw 0x0(%rax,%rax,1)
  add    $0x1,%esi
  add    %r11d,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
  nopl   0x0(%rax,%rax,1)
  add    $0x1,%esi
  sub    $0x1,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
  xchg   %ax,%ax
  mov    %esi,%eax
  add    $0x1,%esi
  sub    (%r8,%rax,1),%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
  nopl   0x0(%rax)
  add    $0x1,%esi
  add    %r12d,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
  cs nopw 0x0(%rax,%rax,1)
  add    $0x1,%esi
  xor    %r11d,%edi
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
L201:
  cmp    $0xc0,%al
  jne    L29
  lea    0x2(%rdx),%eax
  movzbl (%r8,%rax,1),%ecx
  mov    %rax,%rdx
  and    $0x7,%ecx
  cmpb   $0xc0,(%r8,%rsi,1)
  je     L52
L147:
  lea    0x1(%rdx),%esi
  ror    %cl,%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
  nopl   0x0(%rax)
L273:
  add    $0x2,%edx
  cmpb   $0xc8,(%r8,%rsi,1)
  mov    %ebp,%ecx
  je     L147
L52:
  lea    0x1(%rdx),%esi
  rol    %cl,%dil
  mov    %esi,%edx
  cmp    $0x2f,%esi
  jbe    L194
  jmp    L63
L92:
  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;
}
```