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

```asm
<main>:
  endbr64
  push   %r15
  xor    %eax,%eax
  mov    %rsi,%r15
  mov    $0x50,%esi
  push   %r14
  lea    D4(%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)
L857:
  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     L224
L92:
  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    L92
L224:
  add    $0x1,%rsi
  add    $0x8,%edi
  cmp    $0x24e,%rsi
  jne    L857
  mov    0x10(%r15),%rax
  xor    %ecx,%ecx
  cmpb   $0x4b,(%rax)
  jne    L773
  lea    0x3(%rax),%rcx
  mov    %rcx,0x10(%r15)
  xor    %ecx,%ecx
  cmpb   $0x46,0x1(%rax)
  sete   %cl
L773:
  mov    %cl,0x4(%rdx)
  mov    0x8(%r15),%rdx
  xor    %edi,%edi
  xor    %ebx,%ebx
  mov    0x10(%r15),%rcx
  movq   $0x0,0x6(%rdx)
  movzbl (%rcx),%esi
  test   %sil,%sil
  jne    L883
  jmp    L590
  nopl   (%rax)
L254:
  addb   $0x1,0x2(%rdx)
  mov    0x10(%r15),%rax
  movl   $0x0,0xa(%rdx)
  movb   $0x0,(%rax)
  mov    0x8(%r15),%rdx
  mov    0x10(%r15),%rsi
  mov    0xa(%rdx),%edi
L124:
  mov    0x6(%rdx),%eax
  lea    0x3(%rsi),%rcx
  cmp    %edi,%eax
  cmovl  %edi,%eax
  add    $0x3,%ebx
  mov    %eax,0x6(%rdx)
  mov    %rcx,0x10(%r15)
  movzbl 0x3(%rsi),%esi
  test   %sil,%sil
  je     L590
L883:
  movzbl 0x1(%rcx),%eax
  test   %al,%al
  je     L590
  cmpb   $0x0,0x2(%rcx)
  je     L590
  cmp    $0x77,%sil
  jg     L254
  cmp    $0x3a,%sil
  je     L401
  cmp    $0x73,%sil
  je     L844
  mov    $0x1,%eax
  cmp    $0x40,%sil
  jle    L269
  xor    %eax,%eax
  cmp    $0x6d,%sil
  setne  %al
  add    $0x2,%eax
L269:
  add    %eax,%edi
  mov    %rcx,%rsi
  mov    %edi,0xa(%rdx)
  jmp    L124
L401:
  movzbl 0x3(%rcx),%eax
  test   %al,%al
  setne  %sil
  cmp    $0x77,%al
  setle  %al
  movzbl %al,%eax
  and    %esi,%eax
  add    $0x2,%eax
  jmp    L269
L844:
  sub    $0x30,%eax
  mov    %al,0x1(%rcx)
  mov    0x8(%r15),%rdx
  movsbl %al,%eax
  mov    0x10(%r15),%rcx
  mov    0xa(%rdx),%edi
  jmp    L269
L590:
  mov    0x18(%r15),%rax
  lea    D6(%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)
L596:
  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     L156
  mov    (%r15),%rax
  movb   $0x0,(%rax)
  mov    (%r15),%rax
  cmpb   $0x4f,(%rax)
  jg     L596
  nopw   0x0(%rax,%rax,1)
L666:
  mov    0x18(%r15),%rdx
  movdqu 0x10(%r15),%xmm1
  movsbl (%rdx),%eax
  lea    (%rax,%rax,2),%eax
  cltq
  neg    %rax
  movq   %rax,%xmm0
  movhps D11(%rip),%xmm0
  paddq  %xmm1,%xmm0
  movups %xmm0,0x10(%r15)
  movb   $0x0,(%rdx)
  mov    (%r15),%rax
  movzbl (%rax),%edx
  xor    %eax,%eax
  lea    -0x12(%rdx),%ecx
  cmp    $0x20,%cl
  ja     L886
  and    $0x7,%edx
  cmp    $0x2,%dl
  sete   %al
  neg    %eax
L886:
  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    L677
  jmp    L871
  nopl   (%rax)
L149:
  lea    -0x13(%rcx),%edx
  cmp    $0x16,%dl
  ja     L845
  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
L845:
  call   <putchar@plt>
  mov    (%r15),%rax
  addb   $0x1,0x1(%rax)
  mov    (%r15),%rdx
  movsbl 0x1(%rdx),%eax
  cmp    $0x2,%al
  jg     L871
L677:
  mov    0x18(%r15),%rcx
  cmpb   $0x0,0x4(%rdx)
  movsbl (%rcx),%edi
  movsbl (%rdx),%ecx
  mov    %edi,%esi
  jne    L149
  lea    -0xb(%rcx),%edx
  cmp    $0x34,%dl
  ja     L845
  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    L845
  nopw   0x0(%rax,%rax,1)
L871:
  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    L852
  mov    0x10(%r15),%rax
  jmp    L268
  nopl   0x0(%rax)
L566:
  cmp    $0x72,%cl
  jle    L684
  movsbl 0x1(%rsi),%ecx
  cmp    %edx,%ecx
  jg     L528
L161:
  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    L852
L268:
  movzbl 0x1(%rax),%eax
  mov    (%r15),%rdx
  xor    %esi,%esi
  sub    $0x31,%eax
  mov    %al,0x2(%rdx)
  mov    (%r15),%rax
  mov    0x10(%r15),%rdx
  movsbl (%rax),%ecx
  movzbl 0x4(%rax),%eax
  add    %eax,%eax
  cmpb   $0x3f,(%rdx)
  setle  %sil
  movzbl (%rdx,%rsi,1),%edx
  mov    %edx,%esi
  cmp    $0x62,%dl
  jg     L488
  lea    0x7(%rdx),%esi
  cmp    $0x4c,%dl
  jg     L488
  sub    $0x12,%eax
  mov    $0x0,%ebx
  sub    %esi,%eax
  cmp    $0x43,%dl
  mov    $0x7,%edx
  cmovge %ebx,%edx
L988:
  mov    0x18(%r15),%rsi
  add    $0x69,%eax
  sub    %edx,%eax
  mov    %al,(%rsi)
  movsbl %al,%eax
  shl    $0x2,%eax
  sub    %eax,%ecx
  mov    0x8(%r15),%rax
  lea    -0x6(%rcx),%ebp
  lea    -0x2(%rcx),%ebx
  lea    -0x8(%rcx),%edx
  mov    %ebx,0x8(%rsp)
  lea    0x11(%rcx),%r13d
  lea    -0x14(%rcx),%edi
  movl   $0x0,0x12(%rax)
  lea    0x0(,%rbp,8),%ebx
  sub    %ebp,%ebx
  cmp    $0x15,%edx
  mov    %edi,0x10(%rsp)
  lea    0x2(%rcx),%r12d
  setbe  %dl
  movzbl %dl,%edx
  shl    $0x5,%edx
  mov    %edx,0xc(%rsp)
  xor    %edx,%edx
  cmp    $0x17,%r13d
  setbe  %dl
  lea    0x0(,%rdx,8),%esi
  xor    %edx,%edx
  mov    %esi,0x14(%rsp)
  lea    0x190(%rbx),%esi
  mov    %esi,0x1c(%rsp)
  lea    0x90(%rbx),%esi
  mov    %esi,0x18(%rsp)
  lea    0x0(%rbp,%rbp,2),%esi
  mov    %esi,0x4(%rsp)
  nopl   0x0(%rax,%rax,1)
L914:
  mov    0x10(%r15),%rsi
  movzbl (%rsi),%ecx
  test   %cl,%cl
  jne    L566
  mov    0xe(%rax),%ecx
  test   %ecx,%ecx
  je     L62
  mov    0x6(%rax),%esi
  sub    %ecx,%esi
  mov    %esi,%ecx
L62:
  cmp    %edx,%ecx
  jle    L161
L528:
  movsbl 0x4(%rax),%r8d
L727:
  mov    %r8d,%esi
  mov    %r14,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %eax,%r8d
  mov    0x8(%r15),%rax
  mov    0x12(%rax),%edi
  add    %r8d,0xa(%rax)
  lea    0x1(%rdi),%edx
  mov    %edx,0x12(%rax)
  jmp    L914
  nopl   (%rax)
L684:
  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    L161
  movsbl 0x4(%rax),%r8d
  mov    %r8d,%edi
  cmp    $0x3a,%cl
  je     L141
  cmp    $0x3e,%cl
  jg     L993
  cmp    $0xe,%r12d
  ja     L727
  mov    $0x239,%edx
  cmp    $0x2c,%cl
  jle    L497
  xor    %edx,%edx
  cmp    $0x3c,%cl
  setg   %dl
  add    $0x23a,%edx
L497:
  add    0x4(%rsp),%edx
  movslq %edx,%rdx
  or     (%rax,%rdx,1),%dil
  movsbl %dil,%r8d
  jmp    L727
  nopl   0x0(%rax,%rax,1)
L141:
  cmp    $0x1,%edx
  jne    L727
  mov    (%r15),%rax
  movzbl (%rax),%eax
  sub    $0x12,%eax
  cmp    $0x20,%al
  ja     L727
  movzbl 0x1(%rsi),%eax
  cmp    $0x3b,%al
  je     L432
  mov    %edi,%r8d
  or     $0x9,%edi
  or     $0x1,%r8d
  movsbl %dil,%edi
  cmp    $0x3a,%al
  movsbl %r8b,%r8d
  cmove  %edi,%r8d
  jmp    L727
  nopl   0x0(%rax,%rax,1)
L993:
  cmp    $0x6f,%cl
  jle    L659
  mov    (%r15),%rcx
  movsbl (%rcx),%esi
  movzbl 0x2(%rcx),%ecx
  lea    -0x1b(%rsi),%r9d
  cmp    $0x1,%r9b
  jbe    L154
  cmp    $0x1,%cl
  je     L189
  cmp    $0x1,%edx
  setle  %r10b
  cmp    $0x3,%cl
  je     L882
L289:
  cmp    $0x7,%cl
  sete   %r11b
  cmp    $0xe,%r9b
  setbe  %cl
  test   %cl,%r11b
  je     L727
  test   %r10b,%r10b
  je     L727
  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    L727
  cs nopw 0x0(%rax,%rax,1)
L659:
  cmp    $0x6a,%cl
  jg     L60
  mov    (%r15),%r9
  cmpl   $0x8,0x8(%rsp)
  movzbl 0x2(%r9),%edi
  ja     L625
  cmp    $0x1,%edx
  jle    L1005
  xor    %ecx,%ecx
  cmpb   $0x2e,0x2(%rsi)
  je     L52
L587:
  test   %dil,%dil
  je     L965
L679:
  cmp    $0x7,%dil
  jne    L352
  mov    0x18(%r15),%rsi
  cmpb   $0x7,(%rsi)
  jg     L132
  cmpl   $0x8,0x10(%rsp)
  ja     L352
  cmp    $0x1,%edx
  jg     L352
  add    0x18(%rsp),%edx
  movslq %edx,%rdx
  movsbl (%rax,%rdx,1),%eax
  or     %eax,%ecx
  nopw   0x0(%rax,%rax,1)
L352:
  or     %ecx,%r8d
  jmp    L727
L488:
  sub    %esi,%eax
  xor    %edx,%edx
  jmp    L988
  nopl   0x0(%rax)
L60:
  test   %edx,%edx
  jne    L727
  mov    (%r15),%rcx
  movsbl (%rcx),%edx
  lea    -0x16(%rdx),%r9d
  cmp    $0x9,%r9b
  ja     L209
  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    L727
L154:
  test   %cl,%cl
  je     L937
  cmp    $0x1,%cl
  je     L727
  cmp    $0x1,%edx
  setle  %r10b
  cmp    $0x3,%cl
  jne    L289
L882:
  lea    -0x17(%rsi),%ecx
  cmp    $0x15,%cl
  ja     L727
  test   %r10b,%r10b
  je     L727
  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    L727
  nopw   0x0(%rax,%rax,1)
L189:
  sub    $0x20,%esi
  cmp    $0x1,%sil
  ja     L727
L937:
  cmp    $0x1,%edx
  jg     L727
  imul   $0xe1,%edx,%eax
  add    $0xf,%eax
  or     %eax,%r8d
  jmp    L727
  nop
L625:
  xor    %ecx,%ecx
  test   %dil,%dil
  jne    L728
L965:
  cmp    $0x1,%edx
  jg     L352
  jmp    L821
  nopl   (%rax)
L852:
  xor    %edi,%edi
  call   <putchar@plt>
  mov    (%r15),%rax
  subq   $0x2,0x18(%r15)
  addb   $0x1,(%rax)
  mov    (%r15),%rax
  cmpb   $0x4f,(%rax)
  jle    L666
  jmp    L596
L55:
  lea    0xcd(%rdx,%rbx,1),%ecx
  movslq %ecx,%rcx
  movsbl (%rax,%rcx,1),%ecx
L728:
  test   %edx,%edx
  jne    L672
  mov    0x18(%r15),%rsi
  mov    0xc(%rsp),%r10d
  movzbl (%rsi),%esi
  or     %ecx,%r10d
  cmp    $0x8,%sil
  cmovl  %r10d,%ecx
L829:
  movzbl (%r9),%r9d
  cmp    $0x42,%r9b
  je     L718
L27:
  cmp    $0xc,%sil
  jle    L358
  mov    %ecx,%esi
  or     $0xff,%sil
  cmp    $0x3a,%r9b
  cmove  %esi,%ecx
L480:
  cmp    $0x7,%dil
  jne    L352
L132:
  test   %edx,%edx
  je     L352
  cmp    $0x8,%r13d
  ja     L352
  add    0x1c(%rsp),%edx
  movslq %edx,%rdx
  movsbl (%rax,%rdx,1),%eax
  or     %eax,%ecx
  jmp    L352
L209:
  lea    -0x26(%rdx),%ecx
  cmp    $0x9,%cl
  ja     L727
  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    L727
L432:
  or     $0x27,%edi
  movsbl %dil,%r8d
  jmp    L727
L1005:
  cmp    $0x2,%dil
  jg     L55
  lea    0xcf(%rdx,%rbx,1),%ecx
  movslq %ecx,%rcx
  movsbl (%rax,%rcx,1),%ecx
  test   %dil,%dil
  jne    L728
L821:
  mov    0x18(%r15),%rsi
  movzbl (%r9),%r9d
  movzbl (%rsi),%esi
  cmp    $0x42,%r9b
  jne    L27
L718:
  cmp    $0xe,%sil
  jle    L579
  or     $0xff,%cl
  jmp    L679
L358:
  cmp    $0xa,%r9b
  jne    L679
  cmp    $0x1,%sil
  mov    %ecx,%esi
  setle  %r9b
  or     $0xff,%sil
  test   %r9b,%r9b
  cmovne %esi,%ecx
  jmp    L679
L672:
  cmp    $0x1,%edx
  jg     L679
  mov    0x18(%r15),%rsi
  mov    0x14(%rsp),%r10d
  movzbl (%rsi),%esi
  or     %ecx,%r10d
  cmp    $0x7,%sil
  cmovg  %r10d,%ecx
  jmp    L829
L52:
  mov    $0x60,%ecx
  cmp    $0xfffffffe,%ebp
  je     L587
  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    %ebp,%esi
  mov    $0x0,%esi
  cmovne %esi,%ecx
  jmp    L587
L579:
  cmp    $0xc,%sil
  jg     L480
  jmp    L679
L156:
  add    $0x28,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

tool_calls: name: disassemble_data
arguments: label: D4
type: string
name: disassemble_data
arguments: label: D6
type: string
name: disassemble_data
arguments: label: D11
type: byte[8]

tool: D4: %c

tool: D6:   %d          %d


tool: {"D11": [0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00]}

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;
  }
}
```