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

```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)
L191:
  mov    %rax,%rcx
  add    %rax,%rax
  sub    $0x1,%edx
  jne    L191
  mov    $0x80000000,%eax
  cmp    %rax,%rcx
  je     L404
  xor    %eax,%eax
  call   <abort@plt>
L404:
  mov    $0x20,%edx
  mov    $0x1,%eax
  cs nopw 0x0(%rax,%rax,1)
L211:
  mov    %rax,%rcx
  add    %rax,%rax
  sub    $0x1,%edx
  jne    L211
  mov    $0x80000000,%eax
  cmp    %rax,%rcx
  je     L463
  xor    %eax,%eax
  call   <abort@plt>
L463:
  mov    $0x20,%edx
  mov    $0x1,%eax
  cs nopw 0x0(%rax,%rax,1)
L771:
  mov    %rax,%rcx
  add    %rax,%rax
  sub    $0x1,%edx
  jne    L771
  mov    $0x80000000,%eax
  cmp    %rax,%rcx
  je     L146
  xor    %eax,%eax
  call   <abort@plt>
L146:
  mov    $0x20,%eax
  mov    $0x20,%edx
  mov    $0x1,%ecx
  nopl   0x0(%rax,%rax,1)
L419:
  mov    %ecx,%edi
  sub    %edx,%edi
  mov    %edi,%edx
  sub    $0x1,%eax
  jne    L419
  cmp    $0x20,%edi
  je     L858
  xor    %eax,%eax
  call   <abort@plt>
L858:
  movabs $0x100000000,%rax
  mov    $0x20,%edx
  cs nopw 0x0(%rax,%rax,1)
L746:
  mov    %rax,%rcx
  shr    $0x3f,%rcx
  add    %rcx,%rax
  sar    %rax
  sub    $0x1,%edx
  jne    L746
  cmp    $0x1,%rax
  je     L536
  xor    %eax,%eax
  call   <abort@plt>
L536:
  movabs $0x100000000,%rax
  mov    $0x20,%edx
  xchg   %ax,%ax
L1090:
  mov    %rax,%rcx
  shr    $0x3f,%rcx
  add    %rcx,%rax
  sar    %rax
  sub    $0x1,%edx
  jne    L1090
  cmp    $0x1,%rax
  je     L690
  xor    %eax,%eax
  call   <abort@plt>
L690:
  mov    $0x20,%esi
  mov    $0x2,%ecx
  movabs $0x100000000,%rdi
  nopl   0x0(%rax,%rax,1)
L324:
  mov    %rdi,%rax
  cqto
  idiv   %rcx
  mov    %rax,%rcx
  sub    $0x1,%esi
  jne    L324
  cmp    $0x2,%rax
  je     L485
  xor    %eax,%eax
  call   <abort@plt>
L485:
  xor    %ecx,%ecx
  mov    $0xffffffff,%eax
  mov    $0x1,%esi
  nopl   0x0(%rax)
L538:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  and    %edx,%eax
  cmp    $0x20,%ecx
  jne    L538
  test   %eax,%eax
  jne    L868
L1032:
  xor    %ecx,%ecx
  mov    $0xffffffff,%eax
  mov    $0x1,%esi
  nopw   0x0(%rax,%rax,1)
L20:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  and    %edx,%eax
  cmp    $0x20,%ecx
  jne    L20
  test   %eax,%eax
  jne    L667
L553:
  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    L251
L676:
  xor    %eax,%eax
  mov    $0xffffffff,%edx
  nopl   (%rax)
L1024:
  mov    %edx,%ecx
  btc    %eax,%edx
  add    $0x1,%eax
  cmp    $0x20,%eax
  jne    L1024
  cmp    $0x80000000,%ecx
  jne    L573
L712:
  xor    %eax,%eax
  mov    $0xffffffff,%edx
  nopl   0x0(%rax,%rax,1)
L1092:
  mov    %edx,%ecx
  btc    %eax,%edx
  add    $0x1,%eax
  cmp    $0x20,%eax
  jne    L1092
  cmp    $0x80000000,%ecx
  jne    L564
L484:
  xor    %eax,%eax
  mov    $0xffffffff,%edx
L395:
  mov    %edx,%ecx
  btc    %eax,%edx
  add    $0x1,%eax
  cmp    $0x20,%eax
  jne    L395
  cmp    $0x80000000,%ecx
  jne    L763
L284:
  xor    %ecx,%ecx
  xor    %eax,%eax
  mov    $0x1,%esi
  nopw   0x0(%rax,%rax,1)
L508:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  or     %edx,%eax
  cmp    $0x20,%ecx
  jne    L508
  cmp    $0xffffffff,%eax
  je     L967
  xor    %eax,%eax
  call   <abort@plt>
L967:
  xor    %ecx,%ecx
  xor    %eax,%eax
  mov    $0x1,%esi
  nopl   0x0(%rax,%rax,1)
L818:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  or     %edx,%eax
  cmp    $0x20,%ecx
  jne    L818
  cmp    $0xffffffff,%eax
  je     L31
  xor    %eax,%eax
  call   <abort@plt>
L31:
  xor    %ecx,%ecx
  xor    %eax,%eax
  mov    $0x1,%esi
  nopl   0x0(%rax,%rax,1)
L781:
  mov    %esi,%edx
  shl    %cl,%edx
  add    $0x1,%ecx
  or     %edx,%eax
  cmp    $0x20,%ecx
  jne    L781
  cmp    $0xffffffff,%eax
  je     L638
  xor    %eax,%eax
  call   <abort@plt>
L638:
  mov    $0x20,%eax
  mov    $0x1,%edx
  nopl   0x0(%rax)
L732:
  add    %rdx,%rdx
  sub    $0x1,%eax
  jne    L732
  movabs $0x100000000,%rax
  cmp    %rax,%rdx
  je     L114
  xor    %eax,%eax
  call   <abort@plt>
L114:
  mov    $0x20,%eax
  mov    $0x1,%edx
  nopl   0x0(%rax,%rax,1)
L413:
  add    %rdx,%rdx
  sub    $0x1,%eax
  jne    L413
  movabs $0x100000000,%rax
  cmp    %rax,%rdx
  je     L409
  xor    %eax,%eax
  call   <abort@plt>
L409:
  movabs $0x100000000,%rdx
  mov    $0x20,%eax
  nopl   (%rax)
L604:
  sar    %rdx
  sub    $0x1,%eax
  jne    L604
  cmp    $0x1,%rdx
  je     L205
  xor    %eax,%eax
  call   <abort@plt>
L205:
  movabs $0x100000000,%rdx
  mov    $0x20,%eax
  nopl   0x0(%rax)
L791:
  sar    %rdx
  sub    $0x1,%eax
  jne    L791
  cmp    $0x1,%rdx
  je     L240
  xor    %eax,%eax
  call   <abort@plt>
L240:
  mov    %rsp,%rbp
  pxor   %xmm3,%xmm3
  movss  D299(%rip),%xmm0
  lea    0x80(%rsp),%rbx
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopw   0x0(%rax,%rax,1)
L281:
  movaps %xmm1,%xmm2
  add    $0x4,%rax
  addss  %xmm0,%xmm1
  movss  %xmm2,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L281
  ucomiss D356(%rip),%xmm1
  jp     L856
  jne    L856
L800:
  movss  D356(%rip),%xmm4
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  cs nopw 0x0(%rax,%rax,1)
L220:
  movaps %xmm1,%xmm2
  add    $0x4,%rax
  subss  %xmm0,%xmm1
  movss  %xmm2,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L220
  ucomiss %xmm3,%xmm1
  jp     L587
  jne    L587
L445:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopw   0x0(%rax,%rax,1)
L996:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L996
  ucomiss D356(%rip),%xmm1
  jp     L870
  jne    L870
L987:
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  nopl   0x0(%rax,%rax,1)
L170:
  subss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L170
  ucomiss %xmm3,%xmm1
  jp     L209
  jne    L209
L697:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopw   0x0(%rax,%rax,1)
L394:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L394
  ucomiss D356(%rip),%xmm1
  jp     L187
  jne    L187
L930:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopl   0x0(%rax,%rax,1)
L664:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L664
  ucomiss D356(%rip),%xmm1
  jp     L1044
  jne    L1044
L296:
  mov    %rbp,%rax
  movaps %xmm3,%xmm1
  nopl   0x0(%rax,%rax,1)
L934:
  addss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L934
  ucomiss D356(%rip),%xmm1
  jp     L579
  jne    L579
L156:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopl   0x0(%rax,%rax,1)
L687:
  addss  %xmm1,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L687
  ucomiss D44(%rip),%xmm1
  jp     L54
  jne    L54
L185:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopl   0x0(%rax,%rax,1)
L495:
  addss  %xmm1,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rax,%rbx
  jne    L495
  ucomiss D44(%rip),%xmm1
  jp     L819
  jne    L819
L364:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopl   0x0(%rax,%rax,1)
L265:
  addss  %xmm1,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L265
  ucomiss D44(%rip),%xmm1
  jp     L134
  jne    L134
L242:
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  nopl   0x0(%rax,%rax,1)
L1058:
  subss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L1058
  ucomiss %xmm3,%xmm1
  jp     L540
  jne    L540
L830:
  mov    %rbp,%rax
  movaps %xmm4,%xmm1
  nopw   0x0(%rax,%rax,1)
L479:
  subss  %xmm0,%xmm1
  add    $0x4,%rax
  movss  %xmm1,-0x4(%rax)
  cmp    %rbx,%rax
  jne    L479
  ucomiss %xmm3,%xmm1
  jp     L549
  jne    L549
L275:
  mov    %rbp,%rax
  movaps %xmm0,%xmm1
  nopw   0x0(%rax,%rax,1)
L475:
  movaps %xmm4,%xmm5
  add    $0x4,%rax
  subss  %xmm1,%xmm5
  movss  %xmm5,-0x4(%rax)
  movaps %xmm5,%xmm1
  cmp    %rax,%rbx
  jne    L475
  xor    %ebx,%ebx
  nopw   0x0(%rax,%rax,1)
L253:
  movss  0x0(%rbp),%xmm1
  test   $0x1,%bl
  jne    L292
  ucomiss D0(%rip),%xmm1
  jp     L969
L980:
  jne    L969
L279:
  add    $0x1,%ebx
  add    $0x4,%rbp
  cmp    $0x20,%ebx
  jne    L253
  movss  D44(%rip),%xmm1
  movss  D357(%rip),%xmm2
  mov    $0x20,%eax
  nopw   0x0(%rax,%rax,1)
L214:
  mulss  %xmm2,%xmm1
  sub    $0x1,%eax
  jne    L214
  ucomiss %xmm0,%xmm1
  jp     L58
  jne    L58
L244:
  movss  D44(%rip),%xmm1
  mov    $0x20,%eax
  nopl   (%rax)
L524:
  mulss  %xmm2,%xmm1
  sub    $0x1,%eax
  jne    L524
  ucomiss %xmm0,%xmm1
  jp     L1062
  jne    L1062
L720:
  mov    0x88(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L916
  add    $0x98,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  ret
  nopl   0x0(%rax,%rax,1)
L292:
  ucomiss %xmm0,%xmm1
  jnp    L980
  nopl   0x0(%rax)
L969:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  jmp    L279
L763:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L284
L564:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L484
L1062:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L720
L58:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D357(%rip),%xmm2
  movss  D299(%rip),%xmm0
  jmp    L244
L549:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  movss  D356(%rip),%xmm4
  jmp    L275
L540:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L830
L134:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L242
L819:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L364
L54:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L185
L579:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L156
L1044:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L296
L187:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L930
L209:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L697
L870:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L987
L587:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  movss  D356(%rip),%xmm4
  jmp    L445
L856:
  xor    %eax,%eax
  call   <abort@plt>
  movss  D299(%rip),%xmm0
  pxor   %xmm3,%xmm3
  jmp    L800
L573:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L712
L251:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L676
L667:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L553
L868:
  xor    %eax,%eax
  call   <abort@plt>
  jmp    L1032
L916:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: tag: D299
type_guessed: f32
name: unpack_data
arguments: tag: D356
type_guessed: f32
name: unpack_data
arguments: tag: D44
type_guessed: byte[4]
name: unpack_data
arguments: tag: D0
type_guessed: f32
name: unpack_data
arguments: tag: D357
type_guessed: byte[4]

tool: D299: 1

tool: D356: 32

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

tool: D0: 31

tool: {"D357": [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;
}
```