user: 请将以下的汇编代码转换成C语言代码:

```asm
<main>:
  endbr64
  push   %r13
  movd   %edi,%xmm7
  mov    %edi,%edx
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0xb58,%rsp
  movdqa D207(%rip),%xmm0
  test   %edi,%edi
  movdqa D950(%rip),%xmm4
  setg   %al
  setg   %r10b
  movdqa %xmm0,%xmm1
  movzbl %al,%eax
  movss  %xmm7,%xmm1
  movdqa %xmm1,%xmm3
  pcmpgtd %xmm4,%xmm3
  movd   %xmm3,%esi
  add    %esi,%eax
  jne    L456
  pshufd $0x55,%xmm3,%xmm2
  movd   %xmm2,%esi
  test   %esi,%esi
  jne    L4476
  movdqa %xmm3,%xmm2
  punpckhdq %xmm3,%xmm2
  movd   %xmm2,%ecx
  test   %ecx,%ecx
  jne    L3719
  pshufd $0xff,%xmm3,%xmm3
  movd   %xmm3,%esi
  cmp    $0xffffffff,%esi
  jne    L2882
  movdqa %xmm4,%xmm2
  mov    %edi,%eax
  mov    %edi,%r9d
  sar    $0x1f,%eax
  pcmpgtd %xmm1,%xmm2
  shr    $0x1f,%r9d
  movd   %xmm2,%esi
  cmp    %esi,%eax
  jne    L2263
  pshufd $0x55,%xmm2,%xmm3
  movd   %xmm3,%esi
  cmp    $0xffffffff,%esi
  jne    L856
  movdqa %xmm2,%xmm3
  punpckhdq %xmm2,%xmm3
  movd   %xmm3,%esi
  test   %esi,%esi
  jne    L3454
  pshufd $0xff,%xmm2,%xmm3
  movd   %xmm3,%esi
  test   %esi,%esi
  jne    L2753
  pxor   %xmm3,%xmm3
  mov    %edi,%eax
  pcmpeqd %xmm3,%xmm2
  not    %eax
  mov    %eax,%r8d
  sar    $0x1f,%eax
  shr    $0x1f,%r8d
  movd   %xmm2,%r11d
  cmp    %r11d,%eax
  jne    L4985
  pshufd $0x55,%xmm2,%xmm3
  movd   %xmm3,%ecx
  test   %ecx,%ecx
  jne    L999
  movdqa %xmm2,%xmm3
  punpckhdq %xmm2,%xmm3
  movd   %xmm3,%r11d
  cmp    $0xffffffff,%r11d
  jne    L159
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%r11d
  cmp    $0xffffffff,%r11d
  jne    L307
  movdqa %xmm1,%xmm3
  pxor   %xmm2,%xmm2
  test   %edi,%edi
  pcmpgtd %xmm4,%xmm3
  setle  %al
  setle  %dil
  movzbl %al,%eax
  pcmpeqd %xmm2,%xmm3
  movd   %xmm3,%r11d
  add    %r11d,%eax
  jne    L1027
  pshufd $0x55,%xmm3,%xmm2
  movd   %xmm2,%r11d
  cmp    $0xffffffff,%r11d
  jne    L4588
  movdqa %xmm3,%xmm2
  punpckhdq %xmm3,%xmm2
  movd   %xmm2,%r11d
  cmp    $0xffffffff,%r11d
  jne    L4544
  pshufd $0xff,%xmm3,%xmm3
  movd   %xmm3,%r11d
  test   %r11d,%r11d
  jne    L55
  movdqa %xmm1,%xmm2
  test   %edx,%edx
  pcmpeqd %xmm4,%xmm2
  sete   %al
  sete   %cl
  movzbl %al,%eax
  movd   %xmm2,%esi
  add    %esi,%eax
  jne    L5752
  pshufd $0x55,%xmm2,%xmm3
  movd   %xmm3,%esi
  test   %esi,%esi
  jne    L3623
  movdqa %xmm2,%xmm3
  punpckhdq %xmm2,%xmm3
  movd   %xmm3,%esi
  cmp    $0xffffffff,%esi
  jne    L1593
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%esi
  test   %esi,%esi
  jne    L3408
  pcmpeqd %xmm4,%xmm1
  pxor   %xmm2,%xmm2
  test   %edx,%edx
  setne  %bl
  setne  %al
  movzbl %bl,%ebx
  pcmpeqd %xmm2,%xmm1
  neg    %ebx
  movd   %xmm1,%r11d
  cmp    %ebx,%r11d
  jne    L712
  pshufd $0x55,%xmm1,%xmm2
  movd   %xmm2,%r11d
  cmp    $0xffffffff,%r11d
  jne    L5241
  movdqa %xmm1,%xmm2
  punpckhdq %xmm1,%xmm2
  movd   %xmm2,%r11d
  test   %r11d,%r11d
  jne    L4263
  pshufd $0xff,%xmm1,%xmm1
  movd   %xmm1,%r11d
  cmp    $0xffffffff,%r11d
  jne    L5207
  movdqa D559(%rip),%xmm5
  movss  %xmm7,%xmm0
  movdqa %xmm4,%xmm2
  mov    %edx,%r11d
  movdqa %xmm0,%xmm6
  psubd  %xmm5,%xmm6
  psubd  %xmm5,%xmm2
  movdqa %xmm6,%xmm3
  pcmpgtd %xmm2,%xmm3
  movd   %xmm3,%esi
  cmp    %ebx,%esi
  jne    L2443
  pshufd $0x55,%xmm3,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L1002
  movdqa %xmm3,%xmm1
  punpckhdq %xmm3,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L1756
  pshufd $0xff,%xmm3,%xmm3
  movd   %xmm3,%esi
  test   %esi,%esi
  jne    L1320
  pcmpgtd %xmm6,%xmm2
  movd   %xmm2,%esi
  test   %esi,%esi
  jne    L406
  pshufd $0x55,%xmm2,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L1347
  movdqa %xmm2,%xmm1
  punpckhdq %xmm2,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L5347
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%esi
  cmp    $0xffffffff,%esi
  jne    L2967
  movdqa %xmm4,%xmm6
  movdqa %xmm0,%xmm1
  psubd  %xmm5,%xmm6
  psubd  %xmm5,%xmm1
  pxor   %xmm5,%xmm5
  movdqa %xmm6,%xmm3
  pcmpgtd %xmm1,%xmm3
  pcmpeqd %xmm5,%xmm3
  movd   %xmm3,%esi
  cmp    $0xffffffff,%esi
  jne    L4241
  pshufd $0x55,%xmm3,%xmm2
  movd   %xmm2,%esi
  test   %esi,%esi
  jne    L3369
  movdqa %xmm3,%xmm2
  punpckhdq %xmm3,%xmm2
  movd   %xmm2,%esi
  cmp    $0xffffffff,%esi
  jne    L3173
  pshufd $0xff,%xmm3,%xmm3
  movd   %xmm3,%esi
  test   %esi,%esi
  jne    L3717
  pcmpgtd %xmm6,%xmm1
  cmp    $0x1,%edx
  sbb    %ebx,%ebx
  pcmpeqd %xmm5,%xmm1
  movd   %xmm1,%esi
  cmp    %ebx,%esi
  jne    L5616
  pshufd $0x55,%xmm1,%xmm2
  movd   %xmm2,%esi
  cmp    $0xffffffff,%esi
  jne    L5628
  movdqa %xmm1,%xmm2
  punpckhdq %xmm1,%xmm2
  movd   %xmm2,%esi
  cmp    $0xffffffff,%esi
  jne    L5301
  pshufd $0xff,%xmm1,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L3809
  pcmpeqd %xmm4,%xmm0
  movd   %xmm0,%esi
  cmp    %ebx,%esi
  jne    L5227
  pshufd $0x55,%xmm0,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L3439
  movdqa %xmm0,%xmm1
  punpckhdq %xmm0,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L1403
  pshufd $0xff,%xmm0,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L2835
  pxor   %xmm1,%xmm1
  mov    %edx,%ebx
  pcmpeqd %xmm1,%xmm0
  neg    %ebx
  sbb    %ebx,%ebx
  movd   %xmm0,%esi
  cmp    %ebx,%esi
  jne    L5590
  pshufd $0x55,%xmm0,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L4969
  movdqa %xmm0,%xmm1
  punpckhdq %xmm0,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L942
  pshufd $0xff,%xmm0,%xmm0
  movd   %xmm0,%esi
  cmp    $0xffffffff,%esi
  jne    L2490
  movdqa D89(%rip),%xmm3
  movdqa D948(%rip),%xmm1
  xor    %ebx,%ebx
  test   %dx,%dx
  setg   %bl
  movdqa %xmm3,%xmm0
  pinsrw $0x0,%edx,%xmm0
  movdqa %xmm0,%xmm2
  pcmpgtw %xmm1,%xmm2
  pextrw $0x0,%xmm2,%esi
  movswl %si,%esi
  add    %esi,%ebx
  jne    L1039
  pextrw $0x1,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L2208
  pextrw $0x2,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L4145
  pextrw $0x3,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L820
  pextrw $0x4,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L3481
  pextrw $0x5,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L725
  pextrw $0x6,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1362
  pextrw $0x7,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L2701
  movdqa %xmm1,%xmm2
  movswl %dx,%r13d
  pcmpgtw %xmm0,%xmm2
  mov    %r13d,%ebx
  sar    $0x1f,%ebx
  pextrw $0x0,%xmm2,%esi
  movswl %si,%esi
  cmp    %ebx,%esi
  jne    L1014
  pextrw $0x1,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L1246
  pextrw $0x2,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L4063
  pextrw $0x3,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L5847
  pextrw $0x4,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L2037
  pextrw $0x5,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1457
  pextrw $0x6,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L5038
  pextrw $0x7,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L2039
  movdqa %xmm1,%xmm2
  mov    %r13d,%ebx
  pminsw %xmm0,%xmm2
  not    %ebx
  pcmpeqw %xmm1,%xmm2
  sar    $0x1f,%ebx
  pextrw $0x0,%xmm2,%esi
  movswl %si,%esi
  cmp    %ebx,%esi
  jne    L1429
  pextrw $0x1,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1490
  pextrw $0x2,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L5530
  pextrw $0x3,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L3310
  pextrw $0x4,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L5571
  pextrw $0x5,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L4493
  pextrw $0x6,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L4743
  pextrw $0x7,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L483
  movdqa %xmm0,%xmm2
  xor    %ebx,%ebx
  test   %dx,%dx
  pminsw %xmm1,%xmm2
  setle  %bl
  pcmpeqw %xmm0,%xmm2
  pextrw $0x0,%xmm2,%esi
  movswl %si,%esi
  add    %esi,%ebx
  jne    L3856
  pextrw $0x1,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L2595
  pextrw $0x2,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L854
  pextrw $0x3,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L2379
  pextrw $0x4,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L5197
  pextrw $0x5,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L3474
  pextrw $0x6,%xmm2,%ebx
  movswl %bx,%esi
  cmp    $0xffff,%bx
  jne    L2179
  pextrw $0x7,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1332
  pcmpeqw %xmm1,%xmm0
  cmp    $0x1,%dx
  sbb    %ebx,%ebx
  pextrw $0x0,%xmm0,%esi
  movswl %si,%r12d
  cmp    %ebx,%r12d
  jne    L3934
  pextrw $0x1,%xmm0,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L5376
  pextrw $0x2,%xmm0,%esi
  movswl %si,%r12d
  cmp    $0xffff,%si
  jne    L5705
  pextrw $0x3,%xmm0,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L4247
  pextrw $0x4,%xmm0,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L5016
  pextrw $0x5,%xmm0,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L215
  pextrw $0x6,%xmm0,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L335
  pextrw $0x7,%xmm0,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L2949
  pxor   %xmm2,%xmm2
  neg    %r11w
  pcmpeqw %xmm2,%xmm0
  sbb    %r11d,%r11d
  pextrw $0x0,%xmm0,%esi
  movswl %si,%esi
  cmp    %r11d,%esi
  jne    L4258
  pextrw $0x1,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L3489
  pextrw $0x2,%xmm0,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L3487
  pextrw $0x3,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L1233
  pextrw $0x4,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L4074
  pextrw $0x5,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L3240
  pextrw $0x6,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L5711
  pextrw $0x7,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L5806
  pinsrw $0x0,%edx,%xmm3
  pxor   %xmm4,%xmm4
  mov    %edx,%ebx
  movdqa %xmm3,%xmm2
  movdqa %xmm3,%xmm0
  psubusw %xmm1,%xmm2
  pcmpeqw %xmm4,%xmm2
  pcmpeqw %xmm4,%xmm2
  pextrw $0x0,%xmm2,%esi
  movswl %si,%r11d
  mov    %edx,%esi
  neg    %si
  sbb    %ebp,%ebp
  cmp    %ebp,%r11d
  jne    L5865
  pextrw $0x1,%xmm2,%esi
  movswl %si,%r11d
  test   %r11d,%r11d
  jne    L1645
  pextrw $0x2,%xmm2,%esi
  movswl %si,%r11d
  test   %r11d,%r11d
  jne    L1200
  pextrw $0x3,%xmm2,%esi
  movswl %si,%r11d
  test   %r11d,%r11d
  jne    L1463
  pextrw $0x4,%xmm2,%esi
  movswl %si,%r11d
  test   %r11d,%r11d
  jne    L225
  pextrw $0x5,%xmm2,%esi
  movswl %si,%r11d
  cmp    $0xffff,%si
  jne    L4550
  pextrw $0x6,%xmm2,%esi
  movswl %si,%r11d
  test   %r11d,%r11d
  jne    L5544
  pextrw $0x7,%xmm2,%esi
  movswl %si,%r11d
  cmp    $0xffff,%si
  jne    L3797
  movdqa %xmm1,%xmm2
  pxor   %xmm4,%xmm4
  psubusw %xmm3,%xmm2
  pcmpeqw %xmm4,%xmm2
  pcmpeqw %xmm4,%xmm2
  pextrw $0x0,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1063
  pextrw $0x1,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L5136
  pextrw $0x2,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L2848
  pextrw $0x3,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L2099
  pextrw $0x4,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L3239
  pextrw $0x5,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1972
  pextrw $0x6,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L4348
  pextrw $0x7,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L1762
  movdqa %xmm1,%xmm2
  psubusw %xmm3,%xmm2
  pxor   %xmm3,%xmm3
  pcmpeqw %xmm3,%xmm2
  pextrw $0x0,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L2895
  pextrw $0x1,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L753
  pextrw $0x2,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L4794
  pextrw $0x3,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L4455
  pextrw $0x4,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L5381
  pextrw $0x5,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L1480
  pextrw $0x6,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L3150
  pextrw $0x7,%xmm2,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L516
  movdqa %xmm0,%xmm2
  pxor   %xmm3,%xmm3
  cmp    $0x1,%dx
  psubusw %xmm1,%xmm2
  sbb    %r11d,%r11d
  pcmpeqw %xmm3,%xmm2
  pextrw $0x0,%xmm2,%esi
  movswl %si,%esi
  cmp    %r11d,%esi
  jne    L2352
  pextrw $0x1,%xmm2,%r12d
  movswl %r12w,%esi
  cmp    $0xffff,%r12w
  jne    L3972
  pextrw $0x2,%xmm2,%r12d
  movswl %r12w,%esi
  cmp    $0xffff,%r12w
  jne    L766
  pextrw $0x3,%xmm2,%r12d
  movswl %r12w,%esi
  cmp    $0xffff,%r12w
  jne    L3305
  pextrw $0x4,%xmm2,%r12d
  movswl %r12w,%esi
  cmp    $0xffff,%r12w
  jne    L626
  pextrw $0x5,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L5042
  pextrw $0x6,%xmm2,%r12d
  movswl %r12w,%esi
  cmp    $0xffff,%r12w
  jne    L5965
  pextrw $0x7,%xmm2,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L2265
  movdqa %xmm0,%xmm2
  pcmpeqw %xmm1,%xmm2
  pextrw $0x0,%xmm2,%esi
  movswl %si,%r12d
  cmp    %r11d,%r12d
  jne    L4169
  pextrw $0x1,%xmm2,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L3957
  pextrw $0x2,%xmm2,%esi
  movswl %si,%r12d
  cmp    $0xffff,%si
  jne    L3542
  pextrw $0x3,%xmm2,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L1134
  pextrw $0x4,%xmm2,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L585
  pextrw $0x5,%xmm2,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L3402
  pextrw $0x6,%xmm2,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L4214
  pextrw $0x7,%xmm2,%esi
  movswl %si,%r12d
  test   %r12d,%r12d
  jne    L3537
  pcmpeqw %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  pcmpeqw %xmm1,%xmm0
  pextrw $0x0,%xmm0,%esi
  movswl %si,%esi
  cmp    %ebp,%esi
  jne    L2038
  pextrw $0x1,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L2464
  pextrw $0x2,%xmm0,%esi
  movswl %si,%esi
  test   %esi,%esi
  jne    L3016
  pextrw $0x3,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L3385
  pextrw $0x4,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L3412
  pextrw $0x5,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L2226
  pextrw $0x6,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L3306
  pextrw $0x7,%xmm0,%r11d
  movswl %r11w,%esi
  cmp    $0xffff,%r11w
  jne    L116
  movzbl %dl,%ebp
  movdqa D640(%rip),%xmm1
  xor    %ebx,%ebx
  mov    %edx,%r11d
  movabs $0x2fb57060a020100,%rsi
  or     %rbp,%rsi
  test   %dl,%dl
  mov    %rsi,(%rsp)
  setg   %bl
  mov    %rsi,0x8(%rsp)
  movdqa (%rsp),%xmm0
  neg    %ebx
  pcmpgtb %xmm1,%xmm0
  movd   %xmm0,%esi
  movsbl %sil,%esi
  cmp    %ebx,%esi
  jne    L2647
  movaps %xmm0,0xb40(%rsp)
  movsbl 0xb41(%rsp),%esi
  test   %esi,%esi
  jne    L2238
  movaps %xmm0,0xb30(%rsp)
  movsbl 0xb32(%rsp),%esi
  test   %esi,%esi
  jne    L2506
  movaps %xmm0,0xb20(%rsp)
  movsbl 0xb23(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L370
  movaps %xmm0,0xb10(%rsp)
  movsbl 0xb14(%rsp),%esi
  test   %esi,%esi
  jne    L5439
  movaps %xmm0,0xb00(%rsp)
  movsbl 0xb05(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2339
  movaps %xmm0,0xaf0(%rsp)
  movsbl 0xaf6(%rsp),%esi
  test   %esi,%esi
  jne    L1386
  movaps %xmm0,0xae0(%rsp)
  movsbl 0xae7(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3557
  movaps %xmm0,0xad0(%rsp)
  movsbl 0xad8(%rsp),%esi
  cmp    %esi,%ebx
  jne    L2647
  movaps %xmm0,0xac0(%rsp)
  movsbl 0xac9(%rsp),%esi
  test   %esi,%esi
  jne    L2238
  movaps %xmm0,0xab0(%rsp)
  movsbl 0xaba(%rsp),%esi
  test   %esi,%esi
  jne    L2506
  movaps %xmm0,0xaa0(%rsp)
  movsbl 0xaab(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L370
  movaps %xmm0,0xa90(%rsp)
  movsbl 0xa9c(%rsp),%esi
  test   %esi,%esi
  jne    L5439
  movaps %xmm0,0xa80(%rsp)
  movsbl 0xa8d(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2339
  movaps %xmm0,0xa70(%rsp)
  movsbl 0xa7e(%rsp),%esi
  test   %esi,%esi
  jne    L1386
  movaps %xmm0,0xa60(%rsp)
  movsbl 0xa6f(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3557
  movdqa %xmm1,%xmm0
  movsbl %dl,%r13d
  pcmpgtb (%rsp),%xmm0
  mov    %r13d,%esi
  sar    $0x1f,%esi
  movd   %xmm0,%r12d
  movsbl %r12b,%r12d
  cmp    %esi,%r12d
  jne    L2447
  movaps %xmm0,0xa50(%rsp)
  movsbl 0xa51(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L5717
  movaps %xmm0,0xa40(%rsp)
  movsbl 0xa42(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5284
  movaps %xmm0,0xa30(%rsp)
  movsbl 0xa33(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2810
  movaps %xmm0,0xa20(%rsp)
  movsbl 0xa24(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L53
  movaps %xmm0,0xa10(%rsp)
  movsbl 0xa15(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2797
  movaps %xmm0,0xa00(%rsp)
  movsbl 0xa06(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L3223
  movaps %xmm0,0x9f0(%rsp)
  movsbl 0x9f7(%rsp),%r12d
  test   %r12d,%r12d
  jne    L889
  movaps %xmm0,0x9e0(%rsp)
  movsbl 0x9e8(%rsp),%r12d
  cmp    %r12d,%esi
  jne    L2447
  movaps %xmm0,0x9d0(%rsp)
  movsbl 0x9d9(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L5717
  movaps %xmm0,0x9c0(%rsp)
  movsbl 0x9ca(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5284
  movaps %xmm0,0x9b0(%rsp)
  movsbl 0x9bb(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2810
  movaps %xmm0,0x9a0(%rsp)
  movsbl 0x9ac(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L53
  movaps %xmm0,0x990(%rsp)
  movsbl 0x99d(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2797
  movaps %xmm0,0x980(%rsp)
  movsbl 0x98e(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L3223
  movaps %xmm0,0x970(%rsp)
  movsbl 0x97f(%rsp),%r12d
  test   %r12d,%r12d
  jne    L889
  movdqa %xmm1,%xmm0
  pxor   %xmm2,%xmm2
  mov    %r13d,%esi
  pcmpgtb (%rsp),%xmm0
  not    %esi
  sar    $0x1f,%esi
  pcmpeqb %xmm2,%xmm0
  movd   %xmm0,%r12d
  movsbl %r12b,%r12d
  cmp    %esi,%r12d
  jne    L2846
  movaps %xmm0,0x960(%rsp)
  movsbl 0x961(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1033
  movaps %xmm0,0x950(%rsp)
  movsbl 0x952(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1529
  movaps %xmm0,0x940(%rsp)
  movsbl 0x943(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1225
  movaps %xmm0,0x930(%rsp)
  movsbl 0x934(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5753
  movaps %xmm0,0x920(%rsp)
  movsbl 0x925(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L234
  movaps %xmm0,0x910(%rsp)
  movsbl 0x916(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1228
  movaps %xmm0,0x900(%rsp)
  movsbl 0x907(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L2441
  movaps %xmm0,0x8f0(%rsp)
  movsbl 0x8f8(%rsp),%r12d
  cmp    %r12d,%esi
  jne    L2846
  movaps %xmm0,0x8e0(%rsp)
  movsbl 0x8e9(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1033
  movaps %xmm0,0x8d0(%rsp)
  movsbl 0x8da(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1529
  movaps %xmm0,0x8c0(%rsp)
  movsbl 0x8cb(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1225
  movaps %xmm0,0x8b0(%rsp)
  movsbl 0x8bc(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5753
  movaps %xmm0,0x8a0(%rsp)
  movsbl 0x8ad(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L234
  movaps %xmm0,0x890(%rsp)
  movsbl 0x89e(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1228
  movaps %xmm0,0x880(%rsp)
  movsbl 0x88f(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L2441
  movdqa (%rsp),%xmm0
  pxor   %xmm2,%xmm2
  pcmpgtb %xmm1,%xmm0
  pcmpeqb %xmm2,%xmm0
  movd   %xmm0,%esi
  movsbl %sil,%r12d
  xor    %esi,%esi
  test   %dl,%dl
  setle  %sil
  neg    %esi
  cmp    %esi,%r12d
  jne    L1152
  movaps %xmm0,0x870(%rsp)
  movsbl 0x871(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L711
  movaps %xmm0,0x860(%rsp)
  movsbl 0x862(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L205
  movaps %xmm0,0x850(%rsp)
  movsbl 0x853(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2450
  movaps %xmm0,0x840(%rsp)
  movsbl 0x844(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1986
  movaps %xmm0,0x830(%rsp)
  movsbl 0x835(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1520
  movaps %xmm0,0x820(%rsp)
  movsbl 0x826(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1801
  movaps %xmm0,0x810(%rsp)
  movsbl 0x817(%rsp),%r12d
  test   %r12d,%r12d
  jne    L3724
  movaps %xmm0,0x800(%rsp)
  movsbl 0x808(%rsp),%r12d
  cmp    %r12d,%esi
  jne    L1152
  movaps %xmm0,0x7f0(%rsp)
  movsbl 0x7f9(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L711
  movaps %xmm0,0x7e0(%rsp)
  movsbl 0x7ea(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L205
  movaps %xmm0,0x7d0(%rsp)
  movsbl 0x7db(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2450
  movaps %xmm0,0x7c0(%rsp)
  movsbl 0x7cc(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1986
  movaps %xmm0,0x7b0(%rsp)
  movsbl 0x7bd(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1520
  movaps %xmm0,0x7a0(%rsp)
  movsbl 0x7ae(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1801
  movaps %xmm0,0x790(%rsp)
  movsbl 0x79f(%rsp),%r12d
  test   %r12d,%r12d
  jne    L3724
  movdqa (%rsp),%xmm0
  cmp    $0x1,%dl
  sbb    %esi,%esi
  pcmpeqb %xmm1,%xmm0
  movd   %xmm0,%r12d
  movsbl %r12b,%r12d
  cmp    %esi,%r12d
  jne    L4282
  movaps %xmm0,0x780(%rsp)
  movsbl 0x781(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5600
  movaps %xmm0,0x770(%rsp)
  movsbl 0x772(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L4658
  movaps %xmm0,0x760(%rsp)
  movsbl 0x763(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1010
  movaps %xmm0,0x750(%rsp)
  movsbl 0x754(%rsp),%r12d
  test   %r12d,%r12d
  jne    L4855
  movaps %xmm0,0x740(%rsp)
  movsbl 0x745(%rsp),%r12d
  test   %r12d,%r12d
  jne    L833
  movaps %xmm0,0x730(%rsp)
  movsbl 0x736(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5909
  movaps %xmm0,0x720(%rsp)
  movsbl 0x727(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1768
  movaps %xmm0,0x710(%rsp)
  movsbl 0x718(%rsp),%r12d
  cmp    %r12d,%esi
  jne    L4282
  movaps %xmm0,0x700(%rsp)
  movsbl 0x709(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5600
  movaps %xmm0,0x6f0(%rsp)
  movsbl 0x6fa(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L4658
  movaps %xmm0,0x6e0(%rsp)
  movsbl 0x6eb(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1010
  movaps %xmm0,0x6d0(%rsp)
  movsbl 0x6dc(%rsp),%r12d
  test   %r12d,%r12d
  jne    L4855
  movaps %xmm0,0x6c0(%rsp)
  movsbl 0x6cd(%rsp),%r12d
  test   %r12d,%r12d
  jne    L833
  movaps %xmm0,0x6b0(%rsp)
  movsbl 0x6be(%rsp),%r12d
  test   %r12d,%r12d
  jne    L5909
  movaps %xmm0,0x6a0(%rsp)
  movsbl 0x6af(%rsp),%r12d
  test   %r12d,%r12d
  jne    L1768
  movdqa (%rsp),%xmm0
  pxor   %xmm2,%xmm2
  neg    %r11b
  sbb    %esi,%esi
  pcmpeqb %xmm1,%xmm0
  pcmpeqb %xmm2,%xmm0
  movd   %xmm0,%r12d
  movsbl %r12b,%r12d
  cmp    %esi,%r12d
  jne    L3112
  movaps %xmm0,0x690(%rsp)
  movsbl 0x691(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L2419
  movaps %xmm0,0x680(%rsp)
  movsbl 0x682(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2002
  movaps %xmm0,0x670(%rsp)
  movsbl 0x673(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L5816
  movaps %xmm0,0x660(%rsp)
  movsbl 0x664(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L690
  movaps %xmm0,0x650(%rsp)
  movsbl 0x655(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1191
  movaps %xmm0,0x640(%rsp)
  movsbl 0x646(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L5491
  movaps %xmm0,0x630(%rsp)
  movsbl 0x637(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L2388
  movaps %xmm0,0x620(%rsp)
  movsbl 0x628(%rsp),%r12d
  cmp    %r12d,%esi
  jne    L3112
  movaps %xmm0,0x610(%rsp)
  movsbl 0x619(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L2419
  movaps %xmm0,0x600(%rsp)
  movsbl 0x60a(%rsp),%r12d
  test   %r12d,%r12d
  jne    L2002
  movaps %xmm0,0x5f0(%rsp)
  movsbl 0x5fb(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L5816
  movaps %xmm0,0x5e0(%rsp)
  movsbl 0x5ec(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L690
  movaps %xmm0,0x5d0(%rsp)
  movsbl 0x5dd(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L1191
  movaps %xmm0,0x5c0(%rsp)
  movsbl 0x5ce(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L5491
  movaps %xmm0,0x5b0(%rsp)
  movsbl 0x5bf(%rsp),%r12d
  cmp    $0xffffffff,%r12d
  jne    L2388
  movabs $0x2fb57060a020100,%rsi
  pxor   %xmm2,%xmm2
  mov    %edx,%ebx
  or     %rbp,%rsi
  mov    %rsi,(%rsp)
  mov    %rsi,0x8(%rsp)
  movdqa (%rsp),%xmm0
  psubusb %xmm1,%xmm0
  pcmpeqb %xmm2,%xmm0
  pcmpeqb %xmm2,%xmm0
  movd   %xmm0,%esi
  movsbl %sil,%ebp
  mov    %edx,%esi
  neg    %sil
  sbb    %esi,%esi
  cmp    %esi,%ebp
  jne    L4762
  movaps %xmm0,0x5a0(%rsp)
  movsbl 0x5a1(%rsp),%ebp
  test   %ebp,%ebp
  jne    L5951
  movaps %xmm0,0x590(%rsp)
  movsbl 0x592(%rsp),%ebp
  test   %ebp,%ebp
  jne    L2008
  movaps %xmm0,0x580(%rsp)
  movsbl 0x583(%rsp),%ebp
  test   %ebp,%ebp
  jne    L5518
  movaps %xmm0,0x570(%rsp)
  movsbl 0x574(%rsp),%ebp
  test   %ebp,%ebp
  jne    L1290
  movaps %xmm0,0x560(%rsp)
  movsbl 0x565(%rsp),%ebp
  cmp    $0xffffffff,%ebp
  jne    L5114
  movaps %xmm0,0x550(%rsp)
  movsbl 0x556(%rsp),%ebp
  test   %ebp,%ebp
  jne    L4671
  movaps %xmm0,0x540(%rsp)
  movsbl 0x547(%rsp),%ebp
  cmp    $0xffffffff,%ebp
  jne    L4410
  movaps %xmm0,0x530(%rsp)
  movsbl 0x538(%rsp),%r11d
  cmp    %r11d,%esi
  jne    L3226
  movaps %xmm0,0x520(%rsp)
  movsbl 0x529(%rsp),%ebp
  test   %ebp,%ebp
  jne    L5951
  movaps %xmm0,0x510(%rsp)
  movsbl 0x51a(%rsp),%ebp
  test   %ebp,%ebp
  jne    L2008
  movaps %xmm0,0x500(%rsp)
  movsbl 0x50b(%rsp),%ebp
  test   %ebp,%ebp
  jne    L5518
  movaps %xmm0,0x4f0(%rsp)
  movsbl 0x4fc(%rsp),%ebp
  test   %ebp,%ebp
  jne    L1290
  movaps %xmm0,0x4e0(%rsp)
  movsbl 0x4ed(%rsp),%ebp
  cmp    $0xffffffff,%ebp
  jne    L5114
  movaps %xmm0,0x4d0(%rsp)
  movsbl 0x4de(%rsp),%ebp
  test   %ebp,%ebp
  jne    L4671
  movaps %xmm0,0x4c0(%rsp)
  movsbl 0x4cf(%rsp),%ebp
  cmp    $0xffffffff,%ebp
  jne    L4410
  movdqa %xmm1,%xmm0
  psubusb (%rsp),%xmm0
  pxor   %xmm2,%xmm2
  pcmpeqb %xmm2,%xmm0
  pcmpeqb %xmm2,%xmm0
  movd   %xmm0,%esi
  movsbl %sil,%esi
  test   %esi,%esi
  jne    L2962
  movaps %xmm0,0x4b0(%rsp)
  movsbl 0x4b1(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L966
  movaps %xmm0,0x4a0(%rsp)
  movsbl 0x4a2(%rsp),%esi
  test   %esi,%esi
  jne    L2782
  movaps %xmm0,0x490(%rsp)
  movsbl 0x493(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L1067
  movaps %xmm0,0x480(%rsp)
  movsbl 0x484(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L4975
  movaps %xmm0,0x470(%rsp)
  movsbl 0x475(%rsp),%esi
  test   %esi,%esi
  jne    L5317
  movaps %xmm0,0x460(%rsp)
  movsbl 0x466(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5453
  movaps %xmm0,0x450(%rsp)
  movsbl 0x457(%rsp),%esi
  test   %esi,%esi
  jne    L3269
  movaps %xmm0,0x440(%rsp)
  movsbl 0x448(%rsp),%esi
  test   %esi,%esi
  jne    L2962
  movaps %xmm0,0x430(%rsp)
  movsbl 0x439(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L966
  movaps %xmm0,0x420(%rsp)
  movsbl 0x42a(%rsp),%esi
  test   %esi,%esi
  jne    L2782
  movaps %xmm0,0x410(%rsp)
  movsbl 0x41b(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L1067
  movaps %xmm0,0x400(%rsp)
  movsbl 0x40c(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L4975
  movaps %xmm0,0x3f0(%rsp)
  movsbl 0x3fd(%rsp),%esi
  test   %esi,%esi
  jne    L5317
  movaps %xmm0,0x3e0(%rsp)
  movsbl 0x3ee(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5453
  movaps %xmm0,0x3d0(%rsp)
  movsbl 0x3df(%rsp),%esi
  test   %esi,%esi
  jne    L3269
  movdqa (%rsp),%xmm0
  pminub %xmm1,%xmm0
  pcmpeqb %xmm1,%xmm0
  movd   %xmm0,%ebp
  movsbl %bpl,%esi
  cmp    $0xff,%bpl
  jne    L2707
  movaps %xmm0,0x3c0(%rsp)
  movsbl 0x3c1(%rsp),%esi
  test   %esi,%esi
  jne    L5092
  movaps %xmm0,0x3b0(%rsp)
  movsbl 0x3b2(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3201
  movaps %xmm0,0x3a0(%rsp)
  movsbl 0x3a3(%rsp),%esi
  test   %esi,%esi
  jne    L4449
  movaps %xmm0,0x390(%rsp)
  movsbl 0x394(%rsp),%esi
  test   %esi,%esi
  jne    L485
  movaps %xmm0,0x380(%rsp)
  movsbl 0x385(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L1559
  movaps %xmm0,0x370(%rsp)
  movsbl 0x376(%rsp),%esi
  test   %esi,%esi
  jne    L2697
  movaps %xmm0,0x360(%rsp)
  movsbl 0x367(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L903
  movaps %xmm0,0x350(%rsp)
  movsbl 0x358(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2707
  movaps %xmm0,0x340(%rsp)
  movsbl 0x349(%rsp),%esi
  test   %esi,%esi
  jne    L5092
  movaps %xmm0,0x330(%rsp)
  movsbl 0x33a(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3201
  movaps %xmm0,0x320(%rsp)
  movsbl 0x32b(%rsp),%esi
  test   %esi,%esi
  jne    L4449
  movaps %xmm0,0x310(%rsp)
  movsbl 0x31c(%rsp),%esi
  test   %esi,%esi
  jne    L485
  movaps %xmm0,0x300(%rsp)
  movsbl 0x30d(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L1559
  movaps %xmm0,0x2f0(%rsp)
  movsbl 0x2fe(%rsp),%esi
  test   %esi,%esi
  jne    L2697
  movaps %xmm0,0x2e0(%rsp)
  movsbl 0x2ef(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L903
  movdqa (%rsp),%xmm0
  cmp    $0x1,%dl
  sbb    %esi,%esi
  pminub %xmm1,%xmm0
  pcmpeqb (%rsp),%xmm0
  movd   %xmm0,%ebp
  movsbl %bpl,%ebp
  cmp    %ebp,%esi
  jne    L1102
  movaps %xmm0,0x2d0(%rsp)
  movsbl 0x2d1(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2143
  movaps %xmm0,0x2c0(%rsp)
  movsbl 0x2c2(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5253
  movaps %xmm0,0x2b0(%rsp)
  movsbl 0x2b3(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3200
  movaps %xmm0,0x2a0(%rsp)
  movsbl 0x2a4(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3415
  movaps %xmm0,0x290(%rsp)
  movsbl 0x295(%rsp),%esi
  test   %esi,%esi
  jne    L5595
  movaps %xmm0,0x280(%rsp)
  movsbl 0x286(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3533
  movaps %xmm0,0x270(%rsp)
  movsbl 0x277(%rsp),%esi
  test   %esi,%esi
  jne    L3330
  movaps %xmm0,0x260(%rsp)
  movsbl 0x268(%rsp),%esi
  cmp    %esi,%ebp
  jne    L3335
  movaps %xmm0,0x250(%rsp)
  movsbl 0x259(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2143
  movaps %xmm0,0x240(%rsp)
  movsbl 0x24a(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5253
  movaps %xmm0,0x230(%rsp)
  movsbl 0x23b(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3200
  movaps %xmm0,0x220(%rsp)
  movsbl 0x22c(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3415
  movaps %xmm0,0x210(%rsp)
  movsbl 0x21d(%rsp),%esi
  test   %esi,%esi
  jne    L5595
  movaps %xmm0,0x200(%rsp)
  movsbl 0x20e(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L3533
  movaps %xmm0,0x1f0(%rsp)
  movsbl 0x1ff(%rsp),%esi
  test   %esi,%esi
  jne    L3330
  movdqa (%rsp),%xmm0
  pcmpeqb %xmm1,%xmm0
  movd   %xmm0,%esi
  movsbl %sil,%esi
  cmp    %ebp,%esi
  jne    L1592
  movaps %xmm0,0x1e0(%rsp)
  movsbl 0x1e1(%rsp),%esi
  test   %esi,%esi
  jne    L3384
  movaps %xmm0,0x1d0(%rsp)
  movsbl 0x1d2(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5273
  movaps %xmm0,0x1c0(%rsp)
  movsbl 0x1c3(%rsp),%esi
  test   %esi,%esi
  jne    L3673
  movaps %xmm0,0x1b0(%rsp)
  movsbl 0x1b4(%rsp),%esi
  test   %esi,%esi
  jne    L3406
  movaps %xmm0,0x1a0(%rsp)
  movsbl 0x1a5(%rsp),%esi
  test   %esi,%esi
  jne    L5766
  movaps %xmm0,0x190(%rsp)
  movsbl 0x196(%rsp),%esi
  test   %esi,%esi
  jne    L367
  movaps %xmm0,0x180(%rsp)
  movsbl 0x187(%rsp),%esi
  test   %esi,%esi
  jne    L1694
  movaps %xmm0,0x170(%rsp)
  movsbl 0x178(%rsp),%esi
  cmp    %esi,%ebp
  jne    L1592
  movaps %xmm0,0x160(%rsp)
  movsbl 0x169(%rsp),%esi
  test   %esi,%esi
  jne    L3384
  movaps %xmm0,0x150(%rsp)
  movsbl 0x15a(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5273
  movaps %xmm0,0x140(%rsp)
  movsbl 0x14b(%rsp),%esi
  test   %esi,%esi
  jne    L3673
  movaps %xmm0,0x130(%rsp)
  movsbl 0x13c(%rsp),%esi
  test   %esi,%esi
  jne    L3406
  movaps %xmm0,0x120(%rsp)
  movsbl 0x12d(%rsp),%esi
  test   %esi,%esi
  jne    L5766
  movaps %xmm0,0x110(%rsp)
  movsbl 0x11e(%rsp),%esi
  test   %esi,%esi
  jne    L367
  movaps %xmm0,0x100(%rsp)
  movsbl 0x10f(%rsp),%esi
  test   %esi,%esi
  jne    L1694
  movdqa (%rsp),%xmm0
  pcmpeqb %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  pcmpeqb %xmm1,%xmm0
  movd   %xmm0,%esi
  movsbl %sil,%esi
  cmp    %r11d,%esi
  jne    L2118
  movaps %xmm0,0xf0(%rsp)
  movsbl 0xf1(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L596
  movaps %xmm0,0xe0(%rsp)
  movsbl 0xe2(%rsp),%esi
  test   %esi,%esi
  jne    L1641
  movaps %xmm0,0xd0(%rsp)
  movsbl 0xd3(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L4404
  movaps %xmm0,0xc0(%rsp)
  movsbl 0xc4(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L1541
  movaps %xmm0,0xb0(%rsp)
  movsbl 0xb5(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2248
  movaps %xmm0,0xa0(%rsp)
  movsbl 0xa6(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5424
  movaps %xmm0,0x90(%rsp)
  movsbl 0x97(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L4730
  movaps %xmm0,0x80(%rsp)
  movsbl 0x88(%rsp),%esi
  cmp    %r11d,%esi
  jne    L2118
  movaps %xmm0,0x70(%rsp)
  movsbl 0x79(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L596
  movaps %xmm0,0x60(%rsp)
  movsbl 0x6a(%rsp),%esi
  test   %esi,%esi
  jne    L1641
  movaps %xmm0,0x50(%rsp)
  movsbl 0x5b(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L4404
  movaps %xmm0,0x40(%rsp)
  movsbl 0x4c(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L1541
  movaps %xmm0,0x30(%rsp)
  movsbl 0x3d(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L2248
  movaps %xmm0,0x20(%rsp)
  movsbl 0x2e(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L5424
  movaps %xmm0,0x10(%rsp)
  movsbl 0x1f(%rsp),%esi
  cmp    $0xffffffff,%esi
  jne    L4730
  movaps D459(%rip),%xmm0
  pxor   %xmm3,%xmm3
  pxor   %xmm4,%xmm4
  xor    %r11d,%r11d
  cvtsi2ss %edx,%xmm3
  movaps D647(%rip),%xmm5
  cvtsi2ss %edx,%xmm0
  movaps %xmm5,%xmm2
  comiss %xmm4,%xmm3
  cmpltps %xmm0,%xmm2
  seta   %r11b
  movd   %xmm2,%esi
  add    %esi,%r11d
  jne    L4454
  pshufd $0x55,%xmm2,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L3644
  movdqa %xmm2,%xmm1
  punpckhdq %xmm2,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L5937
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%esi
  cmp    $0xffffffff,%esi
  jne    L3287
  movaps %xmm0,%xmm2
  xor    %r11d,%r11d
  cmpltps %xmm5,%xmm2
  comiss %xmm3,%xmm4
  movd   %xmm2,%esi
  seta   %r11b
  add    %esi,%r11d
  jne    L2279
  pshufd $0x55,%xmm2,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L3873
  movdqa %xmm2,%xmm1
  punpckhdq %xmm2,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L1535
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%esi
  test   %esi,%esi
  jne    L1443
  movaps %xmm5,%xmm2
  xor    %r11d,%r11d
  cmpleps %xmm0,%xmm2
  comiss %xmm4,%xmm3
  movd   %xmm2,%esi
  setae  %r11b
  add    %esi,%r11d
  jne    L1575
  pshufd $0x55,%xmm2,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L4629
  movdqa %xmm2,%xmm1
  punpckhdq %xmm2,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L4707
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%esi
  cmp    $0xffffffff,%esi
  jne    L4522
  movaps %xmm0,%xmm2
  xor    %r11d,%r11d
  cmpleps %xmm5,%xmm2
  comiss %xmm3,%xmm4
  movd   %xmm2,%esi
  setae  %r11b
  add    %esi,%r11d
  jne    L3708
  pshufd $0x55,%xmm2,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L4369
  movdqa %xmm2,%xmm1
  punpckhdq %xmm2,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L4958
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%esi
  test   %esi,%esi
  jne    L2048
  xor    %ebx,%ebx
  ucomiss %xmm4,%xmm3
  movaps %xmm0,%xmm2
  cmpeqps %xmm5,%xmm2
  setnp  %bl
  cmovne %esi,%ebx
  movd   %xmm2,%r11d
  add    %r11d,%ebx
  jne    L1681
  pshufd $0x55,%xmm2,%xmm1
  movd   %xmm1,%r11d
  test   %r11d,%r11d
  jne    L5563
  movdqa %xmm2,%xmm1
  punpckhdq %xmm2,%xmm1
  movd   %xmm1,%r11d
  cmp    $0xffffffff,%r11d
  jne    L3983
  pshufd $0xff,%xmm2,%xmm2
  movd   %xmm2,%r11d
  test   %r11d,%r11d
  jne    L2757
  xor    %r11d,%r11d
  ucomiss %xmm4,%xmm3
  mov    $0x1,%ebx
  cmpneqps %xmm5,%xmm0
  setp   %r11b
  cmovne %ebx,%r11d
  movd   %xmm0,%esi
  add    %esi,%r11d
  jne    L3531
  pshufd $0x55,%xmm0,%xmm1
  movd   %xmm1,%esi
  cmp    $0xffffffff,%esi
  jne    L5943
  movdqa %xmm0,%xmm1
  punpckhdq %xmm0,%xmm1
  movd   %xmm1,%esi
  test   %esi,%esi
  jne    L4236
  pshufd $0xff,%xmm0,%xmm0
  movd   %xmm0,%esi
  cmp    $0xffffffff,%esi
  jne    L3739
  pxor   %xmm3,%xmm3
  movapd D47(%rip),%xmm1
  movzbl %r10b,%r10d
  cvtsi2sd %edx,%xmm3
  movapd %xmm1,%xmm2
  movapd %xmm3,%xmm0
  movhpd D906(%rip),%xmm0
  cmpltpd %xmm0,%xmm2
  movq   %xmm2,%rsi
  add    %rsi,%r10
  jne    L2240
  movhlps %xmm2,%xmm7
  movq   %xmm7,%rsi
  cmp    $0xffffffffffffffff,%rsi
  jne    L1513
  movapd %xmm0,%xmm2
  movzbl %r9b,%r9d
  cmpltpd %xmm1,%xmm2
  movq   %xmm2,%rsi
  add    %rsi,%r9
  jne    L593
  movhlps %xmm2,%xmm6
  movq   %xmm6,%rsi
  test   %rsi,%rsi
  jne    L3456
  movapd %xmm1,%xmm2
  movzbl %r8b,%r8d
  cmplepd %xmm0,%xmm2
  movq   %xmm2,%rsi
  add    %rsi,%r8
  jne    L3503
  movhlps %xmm2,%xmm7
  movq   %xmm7,%rsi
  cmp    $0xffffffffffffffff,%rsi
  jne    L3926
  movapd %xmm0,%xmm2
  movzbl %dil,%edi
  cmplepd %xmm1,%xmm2
  movq   %xmm2,%rsi
  add    %rsi,%rdi
  jne    L5790
  movhlps %xmm2,%xmm6
  movq   %xmm6,%rsi
  test   %rsi,%rsi
  jne    L1800
  movapd %xmm0,%xmm2
  movzbl %cl,%ecx
  cmpeqpd %xmm1,%xmm2
  movq   %xmm2,%rsi
  add    %rsi,%rcx
  jne    L482
  movhlps %xmm2,%xmm5
  movq   %xmm5,%rsi
  test   %rsi,%rsi
  jne    L1234
  cmpneqpd %xmm1,%xmm0
  movzbl %al,%eax
  movq   %xmm0,%rsi
  add    %rsi,%rax
  jne    L608
  movhlps %xmm0,%xmm7
  movq   %xmm7,%rsi
  cmp    $0xffffffffffffffff,%rsi
  jne    L3930
  add    $0xb58,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  ret
L2039:
  xor    %eax,%eax
  mov    $0x2,%r13d
L4869:
  movswl %ax,%ecx
  mov    %r13d,%edx
L2263:
  lea    D464(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L5241:
  mov    $0x3,%esi
  mov    $0x1,%edx
L712:
  mov    %esi,%ecx
  lea    D644(%rip),%rdi
  mov    %r11d,%esi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3623:
  mov    $0x3,%r11d
  mov    $0x1,%edx
L5752:
  mov    %r11d,%ecx
  lea    D615(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L4588:
  mov    $0x3,%ecx
  mov    $0x1,%edx
L1027:
  mov    %r11d,%esi
  lea    D288(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L999:
  movd   %xmm3,%r11d
  mov    $0x3,%esi
  mov    $0x1,%edx
L4985:
  mov    %esi,%ecx
  lea    D963(%rip),%rdi
  mov    %r11d,%esi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3489:
  mov    $0x3,%eax
  mov    $0x1,%r13d
L1120:
  movswl %ax,%ecx
  mov    %r13d,%edx
  lea    D644(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L5016:
  mov    $0xc,%eax
  mov    $0x6,%r13d
L3256:
  movswl %ax,%ecx
L5522:
  mov    %r13d,%edx
  mov    %r12d,%esi
  lea    D615(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L4247:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L3256
L5705:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L3256
L5376:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L3256
L3934:
  xor    %eax,%eax
  jmp    L3256
L1332:
  xor    %eax,%eax
  mov    $0x2,%r13d
L3042:
  movswl %ax,%ecx
  mov    %r13d,%edx
  lea    D288(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L2179:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L3042
L3474:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L3042
L5197:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L3042
L2379:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L3042
L854:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L3042
L2595:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L3042
L3856:
  xor    %eax,%eax
  jmp    L3042
L483:
  xor    %eax,%eax
  mov    $0x2,%r13d
L5262:
  movswl %ax,%ecx
  mov    %r13d,%edx
  lea    D963(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L4743:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L5262
L4493:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L5262
L4258:
  xor    %eax,%eax
  jmp    L1120
L2949:
  xor    %eax,%eax
  mov    $0x2,%r13d
  jmp    L3256
L335:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L3256
L215:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L3256
L3412:
  mov    $0xc,%eax
  mov    $0x6,%ebx
L3290:
  movzwl %ax,%ecx
  movzwl %bx,%edx
  lea    D157(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3385:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L3290
L3016:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L3290
L3402:
  mov    $0xa,%eax
  mov    $0x57,%ebx
L4548:
  movzwl %ax,%ecx
  movzwl %bx,%edx
  mov    %r12d,%esi
  xor    %eax,%eax
  lea    D208(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L5439:
  mov    $0xc,%eax
  mov    $0x6,%r11d
L5097:
  movsbl %al,%ecx
  movsbl %r11b,%edx
  lea    D927(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L370:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r11d
  jmp    L5097
L2506:
  mov    $0x2,%eax
  mov    $0x2,%r11d
  jmp    L5097
L2238:
  mov    $0x3,%eax
  mov    $0x1,%r11d
  jmp    L5097
L2647:
  xor    %eax,%eax
  jmp    L5097
L116:
  xor    %eax,%eax
  mov    $0x2,%ebx
  jmp    L3290
L3306:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L3290
L2226:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L3290
L593:
  pxor   %xmm1,%xmm1
L1789:
  movapd %xmm3,%xmm0
  lea    D349(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  call   <abort@plt>
L1513:
  mov    D906(%rip),%rax
  movsd  D843(%rip),%xmm1
  movq   %rax,%xmm3
L2610:
  movapd %xmm3,%xmm0
  lea    D707(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  call   <abort@plt>
L2240:
  pxor   %xmm1,%xmm1
  jmp    L2610
L2753:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%edx
  jmp    L2263
L608:
  pxor   %xmm1,%xmm1
L3554:
  movapd %xmm3,%xmm0
  lea    D522(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  call   <abort@plt>
L1234:
  mov    D906(%rip),%rax
  movsd  D843(%rip),%xmm1
  movq   %rax,%xmm3
L1799:
  movapd %xmm3,%xmm0
  lea    D454(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  call   <abort@plt>
L482:
  pxor   %xmm1,%xmm1
  jmp    L1799
L2464:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L3290
L2038:
  xor    %eax,%eax
  jmp    L3290
L3537:
  xor    %eax,%eax
  mov    $0x2,%ebx
  jmp    L4548
L4214:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L4548
L5717:
  mov    $0x3,%eax
  mov    $0x1,%r13d
L4391:
  movsbl %al,%ecx
  mov    %r13d,%edx
  mov    %r12d,%esi
  xor    %eax,%eax
  lea    D464(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L2447:
  xor    %eax,%eax
  jmp    L4391
L3557:
  xor    %eax,%eax
  mov    $0x2,%r11d
  jmp    L5097
L1386:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r11d
  jmp    L5097
L2339:
  mov    $0xa,%eax
  mov    $0x57,%r11d
  jmp    L5097
L5571:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L5262
L3310:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L5262
L5530:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L5262
L1490:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L5262
L1429:
  xor    %eax,%eax
  jmp    L5262
L5038:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L4869
L1457:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L4869
L2037:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L4869
L5847:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L4869
L4063:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L4869
L3739:
  movss  D891(%rip),%xmm1
  movss  D956(%rip),%xmm3
L2442:
  pxor   %xmm0,%xmm0
  lea    D522(%rip),%rdi
  mov    $0x2,%eax
  cvtss2sd %xmm1,%xmm1
  cvtss2sd %xmm3,%xmm0
  call   <printf@plt>
  call   <abort@plt>
L4236:
  movss  D230(%rip),%xmm3
  movaps %xmm3,%xmm1
  jmp    L2442
L5943:
  movss  D549(%rip),%xmm1
  movss  D209(%rip),%xmm3
  jmp    L2442
L3531:
  movaps %xmm4,%xmm1
  jmp    L2442
L2757:
  movss  D891(%rip),%xmm1
  movss  D956(%rip),%xmm3
L894:
  pxor   %xmm0,%xmm0
  mov    %r11d,%esi
  lea    D454(%rip),%rdi
  mov    $0x2,%eax
  cvtss2sd %xmm3,%xmm0
  cvtss2sd %xmm1,%xmm1
  call   <printf@plt>
  call   <abort@plt>
L4544:
  mov    $0x2,%ecx
  mov    $0x2,%edx
  jmp    L1027
L3454:
  mov    $0x2,%ecx
  mov    $0x2,%edx
  jmp    L2263
L856:
  mov    $0x3,%ecx
  mov    $0x1,%edx
  jmp    L2263
L55:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%edx
  jmp    L1027
L307:
  mov    $0xffffffe9,%esi
  mov    $0xa,%edx
  jmp    L4985
L159:
  mov    $0x2,%esi
  mov    $0x2,%edx
  jmp    L4985
L3719:
  movd   %xmm2,%esi
  mov    $0x2,%ecx
  mov    $0x2,%edx
L2695:
  lea    D927(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L4476:
  mov    $0x3,%ecx
  mov    $0x1,%edx
  jmp    L2695
L456:
  xor    %ecx,%ecx
  jmp    L2695
L1800:
  mov    D906(%rip),%rax
  movsd  D843(%rip),%xmm1
  movq   %rax,%xmm3
L5099:
  movapd %xmm3,%xmm0
  lea    D810(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  call   <abort@plt>
L5790:
  pxor   %xmm1,%xmm1
  jmp    L5099
L3926:
  mov    D906(%rip),%rax
  movsd  D843(%rip),%xmm1
  movq   %rax,%xmm3
L5552:
  movapd %xmm3,%xmm0
  lea    D611(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  call   <abort@plt>
L3503:
  pxor   %xmm1,%xmm1
  jmp    L5552
L3456:
  mov    D906(%rip),%rax
  movsd  D843(%rip),%xmm1
  movq   %rax,%xmm3
  jmp    L1789
L585:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L4548
L1134:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L4548
L3542:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L4548
L3957:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L4548
L4169:
  xor    %eax,%eax
  jmp    L4548
L2265:
  xor    %eax,%eax
  mov    $0x2,%ebx
L5834:
  movzwl %ax,%ecx
  movzwl %bx,%edx
  lea    D725(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L5965:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L5834
L5042:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L5834
L626:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L5834
L3305:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L5834
L766:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L5834
L3972:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L5834
L2352:
  xor    %eax,%eax
  jmp    L5834
L516:
  xor    %eax,%eax
  mov    $0x2,%ebx
L4382:
  movzwl %ax,%ecx
  movzwl %bx,%edx
  lea    D827(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3150:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L4382
L1480:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L4382
L5381:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L4382
L4455:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L4382
L4794:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L4382
L753:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L4382
L2895:
  xor    %eax,%eax
  jmp    L4382
L1762:
  xor    %eax,%eax
  mov    $0x2,%ebx
L2493:
  movzwl %ax,%ecx
  movzwl %bx,%edx
  lea    D919(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L4348:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L2493
L1972:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L2493
L3239:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L2493
L2099:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L2493
L2848:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L2493
L5136:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L2493
L1063:
  xor    %eax,%eax
  jmp    L2493
L3797:
  xor    %eax,%eax
  mov    $0x2,%ebx
L562:
  movzwl %ax,%ecx
  movzwl %bx,%edx
  mov    %r11d,%esi
  xor    %eax,%eax
  lea    D812(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L5544:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L562
L4550:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L562
L225:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L562
L1463:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L562
L1200:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L562
L1645:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L562
L5865:
  xor    %eax,%eax
  jmp    L562
L5806:
  xor    %eax,%eax
  mov    $0x2,%r13d
  jmp    L1120
L5711:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L1120
L3240:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L1120
L4074:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L1120
L1233:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L1120
L3487:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L1120
L3930:
  mov    D906(%rip),%rax
  movsd  D843(%rip),%xmm1
  movq   %rax,%xmm3
  jmp    L3554
L2882:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%edx
  jmp    L2695
L3408:
  mov    $0xffffffe9,%r11d
  mov    $0xa,%edx
  jmp    L5752
L1593:
  mov    $0x2,%r11d
  mov    $0x2,%edx
  jmp    L5752
L5616:
  xor    %ecx,%ecx
L4706:
  mov    %r11d,%edx
  lea    D725(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3717:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%r11d
L727:
  mov    %r11d,%edx
  lea    D827(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3173:
  mov    $0x2,%ecx
  mov    $0x2,%r11d
  jmp    L727
L3369:
  mov    $0x3,%ecx
  mov    $0x1,%r11d
  jmp    L727
L4241:
  xor    %ecx,%ecx
  jmp    L727
L2967:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%r11d
L1154:
  mov    %r11d,%edx
  lea    D919(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L5347:
  mov    $0x2,%ecx
  mov    $0x2,%r11d
  jmp    L1154
L1347:
  mov    $0x3,%ecx
  mov    $0x1,%r11d
  jmp    L1154
L406:
  xor    %ecx,%ecx
  jmp    L1154
L1320:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%r11d
L1436:
  mov    %r11d,%edx
  lea    D812(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L1756:
  mov    $0x2,%ecx
  mov    $0x2,%r11d
  jmp    L1436
L1002:
  mov    $0x3,%ecx
  mov    $0x1,%r11d
  jmp    L1436
L2443:
  xor    %ecx,%ecx
  jmp    L1436
L5207:
  mov    $0xffffffe9,%esi
  mov    $0xa,%edx
  jmp    L712
L4263:
  mov    $0x2,%esi
  mov    $0x2,%edx
  jmp    L712
L3983:
  movss  D230(%rip),%xmm3
  movaps %xmm3,%xmm1
  jmp    L894
L5563:
  movss  D549(%rip),%xmm1
  movss  D209(%rip),%xmm3
  jmp    L894
L1681:
  movaps %xmm4,%xmm1
  jmp    L894
L2048:
  movss  D891(%rip),%xmm1
  movss  D956(%rip),%xmm3
L4724:
  pxor   %xmm0,%xmm0
  lea    D810(%rip),%rdi
  mov    $0x2,%eax
  cvtss2sd %xmm1,%xmm1
  cvtss2sd %xmm3,%xmm0
  call   <printf@plt>
  call   <abort@plt>
L4958:
  movss  D230(%rip),%xmm3
  movaps %xmm3,%xmm1
  jmp    L4724
L4369:
  movss  D549(%rip),%xmm1
  movss  D209(%rip),%xmm3
  jmp    L4724
L3708:
  movaps %xmm4,%xmm1
  jmp    L4724
L4522:
  movss  D891(%rip),%xmm1
  movss  D956(%rip),%xmm3
L3514:
  pxor   %xmm0,%xmm0
  lea    D611(%rip),%rdi
  mov    $0x2,%eax
  cvtss2sd %xmm1,%xmm1
  cvtss2sd %xmm3,%xmm0
  call   <printf@plt>
  call   <abort@plt>
L4707:
  movss  D230(%rip),%xmm3
  movaps %xmm3,%xmm1
  jmp    L3514
L4629:
  movss  D549(%rip),%xmm1
  movss  D209(%rip),%xmm3
  jmp    L3514
L1575:
  movaps %xmm4,%xmm1
  jmp    L3514
L1443:
  movss  D891(%rip),%xmm1
  movss  D956(%rip),%xmm3
L5096:
  pxor   %xmm0,%xmm0
  lea    D349(%rip),%rdi
  mov    $0x2,%eax
  cvtss2sd %xmm1,%xmm1
  cvtss2sd %xmm3,%xmm0
  call   <printf@plt>
  call   <abort@plt>
L1535:
  movss  D230(%rip),%xmm3
  movaps %xmm3,%xmm1
  jmp    L5096
L3873:
  movss  D549(%rip),%xmm1
  movss  D209(%rip),%xmm3
  jmp    L5096
L2279:
  movaps %xmm4,%xmm1
  jmp    L5096
L3287:
  movss  D891(%rip),%xmm1
  movss  D956(%rip),%xmm3
L4174:
  pxor   %xmm0,%xmm0
  lea    D707(%rip),%rdi
  mov    $0x2,%eax
  cvtss2sd %xmm1,%xmm1
  cvtss2sd %xmm3,%xmm0
  call   <printf@plt>
  call   <abort@plt>
L5937:
  movss  D230(%rip),%xmm1
  movaps %xmm1,%xmm3
  jmp    L4174
L3644:
  movss  D549(%rip),%xmm1
  movss  D209(%rip),%xmm3
  jmp    L4174
L4454:
  movaps %xmm4,%xmm1
  jmp    L4174
L4730:
  xor    %eax,%eax
  mov    $0x2,%ebx
L3189:
  movzbl %al,%ecx
  movzbl %bl,%edx
  lea    D157(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L5424:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L3189
L2248:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L3189
L1541:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L3189
L4404:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L3189
L1641:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L3189
L596:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L3189
L2118:
  xor    %eax,%eax
  jmp    L3189
L1694:
  xor    %eax,%eax
  mov    $0x2,%ebx
L5216:
  movzbl %al,%ecx
  movzbl %bl,%edx
  lea    D208(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L367:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L5216
L5766:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L5216
L3406:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L5216
L3673:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L5216
L5273:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L5216
L3384:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L5216
L1592:
  xor    %eax,%eax
  jmp    L5216
L3335:
  xor    %eax,%eax
L3217:
  movzbl %al,%ecx
  movzbl %bl,%edx
  lea    D725(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L3330:
  xor    %eax,%eax
  mov    $0x2,%ebx
  jmp    L3217
L3533:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L3217
L5595:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L3217
L3415:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L3217
L3200:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L3217
L5253:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L3217
L2143:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L3217
L1102:
  mov    %ebp,%esi
  xor    %eax,%eax
  jmp    L3217
L903:
  xor    %eax,%eax
  mov    $0x2,%ebx
L1682:
  movzbl %al,%ecx
  movzbl %bl,%edx
  lea    D827(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L2697:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L1682
L1559:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L1682
L485:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L1682
L4449:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L1682
L3201:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L1682
L5092:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L1682
L2707:
  xor    %eax,%eax
  jmp    L1682
L3269:
  xor    %eax,%eax
  mov    $0x2,%ebx
L1367:
  movzbl %al,%ecx
  movzbl %bl,%edx
  lea    D919(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L5453:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L1367
L5317:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L1367
L4975:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L1367
L1067:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L1367
L2782:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L1367
L966:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L1367
L2962:
  xor    %eax,%eax
  jmp    L1367
L3226:
  mov    %r11d,%ebp
L4762:
  xor    %eax,%eax
  jmp    L63
L4410:
  xor    %eax,%eax
  mov    $0x2,%ebx
L63:
  movzbl %al,%ecx
  movzbl %bl,%edx
  mov    %ebp,%esi
  xor    %eax,%eax
  lea    D812(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L4671:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%ebx
  jmp    L63
L5114:
  mov    $0xa,%eax
  mov    $0x57,%ebx
  jmp    L63
L1290:
  mov    $0xc,%eax
  mov    $0x6,%ebx
  jmp    L63
L5518:
  mov    $0xffffffe9,%eax
  mov    $0xa,%ebx
  jmp    L63
L2008:
  mov    $0x2,%eax
  mov    $0x2,%ebx
  jmp    L63
L5951:
  mov    $0x3,%eax
  mov    $0x1,%ebx
  jmp    L63
L2388:
  xor    %eax,%eax
  mov    $0x2,%r13d
L3894:
  movsbl %al,%ecx
  mov    %r13d,%edx
  mov    %r12d,%esi
  xor    %eax,%eax
  lea    D644(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L5491:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L3894
L1191:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L3894
L690:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L3894
L5816:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L3894
L2002:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L3894
L2419:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L3894
L3112:
  xor    %eax,%eax
  jmp    L3894
L1768:
  xor    %eax,%eax
  mov    $0x2,%r13d
L2500:
  movsbl %al,%ecx
  jmp    L5522
L5909:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L2500
L833:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L2500
L4855:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L2500
L1010:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L2500
L4658:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L2500
L5600:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L2500
L4282:
  xor    %eax,%eax
  jmp    L2500
L3724:
  xor    %eax,%eax
  mov    $0x2,%r13d
L5420:
  movsbl %al,%ecx
  mov    %r13d,%edx
  mov    %r12d,%esi
  xor    %eax,%eax
  lea    D288(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L1801:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L5420
L1520:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L5420
L1986:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L5420
L2450:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L5420
L205:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L5420
L711:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L5420
L1152:
  xor    %eax,%eax
  jmp    L5420
L2441:
  xor    %eax,%eax
  mov    $0x2,%r13d
L4687:
  movsbl %al,%ecx
  mov    %r13d,%edx
  mov    %r12d,%esi
  xor    %eax,%eax
  lea    D963(%rip),%rdi
  call   <printf@plt>
  call   <abort@plt>
L1228:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L4687
L234:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L4687
L5753:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L4687
L1225:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L4687
L1529:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L4687
L1033:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L4687
L2846:
  xor    %eax,%eax
  jmp    L4687
L889:
  xor    %eax,%eax
  mov    $0x2,%r13d
  jmp    L4391
L3223:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r13d
  jmp    L4391
L2797:
  mov    $0xa,%eax
  mov    $0x57,%r13d
  jmp    L4391
L53:
  mov    $0xc,%eax
  mov    $0x6,%r13d
  jmp    L4391
L2810:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r13d
  jmp    L4391
L5284:
  mov    $0x2,%eax
  mov    $0x2,%r13d
  jmp    L4391
L1246:
  mov    $0x3,%eax
  mov    $0x1,%r13d
  jmp    L4869
L1014:
  xor    %eax,%eax
  jmp    L4869
L2701:
  xor    %eax,%eax
  mov    $0x2,%r11d
L4917:
  movswl %ax,%ecx
  movswl %r11w,%edx
  jmp    L2695
L1362:
  mov    $0xfffffffe,%eax
  mov    $0xfffffffb,%r11d
  jmp    L4917
L725:
  mov    $0xa,%eax
  mov    $0x57,%r11d
  jmp    L4917
L3481:
  mov    $0xc,%eax
  mov    $0x6,%r11d
  jmp    L4917
L820:
  mov    $0xffffffe9,%eax
  mov    $0xa,%r11d
  jmp    L4917
L4145:
  mov    $0x2,%eax
  mov    $0x2,%r11d
  jmp    L4917
L2208:
  mov    $0x3,%eax
  mov    $0x1,%r11d
  jmp    L4917
L1039:
  xor    %eax,%eax
  jmp    L4917
L2490:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%r11d
L4221:
  mov    %r11d,%edx
  lea    D157(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L942:
  mov    $0x2,%ecx
  mov    $0x2,%r11d
  jmp    L4221
L4969:
  mov    $0x3,%ecx
  mov    $0x1,%r11d
  jmp    L4221
L5590:
  xor    %ecx,%ecx
  jmp    L4221
L2835:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%r11d
L2662:
  mov    %r11d,%edx
  lea    D208(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  call   <abort@plt>
L1403:
  mov    $0x2,%ecx
  mov    $0x2,%r11d
  jmp    L2662
L3439:
  mov    $0x3,%ecx
  mov    $0x1,%r11d
  jmp    L2662
L5227:
  xor    %ecx,%ecx
  jmp    L2662
L3809:
  mov    $0xffffffe9,%ecx
  mov    $0xa,%r11d
  jmp    L4706
L5301:
  mov    $0x2,%ecx
  mov    $0x2,%r11d
  jmp    L4706
L5628:
  mov    $0x3,%ecx
  mov    $0x1,%r11d
  jmp    L4706
```

