user: 这段汇编代码用C语言表示是什么样的?

```asm
<main>:
  endbr64
  push   %r15
  xor    %eax,%eax
  mov    %rsi,%r15
  mov    $0x50,%esi
  push   %r14
  lea    D15(%rip),%r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  movslq %edi,%rbx
  mov    %r14,%rdi
  sub    $0x28,%rsp
  call   <printf@plt>
  mov    %r14,%rdi
  imul   $0x34,%eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edi,%edi
  mov    $0x63,%esi
  mov    %eax,%r9d
  mov    0x8(%r15),%rax
  lea    0x2(%rax),%rdx
  mov    %rdx,(%r15,%rbx,8)
  mov    %r9b,0x2(%rax)
  nopl   (%rax)
L464:
  mov    0x8(%r15),%rax
  movb   $0x0,(%rax,%rsi,1)
  mov    (%r15),%rax
  movb   $0x0,(%rax)
  mov    (%r15),%rdx
  movsbl (%rdx),%eax
  cmp    $0x7,%al
  jg     L628
L750:
  mov    0x8(%r15),%rcx
  lea    0x63(%rdi,%rax,1),%eax
  cltq
  lea    (%rcx,%rsi,1),%rdx
  cmpb   $0x20,(%rcx,%rax,1)
  movzbl (%rdx),%eax
  sete   %cl
  lea    (%rcx,%rax,2),%eax
  mov    %al,(%rdx)
  mov    (%r15),%rax
  addb   $0x1,(%rax)
  mov    (%r15),%rdx
  movsbl (%rdx),%eax
  cmp    $0x7,%al
  jle    L750
L628:
  add    $0x1,%rsi
  add    $0x8,%edi
  cmp    $0x24e,%rsi
  jne    L464
  mov    0x10(%r15),%rax
  xor    %ecx,%ecx
  cmpb   $0x4b,(%rax)
  jne    L214
  lea    0x3(%rax),%rcx
  mov    %rcx,0x10(%r15)
  xor    %ecx,%ecx
  cmpb   $0x46,0x1(%rax)
  sete   %cl
L214:
  mov    %cl,0x4(%rdx)
  mov    0x8(%r15),%rdx
  xor    %ebx,%ebx
  mov    0x10(%r15),%rsi
  movq   $0x0,0x6(%rdx)
  movzbl (%rsi),%ecx
  test   %cl,%cl
  jne    L668
  jmp    L833
  nopw   0x0(%rax,%rax,1)
L348:
  addb   $0x1,0x2(%rdx)
  mov    0x10(%r15),%rax
  movl   $0x0,0xa(%rdx)
  movb   $0x0,(%rax)
  mov    0x8(%r15),%rdx
  mov    0xa(%rdx),%eax
L131:
  mov    0x6(%rdx),%ecx
  cmp    %eax,%ecx
  cmovl  %eax,%ecx
  mov    0x10(%r15),%rax
  add    $0x3,%ebx
  lea    0x3(%rax),%rsi
  mov    %ecx,0x6(%rdx)
  mov    %rsi,0x10(%r15)
  movzbl 0x3(%rax),%ecx
  test   %cl,%cl
  je     L833
L668:
  movzbl 0x1(%rsi),%eax
  test   %al,%al
  je     L833
  cmpb   $0x0,0x2(%rsi)
  je     L833
  cmp    $0x77,%cl
  jg     L348
  cmp    $0x3a,%cl
  je     L942
  cmp    $0x73,%cl
  je     L510
  mov    $0x1,%eax
  cmp    $0x40,%cl
  jle    L289
  xor    %eax,%eax
  cmp    $0x6d,%cl
  setne  %al
  add    $0x2,%eax
L289:
  add    0xa(%rdx),%eax
  mov    %eax,0xa(%rdx)
  jmp    L131
L942:
  movzbl 0x3(%rsi),%eax
  test   %al,%al
  setne  %cl
  cmp    $0x77,%al
  setle  %al
  movzbl %al,%eax
  and    %ecx,%eax
  add    $0x2,%eax
  jmp    L289
L510:
  sub    $0x30,%eax
  mov    %al,0x1(%rsi)
  movsbl %al,%eax
  mov    0x8(%r15),%rdx
  jmp    L289
L833:
  mov    0x18(%r15),%rax
  lea    D19(%rip),%rdi
  movslq %ebx,%rbx
  lea    0x1(%rax),%rcx
  mov    %rcx,0x18(%r15)
  movsbl (%rax),%eax
  lea    (%rax,%rax,4),%r9d
  mov    0x6(%rdx),%eax
  shl    $0x4,%r9d
  lea    0x38(,%rax,8),%esi
  mov    %r9d,%edx
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%r15),%rax
  movb   $0x0,(%rax)
  sub    %rbx,0x10(%r15)
L254:
  mov    0x18(%r15),%rax
  movb   $0x0,(%rax)
  mov    0x18(%r15),%rdx
  movzbl -0x1(%rdx),%eax
  lea    -0x1(%rax),%ecx
  mov    %cl,-0x1(%rdx)
  test   %al,%al
  je     L264
  mov    (%r15),%rax
  movb   $0x0,(%rax)
  mov    (%r15),%rax
  cmpb   $0x4f,(%rax)
  jg     L254
  nopw   0x0(%rax,%rax,1)
L810:
  mov    0x18(%r15),%rax
  movsbl (%rax),%edx
  lea    (%rdx,%rdx,2),%edx
  movslq %edx,%rdx
  sub    %rdx,0x10(%r15)
  lea    0x1(%rax),%rdx
  mov    %rdx,0x18(%r15)
  movb   $0x0,(%rax)
  mov    (%r15),%rax
  movzbl (%rax),%edx
  xor    %eax,%eax
  lea    -0x12(%rdx),%ecx
  cmp    $0x20,%cl
  ja     L570
  and    $0x7,%edx
  cmp    $0x2,%dl
  sete   %al
  neg    %eax
L570:
  mov    0x18(%r15),%rdx
  xor    %edi,%edi
  mov    %al,(%rdx)
  call   <putchar@plt>
  mov    0x18(%r15),%rax
  movsbl (%rax),%edi
  call   <putchar@plt>
  mov    (%r15),%rax
  movb   $0x0,0x1(%rax)
  mov    (%r15),%rdx
  movsbl 0x1(%rdx),%eax
  cmp    $0x2,%al
  jle    L678
  jmp    L775
  nopl   0x0(%rax)
L895:
  lea    -0x13(%rcx),%edx
  cmp    $0x16,%dl
  ja     L318
  add    $0x2a,%eax
  lea    (%rcx,%rcx,2),%edx
  movsbl %al,%eax
  add    %edx,%eax
  mov    0x8(%r15),%rdx
  cltq
  or     (%rdx,%rax,1),%sil
  movsbl %sil,%edi
L318:
  call   <putchar@plt>
  mov    (%r15),%rax
  addb   $0x1,0x1(%rax)
  mov    (%r15),%rdx
  movsbl 0x1(%rdx),%eax
  cmp    $0x2,%al
  jg     L775
L678:
  mov    0x18(%r15),%rcx
  cmpb   $0x0,0x4(%rdx)
  movsbl (%rcx),%edi
  movsbl (%rdx),%ecx
  mov    %edi,%esi
  jne    L895
  lea    -0xb(%rcx),%edx
  cmp    $0x34,%dl
  ja     L318
  lea    0x0(,%rcx,8),%edx
  sub    %ecx,%edx
  lea    0x61(%rdx,%rax,1),%eax
  mov    0x8(%r15),%rdx
  cltq
  movsbl (%rdx,%rax,1),%eax
  not    %eax
  or     %eax,%edi
  jmp    L318
  nopw   0x0(%rax,%rax,1)
L775:
  mov    0x18(%r15),%rax
  lea    0x1(%rax),%rdx
  mov    %rdx,0x18(%r15)
  movsbl (%rax),%edi
  call   <putchar@plt>
  mov    0x8(%r15),%rax
  movq   $0x0,0xa(%rax)
  mov    0x6(%rax),%eax
  test   %eax,%eax
  jle    L102
  mov    0x10(%r15),%rax
  jmp    L627
  nopl   0x0(%rax)
L466:
  cmp    $0x72,%cl
  jle    L938
  movsbl 0x1(%rsi),%ecx
  cmp    %edx,%ecx
  jg     L547
L250:
  addb   $0x1,0x3(%rax)
  mov    0x8(%r15),%rdx
  mov    0x10(%r15),%rax
  mov    0xa(%rdx),%ecx
  add    $0x3,%rax
  mov    %rax,0x10(%r15)
  mov    %ecx,0xe(%rdx)
  cmp    0x6(%rdx),%ecx
  jge    L102
L627:
  movzbl 0x1(%rax),%eax
  mov    (%r15),%rdx
  xor    %ecx,%ecx
  sub    $0x31,%eax
  mov    %al,0x2(%rdx)
  mov    (%r15),%rax
  mov    0x10(%r15),%rdx
  movsbl (%rax),%ebx
  movzbl 0x4(%rax),%eax
  add    %eax,%eax
  cmpb   $0x3f,(%rdx)
  setle  %cl
  movzbl (%rdx,%rcx,1),%edx
  mov    %edx,%ecx
  cmp    $0x62,%dl
  jg     L153
  lea    0x7(%rdx),%ecx
  cmp    $0x4c,%dl
  jg     L153
  sub    $0x12,%eax
  mov    $0x0,%esi
  sub    %ecx,%eax
  cmp    $0x43,%dl
  mov    $0x7,%edx
  cmovge %esi,%edx
L883:
  mov    0x18(%r15),%rcx
  add    $0x69,%eax
  sub    %edx,%eax
  mov    %al,(%rcx)
  movsbl %al,%eax
  shl    $0x2,%eax
  sub    %eax,%ebx
  mov    0x8(%r15),%rax
  lea    -0x6(%rbx),%r12d
  lea    -0x8(%rbx),%edx
  lea    0x11(%rbx),%r13d
  lea    0x0(,%r12,8),%ebp
  movl   $0x0,0x12(%rax)
  sub    %r12d,%ebp
  cmp    $0x15,%edx
  lea    (%r12,%r12,2),%esi
  setbe  %dl
  mov    %esi,0x8(%rsp)
  movzbl %dl,%edx
  shl    $0x5,%edx
  mov    %edx,0x10(%rsp)
  xor    %edx,%edx
  cmp    $0x17,%r13d
  setbe  %dl
  lea    0x0(,%rdx,8),%edi
  xor    %edx,%edx
  mov    %edi,0x14(%rsp)
  lea    0x190(%rbp),%edi
  mov    %edi,0x1c(%rsp)
  lea    0x90(%rbp),%edi
  mov    %edi,0x18(%rsp)
  lea    -0x2(%rbx),%edi
  mov    %edi,0xc(%rsp)
  nopw   0x0(%rax,%rax,1)
L68:
  mov    0x10(%r15),%rsi
  movzbl (%rsi),%ecx
  test   %cl,%cl
  jne    L466
  mov    0xe(%rax),%ecx
  test   %ecx,%ecx
  je     L1027
  mov    0x6(%rax),%edi
  sub    %ecx,%edi
  mov    %edi,%ecx
L1027:
  cmp    %edx,%ecx
  jle    L250
L547:
  movsbl 0x4(%rax),%r8d
L659:
  mov    %r8d,%esi
  mov    %r14,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %eax,%r8d
  mov    0x8(%r15),%rax
  mov    0x12(%rax),%esi
  add    %r8d,0xa(%rax)
  lea    0x1(%rsi),%edx
  mov    %edx,0x12(%rax)
  jmp    L68
  nopl   (%rax)
L938:
  xor    %r9d,%r9d
  cmp    $0x40,%cl
  mov    $0x1,%r8d
  setg   %r9b
  cmpb   $0x1,0x3(%rsi)
  sbb    $0xffffffff,%r8d
  xor    %edi,%edi
  cmp    $0x3a,%cl
  sete   %dil
  imul   %r8d,%edi
  xor    %r8d,%r8d
  cmp    $0x6d,%cl
  sete   %r8b
  lea    0x1(%rdi,%r9,2),%edi
  sub    %r8d,%edi
  cmp    %edx,%edi
  jle    L250
  movsbl 0x4(%rax),%r8d
  mov    %r8d,%edi
  cmp    $0x3a,%cl
  je     L371
  cmp    $0x3e,%cl
  jg     L470
  lea    0x2(%rbx),%edx
  cmp    $0xe,%edx
  ja     L659
  mov    $0x239,%edx
  cmp    $0x2c,%cl
  jle    L567
  xor    %edx,%edx
  cmp    $0x3c,%cl
  setg   %dl
  add    $0x23a,%edx
L567:
  add    0x8(%rsp),%edx
  movslq %edx,%rdx
  or     (%rax,%rdx,1),%dil
  movsbl %dil,%r8d
  jmp    L659
  nopl   (%rax)
L371:
  cmp    $0x1,%edx
  jne    L659
  mov    (%r15),%rax
  movzbl (%rax),%eax
  sub    $0x12,%eax
  cmp    $0x20,%al
  ja     L659
  movzbl 0x1(%rsi),%eax
  cmp    $0x3b,%al
  je     L280
  mov    %edi,%r8d
  or     $0x9,%edi
  or     $0x1,%r8d
  movsbl %dil,%edi
  cmp    $0x3a,%al
  movsbl %r8b,%r8d
  cmove  %edi,%r8d
  jmp    L659
  nopl   0x0(%rax,%rax,1)
L470:
  cmp    $0x6f,%cl
  jle    L996
  mov    (%r15),%rcx
  movsbl (%rcx),%esi
  movzbl 0x2(%rcx),%ecx
  lea    -0x1b(%rsi),%r9d
  cmp    $0x1,%r9b
  jbe    L561
  cmp    $0x1,%cl
  je     L7
  cmp    $0x1,%edx
  setle  %r10b
  cmp    $0x3,%cl
  je     L81
L809:
  cmp    $0x7,%cl
  sete   %r11b
  cmp    $0xe,%r9b
  setbe  %cl
  test   %cl,%r11b
  je     L659
  test   %r10b,%r10b
  je     L659
  lea    0x0(,%rsi,8),%ecx
  sub    %esi,%ecx
  lea    0x87(%rdx,%rcx,1),%edx
  movslq %edx,%rdx
  or     (%rax,%rdx,1),%dil
  movsbl %dil,%r8d
  jmp    L659
  xchg   %ax,%ax
L996:
  cmp    $0x6a,%cl
  jg     L863
  mov    (%r15),%r9
  cmpl   $0x8,0xc(%rsp)
  movzbl 0x2(%r9),%edi
  ja     L655
  cmp    $0x1,%edx
  jle    L663
  xor    %ecx,%ecx
  cmpb   $0x2e,0x2(%rsi)
  je     L634
L341:
  test   %dil,%dil
  je     L802
L442:
  cmp    $0x7,%dil
  jne    L61
  mov    0x18(%r15),%rsi
  cmpb   $0x7,(%rsi)
  jg     L329
  lea    -0x14(%rbx),%esi
  cmp    $0x8,%esi
  ja     L61
  cmp    $0x1,%edx
  jg     L61
  add    0x18(%rsp),%edx
  movslq %edx,%rdx
  movsbl (%rax,%rdx,1),%eax
  or     %eax,%ecx
  nopl   0x0(%rax,%rax,1)
L61:
  or     %ecx,%r8d
  jmp    L659
L153:
  sub    %ecx,%eax
  xor    %edx,%edx
  jmp    L883
  nopl   0x0(%rax)
L863:
  test   %edx,%edx
  jne    L659
  mov    (%r15),%rcx
  movsbl (%rcx),%edx
  lea    -0x16(%rdx),%r9d
  cmp    $0x9,%r9b
  ja     L74
  movsbl 0x2(%rcx),%esi
  lea    0x0(,%rdx,8),%ecx
  sub    %edx,%ecx
  lea    0x143(%rsi,%rcx,1),%edx
  movslq %edx,%rdx
  or     (%rax,%rdx,1),%dil
  movsbl %dil,%r8d
  jmp    L659
L561:
  test   %cl,%cl
  je     L853
  cmp    $0x1,%cl
  je     L659
  cmp    $0x1,%edx
  setle  %r10b
  cmp    $0x3,%cl
  jne    L809
L81:
  lea    -0x17(%rsi),%ecx
  cmp    $0x15,%cl
  ja     L659
  test   %r10b,%r10b
  je     L659
  lea    0x0(,%rsi,8),%ecx
  sub    %esi,%ecx
  lea    0x97(%rdx,%rcx,1),%edx
  movslq %edx,%rdx
  or     (%rax,%rdx,1),%dil
  movsbl %dil,%r8d
  jmp    L659
  nopw   0x0(%rax,%rax,1)
L7:
  sub    $0x20,%esi
  cmp    $0x1,%sil
  ja     L659
L853:
  cmp    $0x1,%edx
  jg     L659
  imul   $0xe1,%edx,%eax
  add    $0xf,%eax
  or     %eax,%r8d
  jmp    L659
  nop
L655:
  xor    %ecx,%ecx
  test   %dil,%dil
  jne    L587
L802:
  cmp    $0x1,%edx
  jg     L61
  jmp    L8
  nopl   (%rax)
L102:
  xor    %edi,%edi
  call   <putchar@plt>
  mov    (%r15),%rax
  subq   $0x2,0x18(%r15)
  addb   $0x1,(%rax)
  mov    (%r15),%rax
  cmpb   $0x4f,(%rax)
  jle    L810
  jmp    L254
L1040:
  lea    0xcd(%rdx,%rbp,1),%ecx
  movslq %ecx,%rcx
  movsbl (%rax,%rcx,1),%ecx
L587:
  test   %edx,%edx
  jne    L117
  mov    0x18(%r15),%rsi
  mov    0x10(%rsp),%r10d
  movzbl (%rsi),%esi
  or     %ecx,%r10d
  cmp    $0x8,%sil
  cmovl  %r10d,%ecx
L514:
  movzbl (%r9),%r9d
  cmp    $0x42,%r9b
  je     L806
L236:
  cmp    $0xc,%sil
  jle    L922
  mov    %ecx,%esi
  or     $0xff,%sil
  cmp    $0x3a,%r9b
  cmove  %esi,%ecx
L150:
  cmp    $0x7,%dil
  jne    L61
L329:
  test   %edx,%edx
  je     L61
  cmp    $0x8,%r13d
  ja     L61
  add    0x1c(%rsp),%edx
  movslq %edx,%rdx
  movsbl (%rax,%rdx,1),%eax
  or     %eax,%ecx
  jmp    L61
L74:
  lea    -0x26(%rdx),%ecx
  cmp    $0x9,%cl
  ja     L659
  lea    0x0(,%rdx,8),%ecx
  movsbl 0x2(%rsi),%esi
  sub    %edx,%ecx
  lea    0xa2(%rsi,%rcx,1),%edx
  movslq %edx,%rdx
  or     (%rax,%rdx,1),%dil
  movsbl %dil,%r8d
  jmp    L659
L280:
  or     $0x27,%edi
  movsbl %dil,%r8d
  jmp    L659
L663:
  cmp    $0x2,%dil
  jg     L1040
  lea    0xcf(%rdx,%rbp,1),%ecx
  movslq %ecx,%rcx
  movsbl (%rax,%rcx,1),%ecx
  test   %dil,%dil
  jne    L587
L8:
  mov    0x18(%r15),%rsi
  movzbl (%r9),%r9d
  movzbl (%rsi),%esi
  cmp    $0x42,%r9b
  jne    L236
L806:
  cmp    $0xe,%sil
  jle    L311
  or     $0xff,%cl
  jmp    L442
L922:
  cmp    $0xa,%r9b
  jne    L442
  cmp    $0x1,%sil
  mov    %ecx,%esi
  setle  %r9b
  or     $0xff,%sil
  test   %r9b,%r9b
  cmovne %esi,%ecx
  jmp    L442
L117:
  cmp    $0x1,%edx
  jg     L442
  mov    0x18(%r15),%rsi
  mov    0x14(%rsp),%r10d
  movzbl (%rsi),%esi
  or     %ecx,%r10d
  cmp    $0x7,%sil
  cmovg  %r10d,%ecx
  jmp    L514
L634:
  mov    $0x60,%ecx
  cmp    $0xfffffffe,%r12d
  je     L341
  mov    0x18(%r15),%rsi
  movzbl (%rsi),%esi
  mov    %esi,%r10d
  shr    $0x7,%r10b
  add    %r10d,%esi
  and    $0x1,%esi
  sub    %r10d,%esi
  movsbl %sil,%esi
  add    %esi,%esi
  not    %esi
  cmp    %r12d,%esi
  mov    $0x0,%esi
  cmovne %esi,%ecx
  jmp    L341
L311:
  cmp    $0xc,%sil
  jg     L150
  jmp    L442
L264:
  add    $0x28,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

tool_calls: name: parse_data
arguments: data_label: D15
data_type: string
name: parse_data
arguments: data_label: D19
data_type: string

tool: D15: %c

tool: D19:   %d          %d


assistant: ```c
main(int c, char *C[]) {
  (C[c] = C[1] + 2)[0] = printf("%c", 52 * printf("%c", 'C' + '4' / 4));
  for (c = 0; c < 491; ++c)
    for (**C = C[1]['c' + c] = 0; *C[0] < 8; (**C)++)
      C[1][c + 'c'] = *(C[1] + c + 'c') + C[1][99 + c] + (C[1][**C + 8 * c + 99] == 32);
  (*C)[4] = *C[2] == 75 ? *((C[2] += 3) - 2) == 70 ? 1 : 0 : 0;
  ((int *)(C[1] + 6))[0] = ((int *)(C[1] + 6))[1] = c = 0;
  while (*C[2] ? C[2][1] ? *(C[2] + 2) ? 1 : 0 : 0 : 0) {
    if (*C[2] > 'w') {
      ((int *)(C[1] + 6))[1] = 0;
      C[1][2]++;
      *C[2] = 0;
    } else
      ((int *)(C[1] + 6))[1] += *C[2] == 58 ? 2 + (C[2][3] && *(C[2] + 3) < 'x') : *C[2] == 's' ? (C[2][1] -= 48) : *C[2] >= 65 ? 3 - (*C[2] == 'm' ? 1 : 0) : 1;
    ((int *)(C[1] + 6))[0] = ((int *)(C[1] + 6))[1] > ((int *)(C[1] + 6))[0] ? ((int *)(C[1] + 6))[1] : ((int *)(C[1] + 6))[0];
    c += 3;
    *(C + 2) += 3;
  }
  printf("  %d          %d\n", 56 + 8 * ((int *)(C[1] + 6))[0], 80 * *(C[3]++));
  *C[2] = 0;
  C[2] -= c;
  *C[3] = 0;
  while (C[3][1, -1]--) {
    ;
    for (**C = 0; **C < 80; (**C)++) {
      C[2] -= 3 * *C[3];
      *C[3]++ = 0;
      *C[3] = **C >= 51 || **C < 18 || **C % 8 != 2 ? 0 : 255;
      printf("%c", 1 - 1);
      printf("%c", *C[3]);
      for ((*C)[1] = 0; (*C)[1] < 3; (*C)[1]++)
        printf("%c", *C[3] | ((*C)[4] ? **C > 18 && **C < 42 ? C[1][42 + *(*C + 1) + 3 * **C] : 0 : **C >= 11 && **C < 64 ? ~C[1][7 * **C + 97 + (*C)[1]] : 0));
      printf("%c", *C[3]++);
      for (((int *)(C[1] + 6))[1] = 0; (((int *)(C[1] + 6))[2] = ((int *)(C[1] + 6))[1]) < ((int *)(C[1] + 6))[0];) {
        (*C)[2] = C[2][1] - 49;
        c = (*C[2] <= 63);
        c = (*C)[0] - 4 * (C[3][0] = 105 - C[2][c] - 7 * (*(C[2] + c) < 'c') - 18 * (C[2][c] < 77) + 2 * (*C)[4] - 7 * (C[2][c] < 'C')) - 6;
        for (((int *)(C[1] + 6))[3] = 0; ((int *)(C[1] + 6))[3] < (*C[2] ? *C[2] > 'r' ? C[2][1] : (1 + 2 * (*C[2] > 64) + (2 - !C[2][3]) * (58 == (*(C + 2))[0]) - (C[2][0] == 'm')) : ((int *)(C[1] + 6))[2] ? ((int *)(C[1] + 6))[0] - ((int *)(C[1] + 6))[2] : 0); ((int *)(C[1] + 6))[3]++)
          ((int *)(C[1] + 6))[1] += printf("%c", C[1][4] | (*C[2] && *C[2] < 's' ? *C[2] == 58 ? ((int *)(C[1] + 6))[3] == 1 ? **C > 17 && **C < 51 ? C[2][1] == 59 ? 39 : C[2][1] == 58 ? 9 : 1 : 0 : 0 : 63 > *C[2] ? (c < 7 && c > -9 ? C[1][(*C[2] < 45 ? 'c' * 5 + 2 * '%' : *C[2] < 61 ? 570 : 571) + 3 * c] : 0) : *C[2] > 'o' ? **C > 26 && **C < 29 && !(*C)[2] || (*C)[2] == 1 && (&*C[0])[0] < 34 && 31 < **C ? ((int *)(C[1] + 6))[3] < 2 ? 15 + 225 * ((int *)(C[1] + 6))[3] : 0 : (*C)[2] == 3 ? ((int *)(C[1] + 6))[3] < 2 && **C > 22 && **C < 45 && ((int *)(C[1] + 6))[3] < 2 ? C[1][7 * *(*C) + 151 + ((int *)(C[1] + 6))[3]] : 0 : 7 == (*C)[2] && **C > 26 && **C < 42 && ((int *)(C[1] + 6))[3] < 2 ? C[1][7 * **C + 135 + ((int *)(C[1] + 6))[3]] : 0 : *C[2] < 'k' ? (c > -5 && c < 5 ? ((int *)(C[1] + 6))[3] < 2 ? C[1][((*C)[2] < 3 ? 207 : 205) + 7 * c + ((int *)(C[1] + 6))[3]] : C[2][2] == 46 && (c == -2 || c == -1 - 2 * (*C[3] % 2)) ? 96 : 0 : 0) | ((*C)[2] ? ((int *)(C[1] + 6))[3] ? ((int *)(C[1] + 6))[3] < 2 && *C[3] > 7 && c < 1 && c > -24 ? 8 : 0 : *C[3] < 8 && c > 1 && c < 24 ? ' ' : 0 : 0) | (((int *)(C[1] + 6))[3] < 2 && (**C == 66 && *C[3] > 14 || *C[3] > 12 && 58 == **C || *C[3] < 2 && **C == 10) ? 5 * 51 : 0) | (7 == (*C)[2] ? *C[3] < 8 ? c > 13 && c < 23 && ((int *)(C[1] + 6))[3] < 2 ? C[1][144 + 7 * c + ((int *)(C[1] + 6))[3]] : 0 : ((int *)(C[1] + 6))[3] && c < -14 && c > -24 ? C[1][7 * c + 400 + ((int *)(C[1] + 6))[3]] : 0 : 0) : !((int *)(C[1] + 6))[3] ? **C > 21 && C[0][0] < 32 ? C[1][(*C)[2] + 323 + 7 * **C] : 36 + 1 < **C && '0' > **C ? C[1][C[2][2] + 162 + 7 * **C] : 0 : 0 : 0));
        C[1][3]++;
        C[2] += 3;
      }
      printf("%c", 0);
      C[3] -= 2;
    }
    *C[3] = 0;
  }
}
```