user: Converte this assembly snippet into its equivalent C code:

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0xc000(%rsp),%r11
L622:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L622
  sub    $0x838,%rsp
  lea    D163(%rip),%rdi
  mov    %fs:0x28,%rax
  mov    %rax,0xc828(%rsp)
  xor    %eax,%eax
  lea    0xa020(%rsp),%rbp
  call   <puts@plt>
  movl   $0x7b,0x14(%rsp)
  xor    %edx,%edx
  nop
L414:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L414
  movb   $0xa5,0xa021(%rsp)
  lea    0xc820(%rsp),%r13
  mov    %rbp,%rax
  xor    %edx,%edx
  nopl   (%rax)
L159:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L159
  lea    D145(%rip),%r12
  mov    $0x1,%esi
  xor    %eax,%eax
  mov    %r12,%rdi
  call   <printf@plt>
  xor    %edx,%edx
  cs nopw 0x0(%rax,%rax,1)
L432:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L432
  mov    $0xffffa5a5,%eax
  xor    %edx,%edx
  mov    %ax,0xa022(%rsp)
  mov    %rbp,%rax
  nopw   0x0(%rax,%rax,1)
L136:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L136
  mov    $0x2,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L1118:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L1118
  movb   $0xa5,0xa025(%rsp)
  mov    $0xffffa5a5,%eax
  xor    %edx,%edx
  mov    %ax,0xa023(%rsp)
  mov    %rbp,%rax
  nopw   0x0(%rax,%rax,1)
L420:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L420
  mov    $0x3,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L716:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L716
  movl   $0xa5a5a5a5,0xa024(%rsp)
  mov    %rbp,%rax
  xor    %edx,%edx
  nopl   0x0(%rax,%rax,1)
L670:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L670
  mov    $0x4,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L1055:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L1055
  movl   $0xa5a5a5a5,0xa025(%rsp)
  mov    %rbp,%rax
  xor    %edx,%edx
  movb   $0xa5,0xa029(%rsp)
L14:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L14
  mov    $0x5,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L788:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L788
  movl   $0xa5a5a5a5,0xa026(%rsp)
  mov    $0xffffa5a5,%eax
  xor    %edx,%edx
  mov    %ax,0xa02a(%rsp)
  mov    %rbp,%rax
  nopl   (%rax)
L612:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L612
  mov    $0x6,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L948:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L948
  mov    $0xffffa5a5,%r15d
  movb   $0xa5,0xa02d(%rsp)
  mov    %rbp,%rax
  xor    %edx,%edx
  movl   $0xa5a5a5a5,0xa027(%rsp)
  mov    %r15w,0xa02b(%rsp)
  nop
L644:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L644
  mov    $0x7,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L532:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L532
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  xor    %edx,%edx
  mov    %rax,0xa028(%rsp)
  mov    %rbp,%rax
  nop
L791:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L791
  mov    $0x8,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L344:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L344
  movb   $0xa5,0xa031(%rsp)
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rax,0xa029(%rsp)
  mov    %rbp,%rax
  nopw   0x0(%rax,%rax,1)
L782:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L782
  mov    $0x9,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L112:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L112
  mov    $0xffffa5a5,%r14d
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %r14w,0xa032(%rsp)
  mov    %rax,0xa02a(%rsp)
  mov    %rbp,%rax
  xchg   %ax,%ax
L869:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L869
  mov    $0xa,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L606:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L606
  movdqa D75(%rip),%xmm0
  mov    %rbp,%rax
  xor    %edx,%edx
  movaps %xmm0,0xa030(%rsp)
  nopl   (%rax)
L313:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L313
  mov    $0x10,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L402:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L402
  movdqa D75(%rip),%xmm0
  mov    %rbp,%rax
  xor    %edx,%edx
  movups %xmm0,0xa02f(%rsp)
  movups %xmm0,0xa03f(%rsp)
  nopl   (%rax)
L79:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L79
  mov    $0x20,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L750:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L750
  movdqa D75(%rip),%xmm0
  mov    %rbp,%rax
  xor    %edx,%edx
  movups %xmm0,0xa02d(%rsp)
  movups %xmm0,0xa03d(%rsp)
  movups %xmm0,0xa04d(%rsp)
  movups %xmm0,0xa05d(%rsp)
  nopl   (%rax)