tool_calls: name: parse_data
arguments: label: D207
type_infered: f32[4]
name: parse_data
arguments: label: D950
type_infered: f32[4]
name: parse_data
arguments: label: D559
type_infered: byte[16]
name: parse_data
arguments: label: D89
type_infered: byte[16]
name: parse_data
arguments: label: D948
type_infered: byte[16]
name: parse_data
arguments: label: D640
type_infered: byte[16]
name: parse_data
arguments: label: D459
type_infered: f32[4]
name: parse_data
arguments: label: D647
type_infered: f32[4]
name: parse_data
arguments: label: D47
type_infered: f32[4]
name: parse_data
arguments: label: D906
type_infered: f64
name: parse_data
arguments: label: D464
type_infered: string
name: parse_data
arguments: label: D644
type_infered: string
name: parse_data
arguments: label: D615
type_infered: string
name: parse_data
arguments: label: D288
type_infered: string
name: parse_data
arguments: label: D963
type_infered: string
name: parse_data
arguments: label: D157
type_infered: string
name: parse_data
arguments: label: D208
type_infered: string
name: parse_data
arguments: label: D927
type_infered: string
name: parse_data
arguments: label: D349
type_infered: string
name: parse_data
arguments: label: D843
type_infered: f32[2]
name: parse_data
arguments: label: D707
type_infered: string
name: parse_data
arguments: label: D522
type_infered: string
name: parse_data
arguments: label: D454
type_infered: string
name: parse_data
arguments: label: D891
type_infered: byte[4]
name: parse_data
arguments: label: D956
type_infered: byte[4]
name: parse_data
arguments: label: D230
type_infered: f32
name: parse_data
arguments: label: D549
type_infered: f32
name: parse_data
arguments: label: D209
type_infered: f32
name: parse_data
arguments: label: D810
type_infered: string
name: parse_data
arguments: label: D611
type_infered: string
name: parse_data
arguments: label: D725
type_infered: string
name: parse_data
arguments: label: D827
type_infered: string
name: parse_data
arguments: label: D919
type_infered: string
name: parse_data
arguments: label: D812
type_infered: string

