user: What is the c source code of the assembly code below:

```asm
<main>:
  endbr64
  push   %rbp
  mov    $0x20,%edx
  push   %rbx
  sub    $0x98,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x88(%rsp)
  xor    %eax,%eax
  mov    $0x1,%eax
  nopw   0x0(%rax,%rax,1)
L231:
  mov    %rax,%rcx
  add    %rax,%rax
  sub    $0x1,%edx
  jne    L231
  mov    $0x80000000,%eax
  cmp    %rax,%rcx
  je     L518
  xor    %eax,%eax
  call   <abort@plt>
L518:
  mov    $0x20,%edx
  mov    $0x1,%eax
  cs nopw 0x0(%rax,%rax,1)
L750:
  mov    %rax,%rcx
  add    %rax,%rax
  sub    $0x1,%edx
  jne    L750
  mov    $0x80000000,%eax
  cmp    %rax,%rcx
  je     L1059
  xor    %eax,%eax
  call   <abort@plt>
L1059:
  mov    $0x20,%edx
  mov    $0x1,%eax
  cs nopw 0x0(%rax,%rax,1)
L845:
  mov    %rax,%rcx
  add    %rax,%rax
  sub    $0x1,%edx
  jne    L845
  mov    $0x80000000,%eax
  cmp    %rax,%rcx
  je     L384
  xor    %eax,%eax
  call   <abort@plt>
L384:
  mov    $0x20,%eax
  mov    $0x20,%edx
  mov    $0x1,%ecx
  nopl   0x0(%rax,%rax,1)
L445:
  mov    %ecx,%edi
  sub    %edx,%edi
  mov    %edi,%edx
  sub    $0x1,%eax
  jne    L445
  cmp    $0x20,%edi
  je     L333
  xor    %eax,%eax
  call   <abort@plt>
L333:
  movabs $0x100000000,%rax
  mov    $0x20,%edx
  cs nopw 0x0(%rax,%rax,1)
L259:
  mov    %rax,%rcx
  shr    $0x3f,%rcx
  add    %rcx,%rax
  sar    %rax
  sub    $0x1,%edx
  jne    L259
  cmp    $0x1,%rax
  je     L711
  xor    %eax,%eax
  call   <abort@plt>
L711:
  movabs $0x100000000,%rax
  mov    $0x20,%edx
  xchg   %ax,%ax
L64:
  mov    %rax,%rcx
  shr    $0x3f,%rcx
  add    %rcx,%rax
  sar    %rax
  sub    $0x1,%edx
  jne    L64
  cmp    $0x1,%rax
  je     L104
  xor    %eax,%eax
  call   <abort@plt>
L104:
  mov    $0x20,%esi
  mov    $0x2,%ecx
  movabs $0x100000000,%rdi
  nopl   0x0(%rax,%rax,1)
L939:
  mov    %rdi,%rax
  cqto
  idiv   %rcx
  mov    %rax,%rcx
  sub    $0x1,%esi
  jne    L939
  cmp    $0x2,%rax
  je     L253
  xor    %eax,%eax
  call   <abort@plt>
L253:
  xor    %ecx,%ecx
  mov    $0xffffffff,%eax
  mov    $0x1,%esi
  nopl   0x0(%rax)
L429:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  and    %edx,%eax
  cmp    $0x20,%ecx
  jne    L429
  test   %eax,%eax
  jne    L147
L644:
  xor    %ecx,%ecx
  mov    $0xffffffff,%eax
  mov    $0x1,%esi
  nopw   0x0(%rax,%rax,1)
L1053:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  and    %edx,%eax
  cmp    $0x20,%ecx
  jne    L1053
  test   %eax,%eax
  jne    L962
L672:
  xor    %ecx,%ecx
  mov    $0xffffffff,%eax
  mov    $0x1,%esi
  nopw   0x0(%rax,%rax,1)
L983:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  and    %edx,%eax
  cmp    $0x20,%ecx
  jne    L983
  test   %eax,%eax
  jne    L1096
L1068:
  xor    %eax,%eax
  mov    $0xffffffff,%edx
  nopl   (%rax)
L648:
  mov    %edx,%ecx
  btc    %eax,%edx
  add    $0x1,%eax
  cmp    $0x20,%eax
  jne    L648
  cmp    $0x80000000,%ecx
  jne    L237
L725:
  xor    %eax,%eax
  mov    $0xffffffff,%edx
  nopl   0x0(%rax,%rax,1)
L694:
  mov    %edx,%ecx
  btc    %eax,%edx
  add    $0x1,%eax
  cmp    $0x20,%eax
  jne    L694
  cmp    $0x80000000,%ecx
  jne    L190
L907:
  xor    %eax,%eax
  mov    $0xffffffff,%edx
L1067:
  mov    %edx,%ecx
  btc    %eax,%edx
  add    $0x1,%eax
  cmp    $0x20,%eax
  jne    L1067
  cmp    $0x80000000,%ecx
  jne    L1001
L464:
  xor    %ecx,%ecx
  xor    %eax,%eax
  mov    $0x1,%esi
  nopw   0x0(%rax,%rax,1)
L351:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  or     %edx,%eax
  cmp    $0x20,%ecx
  jne    L351
  cmp    $0xffffffff,%eax
  je     L549
  xor    %eax,%eax
  call   <abort@plt>
L549:
  xor    %ecx,%ecx
  xor    %eax,%eax
  mov    $0x1,%esi
  nopl   0x0(%rax,%rax,1)
L366:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  or     %edx,%eax
  cmp    $0x20,%ecx
  jne    L366
  cmp    $0xffffffff,%eax
  je     L932
  xor    %eax,%eax
  call   <abort@plt>
L932:
  xor    %ecx,%ecx
  xor    %eax,%eax
  mov    $0x1,%esi
  nopl   0x0(%rax,%rax,1)
L582:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  or     %edx,%eax
  cmp    $0x20,%ecx
  jne    L582
  cmp    $0xffffffff,%eax
  je     L233
  xor    %eax,%eax
  call   <abort@plt>
L233:
  mov    $0x20,%eax
  mov    $0x1,%edx
  nopl   0x0(%rax)
L588:
  add    %rdx,%rdx
  sub    $0x1,%eax
  jne    L588
  movabs $0x100000000,%rax
  cmp    %rax,%rdx
  je     L1004
  xor    %eax,%eax
  call   <abort@plt>
L1004:
  mov    $0x20,%eax
  mov    $0x1,%edx
  nopl   0x0(%rax,%rax,1)
L501:
  add    %rdx,%rdx
  sub    $0x1,%eax
  jne    L501
  movabs $0x100000000,%rax
  cmp    %rax,%rdx
  je     L636
  xor    %eax,%eax
  call   <abort@plt>
L636:
  movabs $0x100000000,%rdx
  mov    $0x20,%eax
  nopl   (%rax)
L422:
  sar    %rdx
  sub    $0x1,%eax
  jne    L422
  cmp    $0x1,%rdx
  je     L514
  xor    %eax,%eax
  call   <abort@plt>
L514:
  movabs $0x100000000,%rdx
  mov    $0x20,%eax
  nopl   0x0(%rax)
L1000:
  sar    %rdx
  sub    $0x1,%eax
  jne    L1000
  cmp    $0x1,%rdx
  je     L142
  xor    %eax,%eax
  call   <abort@plt>
L142:
  mov    %rsp,%rbp
  pxor   %xmm3,%xmm3
  movss  D69(%rip),%xmm0
  lea    0x80(%rsp),%rbx
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopw   0x0(%rax,%rax,1)
L118:
  movaps %xmm1,%xmm2
  add    $0x4,%rax
  addss  %xmm0,%xmm1
  movss  %xmm2,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L118
  ucomiss D85(%rip),%xmm1
  jp     L1026
  jne    L1026
L284:
  movss  D85(%rip),%xmm4
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  cs nopw 0x0(%rax,%rax,1)
L29:
  movaps %xmm1,%xmm2
  add    $0x4,%rax
  subss  %xmm0,%xmm1
  movss  %xmm2,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L29
  ucomiss %xmm3,%xmm1
  jp     L290
  jne    L290
L475:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopw   0x0(%rax,%rax,1)
L1097:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L1097
  ucomiss D85(%rip),%xmm1
  jp     L35
  jne    L35
L3:
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  nopl   0x0(%rax,%rax,1)
L334:
  subss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L334
  ucomiss %xmm3,%xmm1
  jp     L88
  jne    L88
L875:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopw   0x0(%rax,%rax,1)
L696:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L696
  ucomiss D85(%rip),%xmm1
  jp     L62
  jne    L62
L878:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopl   0x0(%rax,%rax,1)
L628:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L628
  ucomiss D85(%rip),%xmm1
  jp     L625
  jne    L625
L581:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopl   0x0(%rax,%rax,1)
L794:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L794
  ucomiss D85(%rip),%xmm1
  jp     L183
  jne    L183
L879:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopl   0x0(%rax,%rax,1)
L911:
  addss  %xmm1,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L911
  ucomiss D154(%rip),%xmm1
  jp     L119
  jne    L119
L149:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopl   0x0(%rax,%rax,1)
L700:
  addss  %xmm1,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L700
  ucomiss D154(%rip),%xmm1
  jp     L803
  jne    L803
L272:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopl   0x0(%rax,%rax,1)
L301:
  addss  %xmm1,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L301
  ucomiss D154(%rip),%xmm1
  jp     L502
  jne    L502
L352:
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  nopl   0x0(%rax,%rax,1)
L172:
  subss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L172
  ucomiss %xmm3,%xmm1
  jp     L246
  jne    L246
L735:
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  nopw   0x0(%rax,%rax,1)
L245:
  subss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L245
  ucomiss %xmm3,%xmm1
  jp     L987
  jne    L987
L494:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopw   0x0(%rax,%rax,1)
L563:
  movaps %xmm4,%xmm5
  add    $0x4,%rax
  subss  %xmm1,%xmm5
  movss  %xmm5,-0x4(%rax)
  movaps %xmm5,%xmm1
  cmp    %rax,%rbx
  jne    L563
  xor    %ebx,%ebx
  nopw   0x0(%rax,%rax,1)
L608:
  movss  0x0(%rbp),%xmm1
  test   $0x1,%bl
  jne    L754
  ucomiss D177(%rip),%xmm1
  jp     L1090
L820:
  jne    L1090
L90:
  add    $0x1,%ebx
  add    $0x4,%rbp
  cmp    $0x20,%ebx
  jne    L608
  movss  D154(%rip),%xmm1
  movss  D241(%rip),%xmm2
  mov    $0x20,%eax
  nopw   0x0(%rax,%rax,1)
L567:
  mulss  %xmm2,%xmm1
  sub    $0x1,%eax
  jne    L567
  ucomiss %xmm0,%xmm1
  jp     L551
  jne    L551
L655:
  movss  D154(%rip),%xmm1
  mov    $0x20,%eax
  nopl   (%rax)
L536:
  mulss  %xmm2,%xmm1
  sub    $0x1,%eax
  jne    L536
  ucomiss %xmm0,%xmm1
  jp     L309
  jne    L309
L1075:
  mov    0x88(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L663
  add    $0x98,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  ret
  nopl   0x0(%rax,%rax,1)
L754:
  ucomiss %xmm0,%xmm1
  jnp    L820
  nopl   0x0(%rax)
L1090:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  jmp    L90
L1001:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L464
L190:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L907
L309:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L1075
L551:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D241(%rip),%xmm2
  movss  D69(%rip),%xmm0
  jmp    L655
L987:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  movss  D85(%rip),%xmm4
  jmp    L494
L246:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L735
L502:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L352
L803:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L272
L119:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L149
L183:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L879
L625:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L581
L62:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L878
L88:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L875
L35:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L3
L290:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D85(%rip),%xmm4
  jmp    L475
L1026:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D69(%rip),%xmm0
  pxor   %xmm3,%xmm3
  jmp    L284
L237:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L725
L1096:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L1068
L962:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L672
L147:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L644
L663:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: data_label: D69
type_infered: f32
name: unpack_data
arguments: data_label: D85
type_infered: f32
name: unpack_data
arguments: data_label: D154
type_infered: byte[4]
name: unpack_data
arguments: data_label: D177
type_infered: f32
name: unpack_data
arguments: data_label: D241
type_infered: byte[4]

tool: D69: 1

tool: D85: 32

tool: {"D154": [0x00,0x00,0x80,0x4f]}

tool: D177: 31

tool: {"D241": [0x00,0x00,0x00,0x3f]}

assistant: ```c
int main(int argc, char **argv) {
  int iexp, igot;
  long long lexp, lgot;
  int N = 32;
  int idata[N];
  long long ldata[N];
  float fexp, fgot;
  float fdata[N];
  int i;
  igot = 0;
  iexp = 32;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      idata[i] = igot++;
    }
  }
  if (iexp != igot)
    abort();
  igot = 32;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      idata[i] = igot--;
    }
  }
  if (iexp != igot)
    abort();
  igot = 0;
  iexp = 32;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      idata[i] = ++igot;
    }
  }
  if (iexp != igot)
    abort();
  igot = 32;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      idata[i] = --igot;
    }
  }
  igot = 0;
  iexp = 32;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = igot += expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = 0;
  iexp = 32;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = igot = igot + expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = 0;
  iexp = 32;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = igot = expr + igot;
    }
  }
  if (iexp != igot)
    abort();
  lgot = 1LL;
  lexp = 1LL << N;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 2LL;