L824:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L824
  mov    $0x40,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L563:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L563
  movdqa D75(%rip),%xmm0
  mov    %rbp,%rax
  xor    %edx,%edx
  movups %xmm0,0xa029(%rsp)
  movups %xmm0,0xa039(%rsp)
  movups %xmm0,0xa049(%rsp)
  movups %xmm0,0xa059(%rsp)
  movups %xmm0,0xa069(%rsp)
  movups %xmm0,0xa079(%rsp)
  movups %xmm0,0xa089(%rsp)
  movups %xmm0,0xa099(%rsp)
  nopl   (%rax)
L551:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L551
  mov    $0x80,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L32:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L32
  movdqa D75(%rip),%xmm0
  mov    %rbp,%rax
  xor    %edx,%edx
  movups %xmm0,0xa021(%rsp)
  movups %xmm0,0xa031(%rsp)
  movups %xmm0,0xa041(%rsp)
  movups %xmm0,0xa051(%rsp)
  movups %xmm0,0xa061(%rsp)
  movups %xmm0,0xa071(%rsp)
  movups %xmm0,0xa081(%rsp)
  movups %xmm0,0xa091(%rsp)
  movups %xmm0,0xa0a1(%rsp)
  movups %xmm0,0xa0b1(%rsp)
  movups %xmm0,0xa0c1(%rsp)
  movups %xmm0,0xa0d1(%rsp)
  movups %xmm0,0xa0e1(%rsp)
  movups %xmm0,0xa0f1(%rsp)
  movups %xmm0,0xa101(%rsp)
  movups %xmm0,0xa111(%rsp)
  nopl   (%rax)
L1013:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L1013
  mov    $0x100,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L392:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L392
  lea    0xa028(%rsp),%rdi
  mov    $0x3f,%ecx
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rax,0xa022(%rsp)
  mov    %rax,0xa21a(%rsp)
  rep stos %rax,%es:(%rdi)
  mov    %rbp,%rax
  nopw   0x0(%rax,%rax,1)
L107:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L107
  mov    $0x200,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edx,%edx
  nop
L312:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L312
  lea    0xa028(%rsp),%rdi
  mov    $0x7f,%ecx
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rax,0xa024(%rsp)
  mov    %rax,0xa41c(%rsp)
  rep stos %rax,%es:(%rdi)
  mov    %rbp,%rax
  nopw   0x0(%rax,%rax,1)
L75:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L75
  mov    $0x400,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0xa,%r14d
  call   <printf@plt>
  mov    $0xf0f0f0f1,%ebx
L545:
  mov    %r14d,%esi
  xor    %edx,%edx
  nopl   (%rax)
L956:
  mov    0x14(%rsp),%eax
  imul   %edx,%eax
  mov    %al,0x0(%rbp,%rdx,1)
  add    $0x1,%rdx
  cmp    $0x2800,%rdx
  jne    L956
  mov    %esi,%eax
  mov    %r14d,%ecx
  imul   %rbx,%rax
  shr    $0x24,%rax
  mov    %eax,%edx
  shl    $0x4,%edx
  add    %edx,%eax
  mov    %esi,%edx
  sub    %eax,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  movslq %edx,%rdx
  add    %rbp,%rdx
  lea    0x8(%rdx),%rdi
  mov    %rax,(%rdx)
  and    $0xfffffffffffffff8,%rdi
  mov    %rax,-0x8(%rdx,%rcx,1)
  sub    %rdi,%rdx
  lea    (%r14,%rdx,1),%ecx
  xor    %edx,%edx
  shr    $0x3,%ecx
  rep stos %rax,%es:(%rdi)
  mov    %rbp,%rax
  nopw   0x0(%rax,%rax,1)
L421:
  movzbl (%rax),%ecx
  add    $0x1,%rax
  add    %ecx,%edx
  cmp    %r13,%rax
  jne    L421
  mov    %r12,%rdi
  xor    %eax,%eax
  add    $0xa,%r14
  call   <printf@plt>
  cmp    $0x64,%r14
  jne    L545
  lea    D105(%rip),%rdi
  lea    0x20(%rsp),%rbx
  call   <puts@plt>
  movl   $0x7b,0x18(%rsp)
  xor    %eax,%eax
  nopl   0x0(%rax)
L1119:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L1119
  movb   $0xa5,0x22(%rsp)
  lea    0x5020(%rsp),%r15
  mov    %rbx,%rax
  xor    %edx,%edx
  nopl   0x0(%rax)
L572:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L572
  mov    $0x1,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L191:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L191
  mov    $0xffffa5a5,%r13d
  mov    %rbx,%rax
  xor    %edx,%edx
  mov    %r13w,0x24(%rsp)
  nopl   0x0(%rax,%rax,1)