tool: {"D207": [0.0,1.401298464324817e-45,2.802596928649634e-45,1.401298464324817e-44]}

tool: {"D950": [0.0,4.203895392974451e-45,2.802596928649634e-45,null]}

tool: {"D559": [0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x80]}

tool: {"D89": [0x00,0x00,0x01,0x00,0x02,0x00,0x0a,0x00,0x06,0x00,0x57,0x00,0xfb,0xff,0x02,0x00]}

tool: {"D948": [0x00,0x00,0x03,0x00,0x02,0x00,0xe9,0xff,0x0c,0x00,0x0a,0x00,0xfe,0xff,0x00,0x00]}

tool: {"D640": [0x00,0x03,0x02,0xe9,0x0c,0x0a,0xfe,0x00,0x00,0x03,0x02,0xe9,0x0c,0x0a,0xfe,0x00]}

tool: {"D459": [0.0,1.0,2.0,10.0]}

tool: {"D647": [0.0,3.0,2.0,-23.0]}

tool: {"D47": [0.0,0.0,0.0,-2.859375]}

tool: D906: 10

tool: D464: %i != ((%i < %i ? -1 : 0) 

tool: D644: %i != ((%i != %i ? -1 : 0) 

tool: D615: %i != ((%i == %i ? -1 : 0) 

tool: D288: %i != ((%i <= %i ? -1 : 0) 

tool: D963: %i != ((%i >= %i ? -1 : 0) 

tool: D157: %i != ((%u != %u ? -1 : 0) 

tool: D208: %i != ((%u == %u ? -1 : 0) 

tool: D927: %i != ((%i > %i ? -1 : 0) 

tool: D349: %i != ((%f < %f ? -1 : 0) 

tool: {"D843": [0.0,-2.859375]}

tool: D707: %i != ((%f > %f ? -1 : 0) 

tool: D522: %i != ((%f != %f ? -1 : 0) 

tool: D454: %i != ((%f == %f ? -1 : 0) 

tool: {"D891": [0x00,0x00,0xb8,0xc1]}

tool: {"D956": [0x00,0x00,0x20,0x41]}

tool: D230: 2

tool: D549: 3

tool: D209: 1

tool: D810: %i != ((%f <= %f ? -1 : 0) 

tool: D611: %i != ((%f >= %f ? -1 : 0) 

tool: D725: %i != ((%u <= %u ? -1 : 0) 

tool: D827: %i != ((%u >= %u ? -1 : 0) 

tool: D919: %i != ((%u < %u ? -1 : 0) 

tool: D812: %i != ((%u > %u ? -1 : 0) 

assistant: ```c
int main(int argc, char *argv[]) {
  __attribute__((vector_size((4) * sizeof(int)))) int i0;
  __attribute__((vector_size((4) * sizeof(int)))) int i1;
  __attribute__((vector_size((4) * sizeof(int)))) int ires;
  int i;
  i0 = (__attribute__((vector_size((4) * sizeof(int)))) int){argc, 1, 2, 10};
  i1 = (__attribute__((vector_size((4) * sizeof(int)))) int){0, 3, 2, (int)-23};
  ;
  do {
    ires = (i0 > i1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ires)[__i] != ((i0)[__i] > (i1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           ">"
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (ires)[__i], (i0)[__i], (i1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ires = (i0 < i1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ires)[__i] != ((i0)[__i] < (i1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "<"
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (ires)[__i], (i0)[__i], (i1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ires = (i0 >= i1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ires)[__i] != ((i0)[__i] >= (i1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           ">="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (ires)[__i], (i0)[__i], (i1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ires = (i0 <= i1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ires)[__i] != ((i0)[__i] <= (i1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "<="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (ires)[__i], (i0)[__i], (i1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ires = (i0 == i1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ires)[__i] != ((i0)[__i] == (i1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "=="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (ires)[__i], (i0)[__i], (i1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ires = (i0 != i1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ires)[__i] != ((i0)[__i] != (i1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "!="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (ires)[__i], (i0)[__i], (i1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((4) * sizeof(int)))) int ures;
  __attribute__((vector_size((4) * sizeof(unsigned int)))) unsigned int u0;
  __attribute__((vector_size((4) * sizeof(unsigned int)))) unsigned int u1;
  u0 = (__attribute__((vector_size((4) * sizeof(unsigned int)))) unsigned int){argc, 1, 2, 10};
  u1 = (__attribute__((vector_size((4) * sizeof(unsigned int)))) unsigned int){0, 3, 2, (unsigned int)-23};
  ;
  do {
    ures = (u0 > u1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ures)[__i] != ((u0)[__i] > (u1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           ">"
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ures)[__i], (u0)[__i], (u1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ures = (u0 < u1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ures)[__i] != ((u0)[__i] < (u1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "<"
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ures)[__i], (u0)[__i], (u1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ures = (u0 >= u1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ures)[__i] != ((u0)[__i] >= (u1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           ">="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ures)[__i], (u0)[__i], (u1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ures = (u0 <= u1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ures)[__i] != ((u0)[__i] <= (u1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "<="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ures)[__i], (u0)[__i], (u1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ures = (u0 == u1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ures)[__i] != ((u0)[__i] == (u1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "=="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ures)[__i], (u0)[__i], (u1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ures = (u0 != u1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ures)[__i] != ((u0)[__i] != (u1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "!="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ures)[__i], (u0)[__i], (u1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((8) * sizeof(short)))) short s0;
  __attribute__((vector_size((8) * sizeof(short)))) short s1;
  __attribute__((vector_size((8) * sizeof(short)))) short sres;
  s0 = (__attribute__((vector_size((8) * sizeof(short)))) short){argc, 1, 2, 10, 6, 87, (short)-5, 2};
  s1 = (__attribute__((vector_size((8) * sizeof(short)))) short){0, 3, 2, (short)-23, 12, 10, (short)-2, 0};
  ;
  do {
    sres = (s0 > s1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((sres)[__i] != ((s0)[__i] > (s1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           ">"
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (sres)[__i], (s0)[__i], (s1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    sres = (s0 < s1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((sres)[__i] != ((s0)[__i] < (s1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "<"
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (sres)[__i], (s0)[__i], (s1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    sres = (s0 >= s1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((sres)[__i] != ((s0)[__i] >= (s1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           ">="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (sres)[__i], (s0)[__i], (s1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    sres = (s0 <= s1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((sres)[__i] != ((s0)[__i] <= (s1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "<="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (sres)[__i], (s0)[__i], (s1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    sres = (s0 == s1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((sres)[__i] != ((s0)[__i] == (s1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "=="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (sres)[__i], (s0)[__i], (s1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    sres = (s0 != s1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((sres)[__i] != ((s0)[__i] != (s1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "!="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (sres)[__i], (s0)[__i], (s1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((8) * sizeof(unsigned short)))) unsigned short us0;
  __attribute__((vector_size((8) * sizeof(unsigned short)))) unsigned short us1;
  __attribute__((vector_size((8) * sizeof(short)))) short usres;
  us0 = (__attribute__((vector_size((8) * sizeof(unsigned short)))) unsigned short){argc, 1, 2, 10, 6, 87, (unsigned short)-5, 2};
  us1 = (__attribute__((vector_size((8) * sizeof(unsigned short)))) unsigned short){0, 3, 2, (unsigned short)-23, 12, 10, (unsigned short)-2, 0};
  ;
  do {
    usres = (us0 > us1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((usres)[__i] != ((us0)[__i] > (us1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           ">"
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (usres)[__i], (us0)[__i], (us1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    usres = (us0 < us1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((usres)[__i] != ((us0)[__i] < (us1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "<"
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (usres)[__i], (us0)[__i], (us1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    usres = (us0 >= us1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((usres)[__i] != ((us0)[__i] >= (us1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           ">="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (usres)[__i], (us0)[__i], (us1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    usres = (us0 <= us1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((usres)[__i] != ((us0)[__i] <= (us1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "<="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (usres)[__i], (us0)[__i], (us1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    usres = (us0 == us1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((usres)[__i] != ((us0)[__i] == (us1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "=="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (usres)[__i], (us0)[__i], (us1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    usres = (us0 != us1);
    do {
      int __i;
      for (__i = 0; __i < 8; __i++) {
        if ((usres)[__i] != ((us0)[__i] != (us1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "!="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (usres)[__i], (us0)[__i], (us1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((16) * sizeof(signed char)))) signed char c0;
  __attribute__((vector_size((16) * sizeof(signed char)))) signed char c1;
  __attribute__((vector_size((16) * sizeof(signed char)))) signed char cres;
  c0 = (__attribute__((vector_size((16) * sizeof(signed char)))) signed char){argc, 1, 2, 10, 6, 87, (signed char)-5, 2, argc, 1, 2, 10, 6, 87, (signed char)-5, 2};
  c1 = (__attribute__((vector_size((16) * sizeof(signed char)))) signed char){0, 3, 2, (signed char)-23, 12, 10, (signed char)-2, 0, 0, 3, 2, (signed char)-23, 12, 10, (signed char)-2, 0};
  ;
  do {
    cres = (c0 > c1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((cres)[__i] != ((c0)[__i] > (c1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           ">"
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (cres)[__i], (c0)[__i], (c1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    cres = (c0 < c1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((cres)[__i] != ((c0)[__i] < (c1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "<"
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (cres)[__i], (c0)[__i], (c1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    cres = (c0 >= c1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((cres)[__i] != ((c0)[__i] >= (c1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           ">="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (cres)[__i], (c0)[__i], (c1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    cres = (c0 <= c1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((cres)[__i] != ((c0)[__i] <= (c1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "<="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (cres)[__i], (c0)[__i], (c1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    cres = (c0 == c1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((cres)[__i] != ((c0)[__i] == (c1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "=="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (cres)[__i], (c0)[__i], (c1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    cres = (c0 != c1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((cres)[__i] != ((c0)[__i] != (c1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%i"
                           " "
                           "!="
                           " "
                           "%i"
                           " ? -1 : 0) ",
                           (cres)[__i], (c0)[__i], (c1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((16) * sizeof(unsigned char)))) unsigned char uc0;
  __attribute__((vector_size((16) * sizeof(unsigned char)))) unsigned char uc1;
  __attribute__((vector_size((16) * sizeof(signed char)))) signed char ucres;
  uc0 = (__attribute__((vector_size((16) * sizeof(unsigned char)))) unsigned char){argc, 1, 2, 10, 6, 87, (unsigned char)-5, 2, argc, 1, 2, 10, 6, 87, (unsigned char)-5, 2};
  uc1 = (__attribute__((vector_size((16) * sizeof(unsigned char)))) unsigned char){0, 3, 2, (unsigned char)-23, 12, 10, (unsigned char)-2, 0, 0, 3, 2, (unsigned char)-23, 12, 10, (unsigned char)-2, 0};
  ;
  do {
    ucres = (uc0 > uc1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((ucres)[__i] != ((uc0)[__i] > (uc1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           ">"
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ucres)[__i], (uc0)[__i], (uc1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ucres = (uc0 < uc1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((ucres)[__i] != ((uc0)[__i] < (uc1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "<"
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ucres)[__i], (uc0)[__i], (uc1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ucres = (uc0 >= uc1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((ucres)[__i] != ((uc0)[__i] >= (uc1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           ">="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ucres)[__i], (uc0)[__i], (uc1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ucres = (uc0 <= uc1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((ucres)[__i] != ((uc0)[__i] <= (uc1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "<="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ucres)[__i], (uc0)[__i], (uc1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ucres = (uc0 == uc1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((ucres)[__i] != ((uc0)[__i] == (uc1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "=="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ucres)[__i], (uc0)[__i], (uc1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ucres = (uc0 != uc1);
    do {
      int __i;
      for (__i = 0; __i < 16; __i++) {
        if ((ucres)[__i] != ((uc0)[__i] != (uc1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%u"
                           " "
                           "!="
                           " "
                           "%u"
                           " ? -1 : 0) ",
                           (ucres)[__i], (uc0)[__i], (uc1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((4) * sizeof(float)))) float f0;
  __attribute__((vector_size((4) * sizeof(float)))) float f1;
  __typeof(f0 == f1) ifres;
  f0 = (__attribute__((vector_size((4) * sizeof(float)))) float){(float)argc, 1., 2., 10.};
  f1 = (__attribute__((vector_size((4) * sizeof(float)))) float){0., 3., 2., (float)-23};
  ;
  do {
    ifres = (f0 > f1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ifres)[__i] != ((f0)[__i] > (f1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           ">"
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (ifres)[__i], (f0)[__i], (f1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ifres = (f0 < f1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ifres)[__i] != ((f0)[__i] < (f1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "<"
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (ifres)[__i], (f0)[__i], (f1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ifres = (f0 >= f1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ifres)[__i] != ((f0)[__i] >= (f1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           ">="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (ifres)[__i], (f0)[__i], (f1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ifres = (f0 <= f1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ifres)[__i] != ((f0)[__i] <= (f1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "<="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (ifres)[__i], (f0)[__i], (f1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ifres = (f0 == f1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ifres)[__i] != ((f0)[__i] == (f1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "=="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (ifres)[__i], (f0)[__i], (f1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    ifres = (f0 != f1);
    do {
      int __i;
      for (__i = 0; __i < 4; __i++) {
        if ((ifres)[__i] != ((f0)[__i] != (f1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "!="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (ifres)[__i], (f0)[__i], (f1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  __attribute__((vector_size((2) * sizeof(double)))) double d0;
  __attribute__((vector_size((2) * sizeof(double)))) double d1;
  __typeof(d0 == d1) idres;
  d0 = (__attribute__((vector_size((2) * sizeof(double)))) double){(double)argc, 10.};
  d1 = (__attribute__((vector_size((2) * sizeof(double)))) double){0., (double)-23};
  ;
  do {
    idres = (d0 > d1);
    do {
      int __i;
      for (__i = 0; __i < 2; __i++) {
        if ((idres)[__i] != ((d0)[__i] > (d1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           ">"
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (idres)[__i], (d0)[__i], (d1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    idres = (d0 < d1);
    do {
      int __i;
      for (__i = 0; __i < 2; __i++) {
        if ((idres)[__i] != ((d0)[__i] < (d1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "<"
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (idres)[__i], (d0)[__i], (d1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    idres = (d0 >= d1);
    do {
      int __i;
      for (__i = 0; __i < 2; __i++) {
        if ((idres)[__i] != ((d0)[__i] >= (d1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           ">="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (idres)[__i], (d0)[__i], (d1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    idres = (d0 <= d1);
    do {
      int __i;
      for (__i = 0; __i < 2; __i++) {
        if ((idres)[__i] != ((d0)[__i] <= (d1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "<="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (idres)[__i], (d0)[__i], (d1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    idres = (d0 == d1);
    do {
      int __i;
      for (__i = 0; __i < 2; __i++) {
        if ((idres)[__i] != ((d0)[__i] == (d1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "=="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (idres)[__i], (d0)[__i], (d1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
    idres = (d0 != d1);
    do {
      int __i;
      for (__i = 0; __i < 2; __i++) {
        if ((idres)[__i] != ((d0)[__i] != (d1)[__i] ? -1 : 0)) {
          __builtin_printf("%i != (("
                           "%f"
                           " "
                           "!="
                           " "
                           "%f"
                           " ? -1 : 0) ",
                           (idres)[__i], (d0)[__i], (d1)[__i]);
          __builtin_abort();
        }
      }
    } while (0);
  } while (0);
  return 0;
}
```