#pragma acc atomic capture
      ldata[i] = lgot *= expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL;
  lexp = 1LL << N;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 2LL;
#pragma acc atomic capture
      ldata[i] = lgot = lgot * expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL;
  lexp = 1LL << N;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 2LL;
#pragma acc atomic capture
      ldata[i] = lgot = expr * lgot;
    }
  }
  if (lexp != lgot)
    abort();
  igot = 32;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = igot -= expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = 32;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = igot = igot - expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = 32;
  iexp = 32;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = igot = expr - igot;
    }
  }
  if (iexp != igot)
    abort();
  lgot = 1LL << 32;
  lexp = 1LL;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 2LL;
#pragma acc atomic capture
      ldata[i] = lgot /= expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL << 32;
  lexp = 1LL;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 2LL;
#pragma acc atomic capture
      ldata[i] = lgot = lgot / expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 2LL;
  lexp = 2LL;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 1LL << N;
#pragma acc atomic capture
      ldata[i] = lgot = expr / lgot;
    }
  }
  if (lexp != lgot)
    abort();
  igot = ~0;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot &= expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = ~0;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot = igot & expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = ~0;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot = expr & igot;
    }
  }
  if (iexp != igot)
    abort();
  igot = ~0;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot ^= expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = ~0;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot = igot ^ expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = ~0;
  iexp = 0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot = expr ^ igot;
    }
  }
  if (iexp != igot)
    abort();
  igot = 0;
  iexp = ~0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot |= expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = 0;
  iexp = ~0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot = igot | expr;
    }
  }
  if (iexp != igot)
    abort();
  igot = 0;
  iexp = ~0;
