user: 请显示与下面列出的汇编代码相匹配的C语言实现：

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x1d000(%rsp),%r11
L1114:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L1114
  sub    $0x998,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x1d988(%rsp)
  xor    %eax,%eax
  call   <check_offloading@plt>
  mov    $0x0,%eax
  call   <omp_is_initial_device@plt>
  movslq %eax,%r15
  mov    $0x0,%eax
L1841:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1841
  test   %r15,%r15
  jne    L1470
  mov    $0x0,%eax
L1408:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1408
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L969
L1593:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L837
L969:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1593
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1593
L837:
  test   %eax,%eax
  jne    L860
L1470:
  lea    D508(%rip),%rdi
  call   <puts@plt>
L172:
  mov    $0x0,%eax
L1371:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1371
  test   %r15,%r15
  jne    L875
  mov    $0x0,%eax
  mov    $0xfffffffd,%ecx
  lea    0x330(%rsp),%r8
  lea    0x1a0(%rsp),%rdi
L186:
  lea    0x2(%rcx,%rax,1),%ecx
  lea    0x5(%rax),%edx
  imul   (%r8,%rax,4),%edx
  mov    %ecx,%esi
  imul   (%rdi,%rax,4),%esi
  lea    0xa(%rdx,%rsi,1),%edx
  add    %edx,0x10(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L186
  mov    $0x0,%ebx
  mov    $0x0,%edi
  lea    D414(%rip),%rbp
  jmp    L1305
L860:
  lea    D96(%rip),%rdi
  call   <puts@plt>
  jmp    L172
L851:
  add    $0x1,%rbx
  cmp    $0x64,%rbx
  je     L2298
L1305:
  mov    %ebx,%esi
  lea    -0x1(%rbx),%eax
  imul   %ebx,%eax
  lea    0x5(%rbx),%edx
  imul   %ebx,%edx
  lea    0x9(%rax,%rdx,2),%eax
  lea    (%rax,%rbx,2),%ecx
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ecx,%edx
  je     L851
  mov    %rbp,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  jmp    L851
L2298:
  test   %edi,%edi
  je     L875
  lea    D451(%rip),%rdi
  call   <puts@plt>
  jmp    L320
L875:
  lea    D431(%rip),%rdi
  call   <puts@plt>
L320:
  mov    $0x0,%eax
L96:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L96
  test   %r15,%r15
  jne    L1124
  mov    $0x0,%eax
L1180:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1180
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L231
L2128:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1932
L231:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2128
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2128
L1932:
  test   %eax,%eax
  jne    L2346
L1124:
  lea    D667(%rip),%rdi
  call   <puts@plt>
L382:
  mov    $0x0,%eax
L274:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L274
  test   %r15,%r15
  jne    L423
  mov    $0x0,%eax
L2:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1326
L2346:
  lea    D652(%rip),%rdi
  call   <puts@plt>
  jmp    L382
L886:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L693
L1326:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L886
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L886
L693:
  test   %eax,%eax
  jne    L1481
L423:
  lea    D409(%rip),%rdi
  call   <puts@plt>
L1499:
  mov    $0x0,%eax
L256:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L256
  test   %r15,%r15
  jne    L86
  mov    $0x0,%eax
L1851:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1851
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1111
L1481:
  lea    D287(%rip),%rdi
  call   <puts@plt>
  jmp    L1499
L1101:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L70
L1111:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1101
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1101
L70:
  test   %eax,%eax
  jne    L761
L86:
  lea    D109(%rip),%rdi
  call   <puts@plt>
L2255:
  mov    $0x0,%eax
L986:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L986
  test   %r15,%r15
  jne    L1968
  mov    $0x0,%eax
L2264:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2264
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L390
L761:
  lea    D296(%rip),%rdi
  call   <puts@plt>
  jmp    L2255
L1115:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1864
L390:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1115
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1115
L1864:
  test   %eax,%eax
  jne    L47
L1968:
  lea    D504(%rip),%rdi
  call   <puts@plt>
L2176:
  mov    $0x0,%eax
L363:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L363
  test   %r15,%r15
  jne    L2097
  mov    $0x0,%eax
L2220:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2220
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L550
L47:
  lea    D691(%rip),%rdi
  call   <puts@plt>
  jmp    L2176
L2043:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L90
L550:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2043
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2043
L90:
  test   %eax,%eax
  jne    L988
L2097:
  lea    D79(%rip),%rdi
  call   <puts@plt>
L2191:
  mov    $0x0,%eax
L701:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L701
  test   %r15,%r15
  jne    L483
  mov    $0x0,%eax
L1028:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1028
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1149
L988:
  lea    D59(%rip),%rdi
  call   <puts@plt>
  jmp    L2191
L480:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1888
L1149:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L480
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L480
L1888:
  test   %eax,%eax
  jne    L852
L483:
  lea    D755(%rip),%rdi
  call   <puts@plt>
L1289:
  mov    $0x0,%eax
L1731:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1731
  test   %r15,%r15
  jne    L938
  mov    $0x0,%eax
L1582:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1582
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1313
L852:
  lea    D568(%rip),%rdi
  call   <puts@plt>
  jmp    L1289
L424:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1197
L1313:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L424
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L424
L1197:
  test   %eax,%eax
  jne    L2189
L938:
  lea    D502(%rip),%rdi
  call   <puts@plt>
L2006:
  mov    $0x0,%eax
L345:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L345
  test   %r15,%r15
  jne    L261
  mov    $0x0,%eax
L1813:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1813
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1665
L2189:
  lea    D299(%rip),%rdi
  call   <puts@plt>
  jmp    L2006
L2037:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1774
L1665:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2037
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2037
L1774:
  test   %eax,%eax
  jne    L1615
L261:
  lea    D541(%rip),%rdi
  call   <puts@plt>
L1827:
  mov    $0x0,%eax
L882:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L882
  test   %r15,%r15
  jne    L1389
  mov    $0x0,%eax
L1112:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1112
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L476
L1615:
  lea    D491(%rip),%rdi
  call   <puts@plt>
  jmp    L1827
L1995:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1285
L476:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1995
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1995
L1285:
  test   %eax,%eax
  jne    L1083
L1389:
  lea    D78(%rip),%rdi
  call   <puts@plt>
L1654:
  mov    $0x0,%eax
L237:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L237
  test   %r15,%r15
  jne    L1906
  mov    $0x0,%eax
L1858:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1858
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L36
L1083:
  lea    D206(%rip),%rdi
  call   <puts@plt>
  jmp    L1654
L1924:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L674
L36:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1924
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1924
L674:
  test   %eax,%eax
  jne    L1773
L1906:
  lea    D715(%rip),%rdi
  call   <puts@plt>
L2388:
  mov    $0x0,%eax
L2034:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L2034
  test   %r15,%r15
  jne    L754
  mov    $0x0,%eax
L1763:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1763
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L703
L1773:
  lea    D106(%rip),%rdi
  call   <puts@plt>
  jmp    L2388
L974:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L2395
L703:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L974
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L974
L2395:
  test   %eax,%eax
  jne    L1667
L754:
  lea    D603(%rip),%rdi
  call   <puts@plt>
L643:
  mov    $0x0,%eax
L1055:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1055
  test   %r15,%r15
  jne    L99
  mov    $0x0,%eax
L1529:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1529
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L2046
L1667:
  lea    D326(%rip),%rdi
  call   <puts@plt>
  jmp    L643
L711:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L857
L2046:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L711
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L711
L857:
  test   %eax,%eax
  jne    L1198
L99:
  lea    D95(%rip),%rdi
  call   <puts@plt>
L1100:
  mov    $0x0,%eax
L324:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L324
  test   %r15,%r15
  jne    L2271
  mov    $0x0,%eax
L1376:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1376
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1673
L1198:
  lea    D163(%rip),%rdi
  call   <puts@plt>
  jmp    L1100
L2289:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L607
L1673:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2289
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2289
L607:
  test   %eax,%eax
  jne    L1753
L2271:
  lea    D641(%rip),%rdi
  call   <puts@plt>
L2153:
  mov    $0x0,%eax
L1467:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1467
  test   %r15,%r15
  jne    L1926
  mov    $0x0,%eax
L2051:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2051
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L2263
L1753:
  lea    D621(%rip),%rdi
  call   <puts@plt>
  jmp    L2153
L233:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L298
L2263:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L233
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L233
L298:
  test   %eax,%eax
  jne    L831
L1926:
  lea    D61(%rip),%rdi
  call   <puts@plt>
L1209:
  mov    $0x0,%eax
L1049:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1049
  test   %r15,%r15
  jne    L1400
  mov    $0x0,%eax
L1861:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1861
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L371
L831:
  lea    D282(%rip),%rdi
  call   <puts@plt>
  jmp    L1209
L655:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L285
L371:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L655
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L655
L285:
  test   %eax,%eax
  jne    L2102
L1400:
  lea    D684(%rip),%rdi
  call   <puts@plt>
L2306:
  mov    $0x0,%eax
L28:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L28
  test   %r15,%r15
  jne    L2091
  mov    $0x0,%eax
L848:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L848
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L894
L2102:
  lea    D374(%rip),%rdi
  call   <puts@plt>
  jmp    L2306
L1552:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L944
L894:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1552
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1552
L944:
  test   %eax,%eax
  jne    L429
L2091:
  lea    D707(%rip),%rdi
  call   <puts@plt>
L1144:
  mov    $0x0,%eax
L1982:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1982
  test   %r15,%r15
  jne    L2206
  mov    $0x0,%eax
L2235:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2235
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L917
L429:
  lea    D126(%rip),%rdi
  call   <puts@plt>
  jmp    L1144
L726:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1922
L917:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L726
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L726
L1922:
  test   %eax,%eax
  jne    L1062
L2206:
  lea    D575(%rip),%rdi
  call   <puts@plt>
L425:
  mov    $0x0,%eax
L1414:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1414
  test   %r15,%r15
  jne    L1265
  mov    $0x0,%eax
L443:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L443
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1110
L1062:
  lea    D756(%rip),%rdi
  call   <puts@plt>
  jmp    L425
L179:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L876
L1110:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L179
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L179
L876:
  test   %eax,%eax
  jne    L634
L1265:
  lea    D298(%rip),%rdi
  call   <puts@plt>
L1474:
  lea    0x4c0(%rsp),%r12
  lea    0xa100(%rsp),%r9
  lea    0x13d40(%rsp),%r10
  mov    %r10,%rdi
  mov    %r9,%rsi
  mov    %r12,%rcx
  mov    $0x0,%edx
L1988:
  lea    (%rdx,%rdx,1),%r8d
  mov    $0x0,%eax
L825:
  movl   $0xffffffff,(%rcx,%rax,1)
  mov    %edx,(%rsi,%rax,1)
  mov    %r8d,(%rdi,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L825
  add    $0x1,%edx
  add    $0x190,%rcx
  add    $0x190,%rsi
  add    $0x190,%rdi
  cmp    $0x64,%edx
  jne    L1988
  lea    0x9c40(%r12),%rsi
  mov    %r12,%rcx
  test   %r15,%r15
  jne    L1611
L339:
  mov    $0x0,%eax
L2362:
  mov    (%r10,%rax,1),%edx
  add    (%r9,%rax,1),%edx
  add    %edx,(%rcx,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2362
  add    $0x190,%rcx
  add    $0x190,%r9
  add    $0x190,%r10
  cmp    %rcx,%rsi
  jne    L339
  add    $0x190,%r12
  movl   $0xffffffff,0xc(%rsp)
  mov    $0x0,%r13d
  mov    $0x0,%eax
  lea    D414(%rip),%r14
  jmp    L2137
L634:
  lea    D424(%rip),%rdi
  call   <puts@plt>
  jmp    L1474
L2106:
  add    $0x4,%rbx
  cmp    %r12,%rbx
  je     L286
L1628:
  mov    (%rbx),%edx
  cmp    %ebp,%edx
  je     L2106
  mov    %ebp,%ecx
  mov    %r13d,%esi
  mov    %r14,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2106
L286:
  add    $0x1,%r13d
  add    $0x190,%r12
  addl   $0x3,0xc(%rsp)
  cmp    $0x64,%r13d
  je     L897
L2137:
  mov    0xc(%rsp),%ebp
  lea    -0x190(%r12),%rbx
  jmp    L1628
L897:
  test   %eax,%eax
  jne    L1918
L1611:
  lea    D744(%rip),%rdi
  call   <puts@plt>
L1314:
  mov    $0x0,%eax
L999:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L999
  test   %r15,%r15
  jne    L201
  mov    $0x0,%eax
L2139:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2139
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L182
L1918:
  lea    D113(%rip),%rdi
  call   <puts@plt>
  jmp    L1314
L1454:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L397
L182:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1454
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1454
L397:
  test   %eax,%eax
  jne    L219
L201:
  lea    D21(%rip),%rdi
  call   <puts@plt>
L2156:
  mov    $0x0,%eax
L1718:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1718
  test   %r15,%r15
  jne    L736
  mov    $0x0,%eax
L1301:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L1301
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L2098
L219:
  lea    D268(%rip),%rdi
  call   <puts@plt>
  jmp    L2156
L2240:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1409
L2098:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2240
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2240
L1409:
  test   %eax,%eax
  jne    L2374
L736:
  lea    D429(%rip),%rdi
  call   <puts@plt>
L7:
  mov    $0x0,%eax
L2320:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L2320
  test   %r15,%r15
  jne    L2335
  mov    $0x0,%eax
L2355:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2355
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L484
L2374:
  lea    D230(%rip),%rdi
  call   <puts@plt>
  jmp    L7
L1164:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L71
L484:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L1164
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L1164
L71:
  test   %eax,%eax
  jne    L32
L2335:
  lea    D373(%rip),%rdi
  call   <puts@plt>
L1407:
  mov    $0x0,%eax
L1250:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L1250
  test   %r15,%r15
  jne    L2334
  mov    $0x0,%eax
L2004:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2004
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L1466
L32:
  lea    D186(%rip),%rdi
  call   <puts@plt>
  jmp    L1407
L2164:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L2318
L1466:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2164
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2164
L2318:
  test   %eax,%eax
  jne    L1525
L2334:
  lea    D271(%rip),%rdi
  call   <puts@plt>
L893:
  mov    $0x0,%eax
L2290:
  movl   $0xffffffff,0x10(%rsp,%rax,4)
  mov    %eax,0x1a0(%rsp,%rax,4)
  lea    (%rax,%rax,1),%edx
  mov    %edx,0x330(%rsp,%rax,4)
  add    $0x1,%rax
  cmp    $0x64,%rax
  jne    L2290
  test   %r15,%r15
  jne    L2146
  mov    $0x0,%eax
L2326:
  mov    0x330(%rsp,%rax,1),%edx
  add    0x1a0(%rsp,%rax,1),%edx
  add    %edx,0x10(%rsp,%rax,1)
  add    $0x4,%rax
  cmp    $0x190,%rax
  jne    L2326
  mov    $0xffffffff,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%eax
  lea    D414(%rip),%r12
  jmp    L63
L1525:
  lea    D514(%rip),%rdi
  call   <puts@plt>
  jmp    L893
L2095:
  add    $0x1,%rbx
  add    $0x3,%ebp
  cmp    $0x64,%rbx
  je     L1342
L63:
  mov    %ebx,%esi
  mov    0x10(%rsp,%rbx,4),%edx
  cmp    %ebp,%edx
  je     L2095
  mov    %ebp,%ecx
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%eax
  jmp    L2095
L1342:
  test   %eax,%eax
  jne    L784
L2146:
  lea    D317(%rip),%rdi
  call   <puts@plt>
L771:
  mov    0x1d988(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L1617
  mov    $0x0,%eax
  add    $0x1d998,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L784:
  lea    D486(%rip),%rdi
  call   <puts@plt>
  jmp    L771
L1617:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: data_label: D414
type_guessed: string
name: read_data
arguments: data_label: D508
type_guessed: string
name: read_data
arguments: data_label: D96
type_guessed: string
name: read_data
arguments: data_label: D451
type_guessed: string
name: read_data
arguments: data_label: D431
type_guessed: string
name: read_data
arguments: data_label: D667
type_guessed: string
name: read_data
arguments: data_label: D652
type_guessed: string
name: read_data
arguments: data_label: D409
type_guessed: string
name: read_data
arguments: data_label: D287
type_guessed: string
name: read_data
arguments: data_label: D109
type_guessed: string
name: read_data
arguments: data_label: D296
type_guessed: string
name: read_data
arguments: data_label: D504
type_guessed: string
name: read_data
arguments: data_label: D691
type_guessed: string
name: read_data
arguments: data_label: D79
type_guessed: string
name: read_data
arguments: data_label: D59
type_guessed: string
name: read_data
arguments: data_label: D755
type_guessed: string
name: read_data
arguments: data_label: D568
type_guessed: string
name: read_data
arguments: data_label: D502
type_guessed: string
name: read_data
arguments: data_label: D299
type_guessed: string
name: read_data
arguments: data_label: D541
type_guessed: string
name: read_data
arguments: data_label: D491
type_guessed: string
name: read_data
arguments: data_label: D78
type_guessed: string
name: read_data
arguments: data_label: D206
type_guessed: string
name: read_data
arguments: data_label: D715
type_guessed: string
name: read_data
arguments: data_label: D106
type_guessed: string
name: read_data
arguments: data_label: D603
type_guessed: string
name: read_data
arguments: data_label: D326
type_guessed: string
name: read_data
arguments: data_label: D95
type_guessed: string
name: read_data
arguments: data_label: D163
type_guessed: string
name: read_data
arguments: data_label: D641
type_guessed: string
name: read_data
arguments: data_label: D621
type_guessed: string
name: read_data
arguments: data_label: D61
type_guessed: string
name: read_data
arguments: data_label: D282
type_guessed: string
name: read_data
arguments: data_label: D684
type_guessed: string
name: read_data
arguments: data_label: D374
type_guessed: string
name: read_data
arguments: data_label: D707
type_guessed: string
name: read_data
arguments: data_label: D126
type_guessed: string
name: read_data
arguments: data_label: D575
type_guessed: string
name: read_data
arguments: data_label: D756
type_guessed: string
name: read_data
arguments: data_label: D298
type_guessed: string
name: read_data
arguments: data_label: D424
type_guessed: string
name: read_data
arguments: data_label: D744
type_guessed: string
name: read_data
arguments: data_label: D113
type_guessed: string
name: read_data
arguments: data_label: D21
type_guessed: string
name: read_data
arguments: data_label: D268
type_guessed: string
name: read_data
arguments: data_label: D429
type_guessed: string
name: read_data
arguments: data_label: D230
type_guessed: string
name: read_data
arguments: data_label: D373
type_guessed: string
name: read_data
arguments: data_label: D186
type_guessed: string
name: read_data
arguments: data_label: D271
type_guessed: string
name: read_data
arguments: data_label: D514
type_guessed: string
name: read_data
arguments: data_label: D317
type_guessed: string
name: read_data
arguments: data_label: D486
type_guessed: string

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


tool: D508: Succeeded 2

tool: D96: Failed 2

tool: D451: Failed 3

tool: D431: Succeeded 3

tool: D667: Succeeded 4

tool: D652: Failed 4

tool: D409: Succeeded 5

tool: D287: Failed 5

tool: D109: Succeeded 6

tool: D296: Failed 6

tool: D504: Succeeded 7

tool: D691: Failed 7

tool: D79: Succeeded 8

tool: D59: Failed 8

tool: D755: Succeeded 9

tool: D568: Failed 9

tool: D502: Succeeded 10

tool: D299: Failed 10

tool: D541: Succeeded 13

tool: D491: Failed 13

tool: D78: Succeeded 14

tool: D206: Failed 14

tool: D715: Succeeded 17

tool: D106: Failed 17

tool: D603: Succeeded 18

tool: D326: Failed 18

tool: D95: Succeeded 21

tool: D163: Failed 21

tool: D641: Succeeded 22

tool: D621: Failed 22

tool: D61: Succeeded 25

tool: D282: Failed 25

tool: D684: Succeeded 26

tool: D374: Failed 26

tool: D707: Succeeded 27

tool: D126: Failed 27

tool: D575: Succeeded 28

tool: D756: Failed 28

tool: D298: Succeeded 31

tool: D424: Failed 31

tool: D744: Succeeded 32

tool: D113: Failed 32

tool: D21: Succeeded 33

tool: D268: Failed 33

tool: D429: Succeeded 34

tool: D230: Failed 34

tool: D373: Succeeded 35

tool: D186: Failed 35

tool: D271: Succeeded 36

tool: D514: Failed 36

tool: D317: Succeeded 37

tool: D486: Failed 37

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