L695:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L695
  mov    $0x2,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L889:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L889
  mov    $0xffffa5a5,%r11d
  movb   $0xa5,0x28(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  mov    %r11w,0x26(%rsp)
  nopl   (%rax)
L958:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L958
  mov    $0x3,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L350:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L350
  movl   $0xa5a5a5a5,0x28(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  nopl   0x0(%rax)
L212:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L212
  mov    $0x4,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L759:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L759
  movl   $0xa5a5a5a5,0x2a(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  movb   $0xa5,0x2e(%rsp)
  nopl   0x0(%rax)
L1066:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L1066
  mov    $0x5,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L325:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L325
  mov    $0xffffa5a5,%r10d
  movl   $0xa5a5a5a5,0x2c(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  mov    %r10w,0x30(%rsp)
L486:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L486
  mov    $0x6,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L893:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L893
  mov    $0xffffa5a5,%r9d
  movb   $0xa5,0x34(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  movl   $0xa5a5a5a5,0x2e(%rsp)
  mov    %r9w,0x32(%rsp)
  nopl   (%rax)
L507:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L507
  mov    $0x7,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L659:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L659
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  xor    %edx,%edx
  mov    %rax,0x30(%rsp)
  mov    %rbx,%rax
  nopl   0x0(%rax,%rax,1)
L811:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L811
  mov    $0x8,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L185:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L185
  movb   $0xa5,0x3a(%rsp)
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rax,0x32(%rsp)
  mov    %rbx,%rax
L175:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L175
  mov    $0x9,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L132:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L132
  mov    $0xffffa5a5,%r8d
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %r8w,0x3c(%rsp)
  mov    %rax,0x34(%rsp)
  mov    %rbx,%rax
  nopw   0x0(%rax,%rax,1)
L618:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L618
  mov    $0xa,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L558:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L558
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movaps %xmm0,0x40(%rsp)
  nopl   0x0(%rax)
L134:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L134
  mov    $0x10,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L588:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L588
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x3e(%rsp)
  movups %xmm0,0x4e(%rsp)
  xchg   %ax,%ax
L924:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L924
  mov    $0x20,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L579:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L579
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x3a(%rsp)
  movups %xmm0,0x4a(%rsp)
  movups %xmm0,0x5a(%rsp)
  movups %xmm0,0x6a(%rsp)
  nopl   0x0(%rax,%rax,1)
L557:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L557
  mov    $0x40,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L780:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L780
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x32(%rsp)
  movups %xmm0,0x42(%rsp)
  movups %xmm0,0x52(%rsp)
  movups %xmm0,0x62(%rsp)
  movups %xmm0,0x72(%rsp)
  movups %xmm0,0x82(%rsp)
  movups %xmm0,0x92(%rsp)
  movups %xmm0,0xa2(%rsp)
  nopl   (%rax)
L437:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L437
  mov    $0x80,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L84:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L84
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x22(%rsp)
  movups %xmm0,0x32(%rsp)
  movups %xmm0,0x42(%rsp)
  movups %xmm0,0x52(%rsp)
  movups %xmm0,0x62(%rsp)
  movups %xmm0,0x72(%rsp)
  movups %xmm0,0x82(%rsp)
  movups %xmm0,0x92(%rsp)
  movups %xmm0,0xa2(%rsp)
  movups %xmm0,0xb2(%rsp)
  movups %xmm0,0xc2(%rsp)
  movups %xmm0,0xd2(%rsp)
  movups %xmm0,0xe2(%rsp)
  movups %xmm0,0xf2(%rsp)
  movups %xmm0,0x102(%rsp)
  movups %xmm0,0x112(%rsp)
  nopw   0x0(%rax,%rax,1)
L125:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L125
  mov    $0x100,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L347:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L347
  lea    0x28(%rsp),%rdi
  mov    $0x3f,%ecx
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rax,0x24(%rsp)
  mov    %rax,0x21c(%rsp)
  rep stos %rax,%es:(%rdi)
  mov    %rbx,%rax
L520:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L520
  mov    $0x200,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nop
L147:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L147
  lea    0x28(%rsp),%rdi
  mov    $0x80,%ecx
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rdi,0x8(%rsp)
  rep stos %rax,%es:(%rdi)
  mov    %rbx,%rax
  nopl   0x0(%rax,%rax,1)
L211:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L211
  mov    $0x400,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0xa,%r14d
  call   <printf@plt>
  mov    $0xf0f0f0f1,%r13d
L624:
  mov    %r14d,%esi
  xor    %eax,%eax
  xchg   %ax,%ax
L1073:
  mov    0x18(%rsp),%edx
  imul   %eax,%edx
  mov    %dx,(%rbx,%rax,2)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L1073
  mov    %esi,%eax
  mov    %r14d,%ecx
  imul   %r13,%rax
  shr    $0x24,%rax
  mov    %eax,%edx
  shl    $0x4,%edx
  add    %eax,%edx
  mov    %esi,%eax
  sub    %edx,%eax
  cltq
  lea    (%rbx,%rax,2),%rdx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  lea    0x8(%rdx),%rdi
  mov    %rax,(%rdx)
  and    $0xfffffffffffffff8,%rdi
  mov    %rax,-0x8(%rdx,%rcx,1)
  sub    %rdi,%rdx
  lea    (%r14,%rdx,1),%ecx
  xor    %edx,%edx
  shr    $0x3,%ecx
  rep stos %rax,%es:(%rdi)
  mov    %rbx,%rax
  nopl   0x0(%rax)
L521:
  movzwl (%rax),%ecx
  add    $0x2,%rax
  add    %ecx,%edx
  cmp    %rax,%r15
  jne    L521
  mov    %r12,%rdi
  xor    %eax,%eax
  add    $0xa,%r14
  call   <printf@plt>
  cmp    $0x64,%r14
  jne    L624
  lea    D104(%rip),%rdi
  call   <puts@plt>
  movl   $0x7b,0x1c(%rsp)
  xor    %eax,%eax
  nopl   0x0(%rax)
L397:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L397
  movb   $0xa5,0x24(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  nopl   0x0(%rax,%rax,1)
L568:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L568
  mov    $0x1,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L65:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L65
  mov    $0xffffa5a5,%edi
  mov    %rbx,%rax
  xor    %edx,%edx
  mov    %di,0x28(%rsp)
  nopl   (%rax)
L380:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L380
  mov    $0x2,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L106:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L106
  mov    $0xffffa5a5,%esi
  movb   $0xa5,0x2e(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  mov    %si,0x2c(%rsp)
  nopw   0x0(%rax,%rax,1)
L526:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L526
  mov    $0x3,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L439:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L439
  movl   $0xa5a5a5a5,0x30(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  nopl   0x0(%rax,%rax,1)
L270:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L270
  mov    $0x4,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L332:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L332
  movl   $0xa5a5a5a5,0x34(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  movb   $0xa5,0x38(%rsp)
  nopl   0x0(%rax,%rax,1)
L16:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L16
  mov    $0x5,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L254:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L254
  mov    $0xffffa5a5,%ecx
  movl   $0xa5a5a5a5,0x38(%rsp)
  mov    %rbx,%rax
  xor    %edx,%edx
  mov    %cx,0x3c(%rsp)
  nopl   (%rax)
L1086:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L1086
  mov    $0x6,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L446:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L446
  movl   $0xa5a5a5a5,0x3c(%rsp)
  mov    $0xffffa5a5,%edx
  mov    %rbx,%rax
  movb   $0xa5,0x42(%rsp)
  mov    %dx,0x40(%rsp)
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L248:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L248
  mov    $0x7,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L1113:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L1113
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  xor    %edx,%edx
  mov    %rax,0x40(%rsp)
  mov    %rbx,%rax
  nopw   0x0(%rax,%rax,1)
L725:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L725
  mov    $0x8,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L602:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L602
  movb   $0xa5,0x4c(%rsp)
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rax,0x44(%rsp)
  mov    %rbx,%rax
  nopw   0x0(%rax,%rax,1)
L400:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L400
  mov    $0x9,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L920:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L920
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  xor    %edx,%edx
  mov    %rax,0x48(%rsp)
  mov    $0xffffa5a5,%eax
  mov    %ax,0x50(%rsp)
  mov    %rbx,%rax
  nopl   0x0(%rax)
L656:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L656
  mov    $0xa,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L1065:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L1065
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movaps %xmm0,0x60(%rsp)
L1112:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L1112
  mov    $0x10,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L822:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L822
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x5c(%rsp)
  movups %xmm0,0x6c(%rsp)
  nopl   (%rax)
L376:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L376
  mov    $0x20,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L163:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L163
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x54(%rsp)
  movups %xmm0,0x64(%rsp)
  movups %xmm0,0x74(%rsp)
  movups %xmm0,0x84(%rsp)
  nopw   0x0(%rax,%rax,1)
L961:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L961
  mov    $0x40,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L553:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L553
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x44(%rsp)
  movups %xmm0,0x54(%rsp)
  movups %xmm0,0x64(%rsp)
  movups %xmm0,0x74(%rsp)
  movups %xmm0,0x84(%rsp)
  movups %xmm0,0x94(%rsp)
  movups %xmm0,0xa4(%rsp)
  movups %xmm0,0xb4(%rsp)
  nopw   0x0(%rax,%rax,1)
L662:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L662
  mov    $0x80,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L630:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L630
  movdqa D75(%rip),%xmm0
  mov    %rbx,%rax
  xor    %edx,%edx
  movups %xmm0,0x24(%rsp)
  movups %xmm0,0x34(%rsp)
  movups %xmm0,0x44(%rsp)
  movups %xmm0,0x54(%rsp)
  movups %xmm0,0x64(%rsp)
  movups %xmm0,0x74(%rsp)
  movups %xmm0,0x84(%rsp)
  movups %xmm0,0x94(%rsp)
  movups %xmm0,0xa4(%rsp)
  movups %xmm0,0xb4(%rsp)
  movups %xmm0,0xc4(%rsp)
  movups %xmm0,0xd4(%rsp)
  movups %xmm0,0xe4(%rsp)
  movups %xmm0,0xf4(%rsp)
  movups %xmm0,0x104(%rsp)
  movups %xmm0,0x114(%rsp)
  nopl   0x0(%rax)
L109:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L109
  mov    $0x100,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L187:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L187
  mov    0x8(%rsp),%rdi
  mov    $0x40,%ecx
  xor    %edx,%edx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  rep stos %rax,%es:(%rdi)
  mov    %rbx,%rax
  nopw   0x0(%rax,%rax,1)
L305:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L305
  mov    $0x200,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  nopl   0x0(%rax)
L69:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L69
  lea    0x30(%rsp),%rdx
  mov    $0x80,%ecx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  mov    %rdx,%rdi
  xor    %edx,%edx
  rep stos %rax,%es:(%rdi)
  mov    %rbx,%rax
  nopl   (%rax)
L336:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L336
  mov    $0x400,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0xa,%r14d
  call   <printf@plt>
  mov    $0xf0f0f0f1,%r13d
L660:
  mov    %r14d,%esi
  xor    %eax,%eax
  nopl   0x0(%rax,%rax,1)
L475:
  mov    0x1c(%rsp),%edx
  imul   %eax,%edx
  mov    %edx,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x2800,%rax
  jne    L475
  mov    %esi,%eax
  mov    %r14d,%ecx
  imul   %r13,%rax
  shr    $0x24,%rax
  mov    %eax,%edx
  shl    $0x4,%edx
  add    %eax,%edx
  mov    %esi,%eax
  sub    %edx,%eax
  cltq
  lea    (%rbx,%rax,4),%rdx
  movabs $0xa5a5a5a5a5a5a5a5,%rax
  lea    0x8(%rdx),%rdi
  mov    %rax,(%rdx)
  and    $0xfffffffffffffff8,%rdi
  mov    %rax,-0x8(%rdx,%rcx,1)
  sub    %rdi,%rdx
  lea    (%r14,%rdx,1),%ecx
  xor    %edx,%edx
  shr    $0x3,%ecx
  rep stos %rax,%es:(%rdi)
  mov    %rbx,%rax
  nopl   0x0(%rax,%rax,1)
L1076:
  add    (%rax),%edx
  add    $0x4,%rax
  cmp    %rbp,%rax
  jne    L1076
  mov    %r12,%rdi
  xor    %eax,%eax
  add    $0xa,%r14
  call   <printf@plt>
  cmp    $0x64,%r14
  jne    L660
  mov    0xc828(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L1075
  add    $0xc838,%rsp
  mov    $0x1,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L1075:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: tag: D163
datatype: string
name: extract_symbolic_data
arguments: tag: D145
datatype: string
name: extract_symbolic_data
arguments: tag: D75
datatype: byte[16]
name: extract_symbolic_data
arguments: tag: D105
datatype: string
name: extract_symbolic_data
arguments: tag: D104
datatype: string

tool: D163: 8

tool: D145: final %d:%d


tool: {"D75": [0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5,0xa5]}

tool: D105: 16

tool: D104: 32

assistant: ```c
int main() {
  printf("8\n");
  {
    unsigned char buffer[10240];
    volatile int seed = 123;
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1 % 17, 0xA5, 1);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 2 % 17, 0xA5, 2);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 2, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 3 % 17, 0xA5, 3);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 3, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 4 % 17, 0xA5, 4);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 4, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 5 % 17, 0xA5, 5);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 5, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 6 % 17, 0xA5, 6);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 6, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 7 % 17, 0xA5, 7);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 7, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 8 % 17, 0xA5, 8);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 8, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 9 % 17, 0xA5, 9);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 9, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 10 % 17, 0xA5, 10);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 10, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 16 % 17, 0xA5, 16);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 16, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 32 % 17, 0xA5, 32);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 32, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 64 % 17, 0xA5, 64);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 64, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 128 % 17, 0xA5, 128);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 128, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 256 % 17, 0xA5, 256);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 256, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 512 % 17, 0xA5, 512);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 512, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1024 % 17, 0xA5, 1024);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1024, v);
    };
    for (int x = 10; x < 100; x += 10) {
      {
        for (int i = 0; i < 10240; i++) {
          buffer[i] = i * seed;
        }
        memset(buffer + x % 17, 0xA5, x);
        int v = 0;
        for (int i = 0; i < 10240; i++) {
          v += buffer[i];
        }
        printf("final %d:%d\n", x, v);
      }
    };
  };
  printf("16\n");
  {
    unsigned short buffer[10240];
    volatile int seed = 123;
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1 % 17, 0xA5, 1);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 2 % 17, 0xA5, 2);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 2, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 3 % 17, 0xA5, 3);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 3, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 4 % 17, 0xA5, 4);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 4, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 5 % 17, 0xA5, 5);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 5, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 6 % 17, 0xA5, 6);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 6, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 7 % 17, 0xA5, 7);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 7, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 8 % 17, 0xA5, 8);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 8, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 9 % 17, 0xA5, 9);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 9, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 10 % 17, 0xA5, 10);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 10, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 16 % 17, 0xA5, 16);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 16, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 32 % 17, 0xA5, 32);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 32, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 64 % 17, 0xA5, 64);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 64, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 128 % 17, 0xA5, 128);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 128, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 256 % 17, 0xA5, 256);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 256, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 512 % 17, 0xA5, 512);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 512, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1024 % 17, 0xA5, 1024);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1024, v);
    };
    for (int x = 10; x < 100; x += 10) {
      {
        for (int i = 0; i < 10240; i++) {
          buffer[i] = i * seed;
        }
        memset(buffer + x % 17, 0xA5, x);
        int v = 0;
        for (int i = 0; i < 10240; i++) {
          v += buffer[i];
        }
        printf("final %d:%d\n", x, v);
      }
    };
  };
  printf("32\n");
  {
    unsigned buffer[10240];
    volatile int seed = 123;
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1 % 17, 0xA5, 1);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 2 % 17, 0xA5, 2);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 2, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 3 % 17, 0xA5, 3);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 3, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 4 % 17, 0xA5, 4);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 4, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 5 % 17, 0xA5, 5);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 5, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 6 % 17, 0xA5, 6);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 6, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 7 % 17, 0xA5, 7);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 7, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 8 % 17, 0xA5, 8);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 8, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 9 % 17, 0xA5, 9);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 9, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 10 % 17, 0xA5, 10);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 10, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 16 % 17, 0xA5, 16);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 16, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 32 % 17, 0xA5, 32);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 32, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 64 % 17, 0xA5, 64);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 64, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 128 % 17, 0xA5, 128);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 128, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 256 % 17, 0xA5, 256);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 256, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 512 % 17, 0xA5, 512);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 512, v);
    };
    {
      for (int i = 0; i < 10240; i++) {
        buffer[i] = i * seed;
      }
      memset(buffer + 1024 % 17, 0xA5, 1024);
      int v = 0;
      for (int i = 0; i < 10240; i++) {
        v += buffer[i];
      }
      printf("final %d:%d\n", 1024, v);
    };
    for (int x = 10; x < 100; x += 10) {
      {
        for (int i = 0; i < 10240; i++) {
          buffer[i] = i * seed;
        }
        memset(buffer + x % 17, 0xA5, x);
        int v = 0;
        for (int i = 0; i < 10240; i++) {
          v += buffer[i];
        }
        printf("final %d:%d\n", x, v);
      }
    };
  };
  return 1;
}
```