#pragma acc data copy(igot, idata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1 << i;
#pragma acc atomic capture
      idata[i] = igot = expr | igot;
    }
  }
  if (iexp != igot)
    abort();
  lgot = 1LL;
  lexp = 1LL << N;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      ldata[i] = lgot <<= expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL;
  lexp = 1LL << N;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      idata[i] = lgot = lgot << expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL;
  lexp = 2LL;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel
    {
      long long expr = 1LL;
#pragma acc atomic capture
      ldata[0] = lgot = expr << lgot;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL << N;
  lexp = 1LL;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 1LL;
#pragma acc atomic capture
      ldata[i] = lgot >>= expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL << N;
  lexp = 1LL;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      int expr = 1;
#pragma acc atomic capture
      ldata[i] = lgot = lgot >> expr;
    }
  }
  if (lexp != lgot)
    abort();
  lgot = 1LL << 63;
  lexp = 1LL << 32;
#pragma acc data copy(lgot, ldata [0:N])
  {
#pragma acc parallel
    {
      long long expr = 1LL << 32;
#pragma acc atomic capture
      ldata[0] = lgot = expr >> lgot;
    }
  }
  if (lexp != lgot)
    abort();
  fgot = 0.0;
  fexp = 32.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      fdata[i] = fgot++;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 32.0;
  fexp = 0.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      fdata[i] = fgot--;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 0.0;
  fexp = 32.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      fdata[i] = ++fgot;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 32.0;
  fexp = 0.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
