user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x1d000(%rsp),%r11
L1159:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L1159
  sub    $0x9a8,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x1d998(%rsp)
  xor    %eax,%eax
  lea    0x340(%rsp),%r13
  call   <check_offloading@plt>
  xor    %eax,%eax
  call   <omp_is_initial_device@plt>
  lea    0x20(%rsp),%rdi
  mov    $0x32,%ecx
  lea    0x1b0(%rsp),%rsi
  cltq
  mov    %rsi,0x8(%rsp)
  mov    %rax,0x18(%rsp)
  mov    $0xffffffffffffffff,%rax
  mov    %rdi,0x10(%rsp)
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1396:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1396
  cmpq   $0x0,0x18(%rsp)
  jne    L1040
  xor    %eax,%eax
L1778:
  mov    0x8(%rsp),%rbx
  mov    0x10(%rsp),%rdi
  mov    0x0(%r13,%rax,1),%edx
  add    (%rbx,%rax,1),%edx
  add    %edx,(%rdi,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1778
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1421:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L314
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L314:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1421
  test   %eax,%eax
  jne    L379
L1040:
  lea    D319(%rip),%rdi
  call   <puts@plt>
L242:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1417:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1417
  cmpq   $0x0,0x18(%rsp)
  jne    L371
  xor    %eax,%eax
  mov    $0xfffffffd,%ecx
L1369:
  mov    0x8(%rsp),%rbx
  lea    0x2(%rcx,%rax,1),%ecx
  lea    0x5(%rax),%edx
  imul   0x0(%r13,%rax,4),%edx
  mov    (%rbx,%rax,4),%esi
  imul   %ecx,%esi
  lea    0xa(%rdx,%rsi,1),%edx
  mov    0x10(%rsp),%rsi
  add    %edx,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1369
  xor    %ebx,%ebx
  xor    %edi,%edi
  lea    D427(%rip),%r14
L1766:
  lea    -0x1(%rbx),%eax
  lea    0x5(%rbx),%edx
  mov    %ebx,%esi
  imul   %ebx,%edx
  imul   %ebx,%eax
  lea    0x9(%rax,%rdx,2),%eax
  lea    (%rax,%rbx,2),%ecx
  mov    0x10(%rsp),%rax
  mov    (%rax,%rbx,4),%edx
  cmp    %ecx,%edx
  je     L1728
  mov    %r14,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
L1728:
  add    $0x1,%rbx
  cmp    $0x64,%rbx
  jne    L1766
  test   %edi,%edi
  jne    L463
L371:
  lea    D423(%rip),%rdi
  call   <puts@plt>
L1054:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1807:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1807
  cmpq   $0x0,0x18(%rsp)
  jne    L640
  xor    %eax,%eax
L1703:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1703
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L361:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1051
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1051:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L361
  test   %eax,%eax
  jne    L48
L640:
  lea    D561(%rip),%rdi
  call   <puts@plt>
L781:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L921:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L921
  cmpq   $0x0,0x18(%rsp)
  jne    L1760
  xor    %eax,%eax
L1798:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1798
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L518:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L568
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L568:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L518
  test   %eax,%eax
  jne    L153
L1760:
  lea    D671(%rip),%rdi
  call   <puts@plt>
L59:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1263:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1263
  cmpq   $0x0,0x18(%rsp)
  jne    L1016
  xor    %eax,%eax
L729:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L729
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1295:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L39
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L39:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1295
  test   %eax,%eax
  jne    L770
L1016:
  lea    D282(%rip),%rdi
  call   <puts@plt>
L751:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1456:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1456
  cmpq   $0x0,0x18(%rsp)
  jne    L122
  xor    %eax,%eax
L10:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L10
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1714:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1824
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1824:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1714
  test   %eax,%eax
  jne    L372
L122:
  lea    D597(%rip),%rdi
  call   <puts@plt>
L1616:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L210:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L210
  cmpq   $0x0,0x18(%rsp)
  jne    L1679
  xor    %eax,%eax
L802:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L802
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L302:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1021
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1021:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L302
  test   %eax,%eax
  jne    L1529
L1679:
  lea    D413(%rip),%rdi
  call   <puts@plt>
L590:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L35:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L35
  cmpq   $0x0,0x18(%rsp)
  jne    L114
  xor    %eax,%eax
L1701:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1701
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L527:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1101
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1101:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L527
  test   %eax,%eax
  jne    L303
L114:
  lea    D623(%rip),%rdi
  call   <puts@plt>
L1482:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L271:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L271
  cmpq   $0x0,0x18(%rsp)
  jne    L324
  xor    %eax,%eax
L312:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L312
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L623:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L50
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L50:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L623
  test   %eax,%eax
  jne    L165
L324:
  lea    D157(%rip),%rdi
  call   <puts@plt>
L709:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L284:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L284
  cmpq   $0x0,0x18(%rsp)
  jne    L316
  xor    %eax,%eax
L1355:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1355
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1802:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1186
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1186:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1802
  test   %eax,%eax
  jne    L229
L316:
  lea    D410(%rip),%rdi
  call   <puts@plt>
L1445:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1524:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1524
  cmpq   $0x0,0x18(%rsp)
  jne    L1372
  xor    %eax,%eax
L508:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L508
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1130:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L411
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L411:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1130
  test   %eax,%eax
  jne    L811
L1372:
  lea    D357(%rip),%rdi
  call   <puts@plt>
L30:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1024:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1024
  cmpq   $0x0,0x18(%rsp)
  jne    L593
  xor    %eax,%eax
L798:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L798
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L186:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L610
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L610:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L186
  test   %eax,%eax
  jne    L1636
L593:
  lea    D633(%rip),%rdi
  call   <puts@plt>
L1727:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L642:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L642
  cmpq   $0x0,0x18(%rsp)
  jne    L189
  xor    %eax,%eax
L1158:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1158
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1574:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L956
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L956:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1574
  test   %eax,%eax
  jne    L1488
L189:
  lea    D763(%rip),%rdi
  call   <puts@plt>
L162:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L736:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L736
  cmpq   $0x0,0x18(%rsp)
  jne    L887
  xor    %eax,%eax
L287:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L287
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L125:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L617
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L617:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L125
  test   %eax,%eax
  jne    L1234
L887:
  lea    D492(%rip),%rdi
  call   <puts@plt>
L85:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L652:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L652
  cmpq   $0x0,0x18(%rsp)
  jne    L859
  xor    %eax,%eax
L1763:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1763
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L977:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1540
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1540:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L977
  test   %eax,%eax
  jne    L1154
L859:
  lea    D670(%rip),%rdi
  call   <puts@plt>
L1849:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1142:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1142
  cmpq   $0x0,0x18(%rsp)
  jne    L168
  xor    %eax,%eax
L167:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L167
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1494:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L441
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L441:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1494
  test   %eax,%eax
  jne    L1459
L168:
  lea    D664(%rip),%rdi
  call   <puts@plt>
L598:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L658:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L658
  cmpq   $0x0,0x18(%rsp)
  jne    L810
  xor    %eax,%eax
L179:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L179
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1776:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1682
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1682:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1776
  test   %eax,%eax
  jne    L1868
L810:
  lea    D724(%rip),%rdi
  call   <puts@plt>
L469:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L69:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L69
  cmpq   $0x0,0x18(%rsp)
  jne    L260
  xor    %eax,%eax
L355:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L355
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1666:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L928
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L928:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1666
  test   %eax,%eax
  jne    L282
L260:
  lea    D398(%rip),%rdi
  call   <puts@plt>
L1221:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1546:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1546
  cmpq   $0x0,0x18(%rsp)
  jne    L920
  xor    %eax,%eax
L853:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L853
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L404:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L136
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L136:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L404
  test   %eax,%eax
  jne    L1730
L920:
  lea    D126(%rip),%rdi
  call   <puts@plt>
L280:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L765:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L765
  cmpq   $0x0,0x18(%rsp)
  jne    L1301
  xor    %eax,%eax
L990:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L990
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L580:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L572
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L572:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L580
  test   %eax,%eax
  jne    L37
L1301:
  lea    D536(%rip),%rdi
  call   <puts@plt>
L1504:
  lea    0x4d0(%rsp),%rbx
  mov    $0x9c40,%edx
  mov    $0xff,%esi
  mov    %rbx,%rdi
  call   <memset@plt>
  lea    0xa110(%rsp),%r8
  lea    0x13d50(%rsp),%rsi
  xor    %edx,%edx
  mov    %r8,%rdi
  mov    %rsi,%r9
  mov    %r8,%rcx
L1699:
  lea    (%rdx,%rdx,1),%r10d
  xor    %eax,%eax
L1397:
  mov    %edx,(%rcx,%rax,1)
  mov    %r10d,(%r9,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1397
  add    $0x1,%edx
  add    $0x190,%rcx
  add    $0x190,%r9
  cmp    $0x64,%edx
  jne    L1699
  cmpq   $0x0,0x18(%rsp)
  mov    %rbx,%rcx
  jne    L883
L1190:
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L963:
  mov    (%rsi,%rax,1),%edx
  add    (%rdi,%rax,1),%edx
  add    %edx,(%rcx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L963
  add    $0x190,%rcx
  add    $0x190,%rdi
  add    $0x190,%rsi
  cmp    %rcx,%r8
  jne    L1190
  add    $0x190,%rbx
  mov    $0xffffffff,%r12d
  xor    %r14d,%r14d
  xor    %eax,%eax
  lea    D427(%rip),%r15
L497:
  lea    -0x190(%rbx),%rbp
  nop
L82:
  mov    0x0(%rbp),%edx
  cmp    %r12d,%edx
  je     L264
  mov    %r12d,%ecx
  mov    %r14d,%esi
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L264:
  add    $0x4,%rbp
  cmp    %rbp,%rbx
  jne    L82
  add    $0x1,%r14d
  add    $0x190,%rbx
  add    $0x3,%r12d
  cmp    $0x64,%r14d
  jne    L497
  test   %eax,%eax
  jne    L500
L883:
  lea    D665(%rip),%rdi
  call   <puts@plt>
L262:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1553:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1553
  cmpq   $0x0,0x18(%rsp)
  jne    L119
  xor    %eax,%eax
L1406:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1406
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1395:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L1205
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1205:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1395
  test   %eax,%eax
  jne    L1465
L119:
  lea    D266(%rip),%rdi
  call   <puts@plt>
L127:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1623:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1623
  cmpq   $0x0,0x18(%rsp)
  jne    L430
  xor    %eax,%eax
L797:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L797
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1654:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L20
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L20:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1654
  test   %eax,%eax
  jne    L268
L430:
  lea    D704(%rip),%rdi
  call   <puts@plt>
L1481:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1507:
  mov    0x8(%rsp),%rsi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rsi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1507
  cmpq   $0x0,0x18(%rsp)
  jne    L1232
  xor    %eax,%eax
L1686:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1686
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L321:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L239
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L239:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L321
  test   %eax,%eax
  jne    L173
L1232:
  lea    D758(%rip),%rdi
  call   <puts@plt>
L790:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L1583:
  mov    0x8(%rsp),%rbx
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rbx,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1583
  cmpq   $0x0,0x18(%rsp)
  jne    L531
  xor    %eax,%eax
L425:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L425
  mov    $0xffffffff,%r14d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r15
L1053:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r14d,%edx
  je     L893
  mov    %r14d,%ecx
  mov    %r15,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L893:
  add    $0x1,%rbx
  add    $0x3,%r14d
  cmp    $0x64,%rbx
  jne    L1053
  test   %eax,%eax
  jne    L1385
L531:
  lea    D164(%rip),%rdi
  call   <puts@plt>
L342:
  mov    0x10(%rsp),%rdi
  mov    $0xffffffffffffffff,%rax
  mov    $0x32,%ecx
  rep stos %rax,%es:(%rdi)
  xor    %eax,%eax
L86:
  mov    0x8(%rsp),%rdi
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x0(%r13,%rax,4)
  mov    %eax,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L86
  cmpq   $0x0,0x18(%rsp)
  jne    L341
  xor    %eax,%eax
L427:
  mov    0x8(%rsp),%rsi
  mov    0x10(%rsp),%rbx
  mov    0x0(%r13,%rax,1),%edx
  add    (%rsi,%rax,1),%edx
  add    %edx,(%rbx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L427
  mov    $0xffffffff,%r12d
  xor    %ebx,%ebx
  xor    %eax,%eax
  lea    D427(%rip),%r13
L7:
  mov    0x10(%rsp),%rdi
  mov    %ebx,%esi
  mov    (%rdi,%rbx,4),%edx
  cmp    %r12d,%edx
  je     L1376
  mov    %r12d,%ecx
  mov    %r13,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%eax
L1376:
  add    $0x1,%rbx
  add    $0x3,%r12d
  cmp    $0x64,%rbx
  jne    L7
  test   %eax,%eax
  jne    L249
L341:
  lea    D699(%rip),%rdi
  call   <puts@plt>
L856:
  mov    0x1d998(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L1213
  add    $0x1d9a8,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L463:
  lea    D229(%rip),%rdi
  call   <puts@plt>
  jmp    L1054
L379:
  lea    D640(%rip),%rdi
  call   <puts@plt>
  jmp    L242
L249:
  lea    D17(%rip),%rdi
  call   <puts@plt>
  jmp    L856
L1385:
  lea    D432(%rip),%rdi
  call   <puts@plt>
  jmp    L342
L173:
  lea    D247(%rip),%rdi
  call   <puts@plt>
  jmp    L790
L268:
  lea    D293(%rip),%rdi
  call   <puts@plt>
  jmp    L1481
L1465:
  lea    D470(%rip),%rdi
  call   <puts@plt>
  jmp    L127
L500:
  lea    D359(%rip),%rdi
  call   <puts@plt>
  jmp    L262
L37:
  lea    D549(%rip),%rdi
  call   <puts@plt>
  jmp    L1504
L1730:
  lea    D658(%rip),%rdi
  call   <puts@plt>
  jmp    L280
L282:
  lea    D679(%rip),%rdi
  call   <puts@plt>
  jmp    L1221
L1868:
  lea    D99(%rip),%rdi
  call   <puts@plt>
  jmp    L469
L1459:
  lea    D370(%rip),%rdi
  call   <puts@plt>
  jmp    L598
L1154:
  lea    D407(%rip),%rdi
  call   <puts@plt>
  jmp    L1849
L1234:
  lea    D177(%rip),%rdi
  call   <puts@plt>
  jmp    L85
L1488:
  lea    D429(%rip),%rdi
  call   <puts@plt>
  jmp    L162
L1636:
  lea    D151(%rip),%rdi
  call   <puts@plt>
  jmp    L1727
L811:
  lea    D424(%rip),%rdi
  call   <puts@plt>
  jmp    L30
L229:
  lea    D12(%rip),%rdi
  call   <puts@plt>
  jmp    L1445
L165:
  lea    D111(%rip),%rdi
  call   <puts@plt>
  jmp    L709
L303:
  lea    D101(%rip),%rdi
  call   <puts@plt>
  jmp    L1482
L1529:
  lea    D619(%rip),%rdi
  call   <puts@plt>
  jmp    L590
L372:
  lea    D649(%rip),%rdi
  call   <puts@plt>
  jmp    L1616
L770:
  lea    D443(%rip),%rdi
  call   <puts@plt>
  jmp    L751
L153:
  lea    D580(%rip),%rdi
  call   <puts@plt>
  jmp    L59
L48:
  lea    D583(%rip),%rdi
  call   <puts@plt>
  jmp    L781
L1213:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: data_label: D427
type_guessed: string
name: parse_data
arguments: data_label: D319
type_guessed: string
name: parse_data
arguments: data_label: D423
type_guessed: string
name: parse_data
arguments: data_label: D561
type_guessed: string
name: parse_data
arguments: data_label: D671
type_guessed: string
name: parse_data
arguments: data_label: D282
type_guessed: string
name: parse_data
arguments: data_label: D597
type_guessed: string
name: parse_data
arguments: data_label: D413
type_guessed: string
name: parse_data
arguments: data_label: D623
type_guessed: string
name: parse_data
arguments: data_label: D157
type_guessed: string
name: parse_data
arguments: data_label: D410
type_guessed: string
name: parse_data
arguments: data_label: D357
type_guessed: string
name: parse_data
arguments: data_label: D633
type_guessed: string
name: parse_data
arguments: data_label: D763
type_guessed: string
name: parse_data
arguments: data_label: D492
type_guessed: string
name: parse_data
arguments: data_label: D670
type_guessed: string
name: parse_data
arguments: data_label: D664
type_guessed: string
name: parse_data
arguments: data_label: D724
type_guessed: string
name: parse_data
arguments: data_label: D398
type_guessed: string
name: parse_data
arguments: data_label: D126
type_guessed: string
name: parse_data
arguments: data_label: D536
type_guessed: string
name: parse_data
arguments: data_label: D665
type_guessed: string
name: parse_data
arguments: data_label: D266
type_guessed: string
name: parse_data
arguments: data_label: D704
type_guessed: string
name: parse_data
arguments: data_label: D758
type_guessed: string
name: parse_data
arguments: data_label: D164
type_guessed: string
name: parse_data
arguments: data_label: D699
type_guessed: string
name: parse_data
arguments: data_label: D229
type_guessed: string
name: parse_data
arguments: data_label: D640
type_guessed: string
name: parse_data
arguments: data_label: D17
type_guessed: string
name: parse_data
arguments: data_label: D432
type_guessed: string
name: parse_data
arguments: data_label: D247
type_guessed: string
name: parse_data
arguments: data_label: D293
type_guessed: string
name: parse_data
arguments: data_label: D470
type_guessed: string
name: parse_data
arguments: data_label: D359
type_guessed: string
name: parse_data
arguments: data_label: D549
type_guessed: string
name: parse_data
arguments: data_label: D658
type_guessed: string
name: parse_data
arguments: data_label: D679
type_guessed: string
name: parse_data
arguments: data_label: D99
type_guessed: string
name: parse_data
arguments: data_label: D370
type_guessed: string
name: parse_data
arguments: data_label: D407
type_guessed: string
name: parse_data
arguments: data_label: D177
type_guessed: string
name: parse_data
arguments: data_label: D429
type_guessed: string
name: parse_data
arguments: data_label: D151
type_guessed: string
name: parse_data
arguments: data_label: D424
type_guessed: string
name: parse_data
arguments: data_label: D12
type_guessed: string
name: parse_data
arguments: data_label: D111
type_guessed: string
name: parse_data
arguments: data_label: D101
type_guessed: string
name: parse_data
arguments: data_label: D619
type_guessed: string
name: parse_data
arguments: data_label: D649
type_guessed: string
name: parse_data
arguments: data_label: D443
type_guessed: string
name: parse_data
arguments: data_label: D580
type_guessed: string
name: parse_data
arguments: data_label: D583
type_guessed: string

tool: D427: Error at %d: device = %d, host = %d


tool: D319: Succeeded 2

tool: D423: Succeeded 3

tool: D561: Succeeded 4

tool: D671: Succeeded 5

tool: D282: Succeeded 6

tool: D597: Succeeded 7

tool: D413: Succeeded 8

tool: D623: Succeeded 9

tool: D157: Succeeded 10

tool: D410: Succeeded 13

tool: D357: Succeeded 14

tool: D633: Succeeded 17

tool: D763: Succeeded 18

tool: D492: Succeeded 21

tool: D670: Succeeded 22

tool: D664: Succeeded 25

tool: D724: Succeeded 26

tool: D398: Succeeded 27

tool: D126: Succeeded 28

tool: D536: Succeeded 31

tool: D665: Succeeded 32

tool: D266: Succeeded 33

tool: D704: Succeeded 34

tool: D758: Succeeded 35

tool: D164: Succeeded 36

tool: D699: Succeeded 37

tool: D229: Failed 3

tool: D640: Failed 2

tool: D17: Failed 37

tool: D432: Failed 36

tool: D247: Failed 35

tool: D293: Failed 34

tool: D470: Failed 33

tool: D359: Failed 32

tool: D549: Failed 31

tool: D658: Failed 28

tool: D679: Failed 27

tool: D99: Failed 26

tool: D370: Failed 25

tool: D407: Failed 22

tool: D177: Failed 21

tool: D429: Failed 18

tool: D151: Failed 17

tool: D424: Failed 14

tool: D12: Failed 13

tool: D111: Failed 10

tool: D101: Failed 9

tool: D619: Failed 8

tool: D649: Failed 7

tool: D443: Failed 6

tool: D580: Failed 5

tool: D583: Failed 4

assistant: ```c
int main() {
  int a[100], b[100], c[100];
  check_offloading();
  long cpuExec = 0;
  int fail, ch;
#pragma omp target map(tofrom : cpuExec)
  { cpuExec = omp_is_initial_device(); }
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 2\n");
  else
    printf("Succeeded 2\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  int q = -5;
  int p = -3;
  int r = 0;
  int l = 10;
  if (!cpuExec) {
#pragma omp target teams num_teams(1) thread_limit(1024) map(tofrom : a, r) map(to : b, c)
#pragma omp parallel
#pragma omp for simd private(q) firstprivate(p) lastprivate(r) linear(l : 2)
    for (int i = 0; i < 100; i++) {
      q = i + 5;
      p += i + 2;
      a[i] += p * b[i] + c[i] * q + l;
      r = i;
    }
    for (int i = 0; i < 100; i++) {
      int expected = (-1 + (-3 + i + 2) * i + (2 * i) * (i + 5) + 10 + (2 * i));
      if (a[i] != expected) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], expected);
        fail = 1;
      }
    }
    if (r != 100 - 1) {
      printf("Error for lastprivate: device = %d, host = %d\n", r, 100 - 1);
      fail = 1;
    }
  }
  if (fail)
    printf("Failed 3\n");
  else
    printf("Succeeded 3\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(static)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 4\n");
  else
    printf("Succeeded 4\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target teams num_teams(1) thread_limit(1024) map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(monotonic : static)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 5\n");
  else
    printf("Succeeded 5\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : static)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 6\n");
  else
    printf("Succeeded 6\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(static, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 7\n");
  else
    printf("Succeeded 7\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(monotonic : static, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 8\n");
  else
    printf("Succeeded 8\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : static, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 9\n");
  else
    printf("Succeeded 9\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(dynamic)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 10\n");
  else
    printf("Succeeded 10\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : dynamic)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 13\n");
  else
    printf("Succeeded 13\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(dynamic, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 14\n");
  else
    printf("Succeeded 14\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : dynamic, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 17\n");
  else
    printf("Succeeded 17\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(guided)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 18\n");
  else
    printf("Succeeded 18\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : guided)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 21\n");
  else
    printf("Succeeded 21\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(guided, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 22\n");
  else
    printf("Succeeded 22\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  ch = 10;
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : guided, ch)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 25\n");
  else
    printf("Succeeded 25\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(auto)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 26\n");
  else
    printf("Succeeded 26\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(monotonic : auto)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 27\n");
  else
    printf("Succeeded 27\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : auto)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 28\n");
  else
    printf("Succeeded 28\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd schedule(simd : runtime)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 31\n");
  else
    printf("Succeeded 31\n");
  fail = 0;
  int ma[100][100], mb[100][100], mc[100][100];
  for (int i = 0; i < 100; i++)
    for (int j = 0; j < 100; j++) {
      ma[i][j] = -1;
      mb[i][j] = i;
      mc[i][j] = 2 * i;
    }
  if (!cpuExec) {
#pragma omp target map(tofrom : ma) map(to : mb, mc)
#pragma omp parallel
#pragma omp for simd collapse(2)
    for (int i = 0; i < 100; i++)
      for (int j = 0; j < 100; j++)
        ma[i][j] += mb[i][j] + mc[i][j];
    for (int i = 0; i < 100; i++)
      for (int j = 0; j < 100; j++)
        if (ma[i][j] != (-1 + i + 2 * i)) {
          printf("Error at %d: device = %d, host = %d\n", i, ma[i][j], (-1 + i + 2 * i));
          fail = 1;
        }
  }
  if (fail)
    printf("Failed 32\n");
  else
    printf("Succeeded 32\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd ordered
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 33\n");
  else
    printf("Succeeded 33\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd nowait
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 34\n");
  else
    printf("Succeeded 34\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd safelen(16)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 35\n");
  else
    printf("Succeeded 35\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd simdlen(16)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 36\n");
  else
    printf("Succeeded 36\n");
  fail = 0;
  for (int i = 0; i < 100; i++) {
    a[i] = -1;
    b[i] = i;
    c[i] = 2 * i;
  }
  if (!cpuExec) {
#pragma omp target map(tofrom : a) map(to : b, c)
#pragma omp parallel
#pragma omp for simd aligned(a, b, c : 8)
    for (int i = 0; i < 100; i++)
      a[i] += b[i] + c[i];
    for (int i = 0; i < 100; i++)
      if (a[i] != (-1 + i + 2 * i)) {
        printf("Error at %d: device = %d, host = %d\n", i, a[i], (-1 + i + 2 * i));
        fail = 1;
      }
  }
  if (fail)
    printf("Failed 37\n");
  else
    printf("Succeeded 37\n");
  return 0;
}
```