#pragma acc atomic capture
      fdata[i] = --fgot;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 0.0;
  fexp = 32.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 1.0;
#pragma acc atomic capture
      fdata[i] = fgot += expr;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 0.0;
  fexp = 32.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 1.0;
#pragma acc atomic capture
      fdata[i] = fgot = fgot + expr;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 0.0;
  fexp = 32.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 1.0;
#pragma acc atomic capture
      fdata[i] = fgot = expr + fgot;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 1.0;
  fexp = 8192.0 * 8192.0 * 64.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 2.0;
#pragma acc atomic capture
      fdata[i] = fgot *= expr;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 1.0;
  fexp = 8192.0 * 8192.0 * 64.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      long long expr = 2LL;
#pragma acc atomic capture
      fdata[i] = fgot = fgot * expr;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 1.0;
  fexp = 8192.0 * 8192.0 * 64.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 2.0;
#pragma acc atomic capture
      fdata[i] = fgot = expr * fgot;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 32.0;
  fexp = 0.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 1.0;
#pragma acc atomic capture
      fdata[i] = fgot -= expr;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 32.0;
  fexp = 0.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 1.0;
#pragma acc atomic capture
      fdata[i] = fgot = fgot - expr;
    }
  }
  if (fexp != fgot)
    abort();
  fgot = 1.0;
  fexp = 0.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 32.0;
#pragma acc atomic capture
      fdata[i] = fgot = expr - fgot;
    }
  }
  for (i = 0; i < N; i++)
    if (i % 2 == 0) {
      if (fdata[i] != 31.0)
        abort();
    } else {
      if (fdata[i] != 1.0)
        abort();
    }
  fexp = 1.0;
  fgot = 8192.0 * 8192.0 * 64.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 2.0;
#pragma acc atomic capture
      fdata[i] = fgot /= expr;
    }
  }
  if (fexp != fgot)
    abort();
  fexp = 1.0;
  fgot = 8192.0 * 8192.0 * 64.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel loop
    for (i = 0; i < N; i++) {
      float expr = 2.0;
#pragma acc atomic capture
      fdata[i] = fgot = fgot / expr;
    }
  }
  if (fexp != fgot)
    abort();
  fexp = 1.0;
  fgot = 8192.0 * 8192.0 * 64.0;
#pragma acc data copy(fgot, fdata [0:N])
  {
#pragma acc parallel
    {
      float expr = 8192.0 * 8192.0 * 64.0;
#pragma acc atomic capture
      fdata[0] = fgot = expr / fgot;
    }
  }
  if (fexp != fgot)
    abort();
  return 0;
}
```