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

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  lea    -0x5000(%rsp),%r11
L166:
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  cmp    %r11,%rsp
  jne    L166
  sub    $0xd58,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x5d48(%rsp)
  xor    %eax,%eax
  call   <check_offloading@plt>
  xor    %eax,%eax
  call   <omp_is_initial_device@plt>
  lea    D260(%rip),%rsi
  lea    D359(%rip),%rdi
  test   %rax,%rax
  lea    D30(%rip),%rax
  cmove  %rax,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  call   <omp_get_initial_device@plt>
  lea    D171(%rip),%rdi
  mov    %eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x1,%edi
  call   <omp_set_default_device@plt>
  xor    %eax,%eax
  call   <omp_get_default_device@plt>
  lea    D312(%rip),%rdi
  mov    %eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  call   <omp_get_default_device@plt>
  lea    D11(%rip),%rdi
  mov    %eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x2,%edi
  call   <omp_set_default_device@plt>
  xor    %eax,%eax
  call   <omp_get_default_device@plt>
  lea    D565(%rip),%rdi
  mov    %eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %eax,%eax
  call   <omp_get_default_device@plt>
  lea    D197(%rip),%rdi
  mov    %eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  xor    %edi,%edi
  call   <omp_set_default_device@plt>
  xor    %eax,%eax
  call   <omp_get_num_devices@plt>
  movl   $0x0,0x4(%rsp)
  test   %rax,%rax
  je     L193
L359:
  lea    0x40(%rsp),%r12
  xor    %eax,%eax
  lea    0x1f40(%rsp),%r11
  mov    $0x3e0,%ecx
  mov    %r12,%rdi
  movapd D522(%rip),%xmm2
  mov    %r11,%rbx
  lea    0x3e40(%rsp),%rbp
  rep stos %rax,%es:(%rdi)
  mov    %r11,%rax
  cs nopw 0x0(%rax,%rax,1)
L382:
  movaps %xmm2,(%rax)
  add    $0x10,%rax
  cmp    %rbp,%rax
  jne    L382
  movdqa D356(%rip),%xmm1
  mov    %rbp,%r13
  mov    %rbp,%rax
  movdqa D454(%rip),%xmm3
  lea    0x5d40(%rsp),%r10
  nopw   0x0(%rax,%rax,1)
L476:
  movdqa %xmm1,%xmm0
  add    $0x20,%rax
  paddd  %xmm3,%xmm1
  cvtdq2pd %xmm0,%xmm4
  pshufd $0xee,%xmm0,%xmm0
  movaps %xmm4,-0x20(%rax)
  cvtdq2pd %xmm0,%xmm0
  movaps %xmm0,-0x10(%rax)
  cmp    %rax,%r10
  jne    L476
  mov    0x4(%rsp),%r14d
  mov    $0x1f00,%edi
  mov    %r10,0x30(%rsp)
  mov    %r11,0x28(%rsp)
  mov    %r14d,%esi
  call   <omp_target_alloc@plt>
  mov    %r14d,%esi
  mov    $0x1f00,%edi
  mov    %rax,0x8(%rsp)
  call   <omp_target_alloc@plt>
  mov    %r14d,%esi
  mov    $0x1f00,%edi
  mov    %rax,%r15
  call   <omp_target_alloc@plt>
  mov    0x28(%rsp),%r11
  mov    0x30(%rsp),%r10
  mov    %rax,%r14
  mov    0x8(%rsp),%rax
  test   %rax,%rax
  lea    -0x320(%rax),%rcx
  setne  %dl
  test   %r15,%r15
  mov    %rcx,0x20(%rsp)
  lea    -0x640(%r15),%rcx
  setne  %al
  mov    %rcx,0x10(%rsp)
  lea    -0x960(%r14),%rcx
  test   %al,%dl
  mov    %rcx,0x18(%rsp)
  je     L332
  lea    D116(%rip),%rsi
  test   %r14,%r14
  je     L332
L97:
  lea    D99(%rip),%rdi
  xor    %eax,%eax
  mov    %r11,0x30(%rsp)
  mov    %r10,0x28(%rsp)
  call   <printf@plt>
  xor    %eax,%eax
  call   <omp_get_initial_device@plt>
  mov    $0xa0,%r8d
  mov    $0x640,%ecx
  lea    0x1ea0(%rsp),%rsi
  sub    $0x8,%rsp
  mov    $0x1f00,%edx
  push   %rax
  mov    0x14(%rsp),%r9d
  mov    0x20(%rsp),%rdi
  call   <omp_target_memcpy@plt>
  xor    %eax,%eax
  call   <omp_get_initial_device@plt>
  mov    0x14(%rsp),%r9d
  mov    0x28(%rsp),%rdi
  lea    0x3d60(%rsp),%rsi
  mov    $0x960,%ecx
  mov    $0xf0,%r8d
  mov    $0x1f00,%edx
  mov    %eax,(%rsp)
  call   <omp_target_memcpy@plt>
  pop    %rcx
  pop    %rsi
  lea    0x8(%r15),%rax
  mov    0x8(%rsp),%rcx
  mov    0x28(%rsp),%r10
  mov    0x30(%rsp),%r11
  movapd D522(%rip),%xmm2
  cmp    %rax,%rcx
  je     L216
  lea    0x8(%r14),%rax
  cmp    %rax,%rcx
  je     L216
  xor    %eax,%eax
  mov    %rcx,%rdx
  nopw   0x0(%rax,%rax,1)
L369:
  movupd (%r15,%rax,1),%xmm0
  movupd (%r14,%rax,1),%xmm5
  addpd  %xmm5,%xmm0
  addpd  %xmm2,%xmm0
  movups %xmm0,(%rdx,%rax,1)
  add    $0x10,%rax
  cmp    $0x1f00,%rax
  jne    L369
L469:
  xor    %eax,%eax
  mov    %r11,0x38(%rsp)
  mov    %r10,0x28(%rsp)
  call   <omp_get_initial_device@plt>
  lea    -0x10(%rsp),%rdi
  sub    $0x8,%rsp
  mov    $0x320,%r8d
  mov    %eax,%r9d
  mov    0xc(%rsp),%eax
  mov    $0x50,%ecx
  mov    $0x1f00,%edx
  push   %rax
  mov    0x30(%rsp),%rsi
  call   <omp_target_memcpy@plt>
  pop    %rax
  xor    %ecx,%ecx
  pop    %rdx
  xor    %r8d,%r8d
  mov    %rbx,0x20(%rsp)
  xor    %edx,%edx
  mov    %rcx,%rbx
  mov    %rbp,0x30(%rsp)
  mov    %r8d,%ebp
  jmp    L276
  nopl   0x0(%rax,%rax,1)
L428:
  add    $0x1,%rbx
  cmp    $0x3e0,%rbx
  je     L432
L276:
  lea    0x2(%rbx),%eax
  pxor   %xmm0,%xmm0
  movsd  (%r12,%rbx,8),%xmm1
  mov    %ebx,%esi
  cvtsi2sd %eax,%xmm0
  ucomisd %xmm0,%xmm1
  jp     L266
  je     L428
L266:
  lea    D42(%rip),%rdx
  lea    D48(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  lea    0x1(%rbp),%eax
  cmp    $0xa,%ebp
  jg     L333
  add    $0x1,%rbx
  mov    %eax,%ebp
  mov    $0x1,%edx
  cmp    $0x3e0,%rbx
  jne    L276
L432:
  mov    0x20(%rsp),%rbx
  mov    0x28(%rsp),%r10
  mov    0x30(%rsp),%rbp
  mov    0x38(%rsp),%r11
  test   %edx,%edx
  jne    L420
  lea    D92(%rip),%rdi
  mov    %r11,0x28(%rsp)
  mov    %r10,0x20(%rsp)
  call   <puts@plt>
  mov    0x28(%rsp),%r11
  mov    0x20(%rsp),%r10
  movdqa D454(%rip),%xmm3
  movapd D522(%rip),%xmm2
  jmp    L417
L333:
  mov    0x20(%rsp),%rbx
  mov    0x28(%rsp),%r10
  mov    0x30(%rsp),%rbp
  mov    0x38(%rsp),%r11
L420:
  lea    D33(%rip),%rdi
  mov    %r11,0x28(%rsp)
  mov    %r10,0x20(%rsp)
  call   <puts@plt>
  mov    0x20(%rsp),%r10
  mov    0x28(%rsp),%r11
  movapd D522(%rip),%xmm2
  movdqa D454(%rip),%xmm3
L417:
  mov    $0x3e0,%ecx
  xor    %eax,%eax
  mov    %r12,%rdi
  rep stos %rax,%es:(%rdi)
  nop
L477:
  movaps %xmm2,(%rbx)
  add    $0x10,%rbx
  cmp    %rbp,%rbx
  jne    L477
  movdqa D356(%rip),%xmm1
  nopl   0x0(%rax)
L164:
  movdqa %xmm1,%xmm0
  add    $0x20,%r13
  paddd  %xmm3,%xmm1
  cvtdq2pd %xmm0,%xmm4
  pshufd $0xee,%xmm0,%xmm0
  movaps %xmm4,-0x20(%r13)
  cvtdq2pd %xmm0,%xmm0
  movaps %xmm0,-0x10(%r13)
  cmp    %r10,%r13
  jne    L164
  xor    %eax,%eax
  mov    %r11,0x20(%rsp)
  call   <offloading_disabled@plt>
  mov    0x20(%rsp),%r11
  test   %rax,%rax
  je     L269
  lea    D540(%rip),%rdi
  mov    %r11,0x10(%rsp)
  call   <puts@plt>
  lea    D116(%rip),%rsi
  lea    D568(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%rsp),%r11
L183:
  xor    %eax,%eax
  mov    %r11,0x10(%rsp)
  call   <offloading_disabled@plt>
  mov    0x10(%rsp),%r11
  test   %rax,%rax
  je     L257
  lea    D618(%rip),%rdi
  call   <puts@plt>
  lea    D116(%rip),%rsi
  lea    D623(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%rsp),%r11
L222:
  mov    0x4(%rsp),%esi
  mov    %r12,%rdi
  mov    %r11,0x10(%rsp)
  call   <omp_target_is_present@plt>
  mov    0x10(%rsp),%r11
  test   %rax,%rax
  jne    L149
L308:
  lea    D30(%rip),%rsi
L372:
  lea    D423(%rip),%rdi
  xor    %eax,%eax
  mov    %r11,0x10(%rsp)
  lea    D30(%rip),%r13
  call   <printf@plt>
  mov    0x4(%rsp),%esi
  mov    0x10(%rsp),%rdi
  lea    D260(%rip),%rbx
  call   <omp_target_is_present@plt>
  lea    D309(%rip),%rdi
  test   %rax,%rax
  mov    %r13,%rax
  cmovne %rbx,%rax
  mov    %rax,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x4(%rsp),%esi
  mov    %rbp,%rdi
  call   <omp_target_is_present@plt>
  mov    %r13,%rsi
  lea    D131(%rip),%rdi
  test   %rax,%rax
  cmovne %rbx,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%rsp),%r11
  movapd D522(%rip),%xmm2
  xor    %eax,%eax
  nopl   0x0(%rax,%rax,1)
L137:
  movapd (%r11,%rax,1),%xmm0
  addpd  0x0(%rbp,%rax,1),%xmm0
  addpd  %xmm2,%xmm0
  movaps %xmm0,(%r12,%rax,1)
  add    $0x10,%rax
  cmp    $0x1f00,%rax
  jne    L137
  xor    %eax,%eax
  mov    %r11,0x10(%rsp)
  call   <offloading_disabled@plt>
  mov    0x10(%rsp),%r11
  test   %rax,%rax
  je     L135
  lea    D51(%rip),%rdi
  call   <puts@plt>
  lea    D116(%rip),%rsi
  lea    D458(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
L374:
  xor    %eax,%eax
  call   <offloading_disabled@plt>
  test   %rax,%rax
  je     L424
  lea    D415(%rip),%rdi
  call   <puts@plt>
  lea    D116(%rip),%rsi
  lea    D79(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
L203:
  xor    %r13d,%r13d
  xor    %ebx,%ebx
  lea    D42(%rip),%rbp
  xor    %edx,%edx
  jmp    L247
  nopl   (%rax)
L181:
  add    $0x1,%r13
  cmp    $0x3e0,%r13
  je     L94
L247:
  lea    0x2(%r13),%eax
  pxor   %xmm0,%xmm0
  movsd  (%r12,%r13,8),%xmm1
  mov    %r13d,%esi
  cvtsi2sd %eax,%xmm0
  ucomisd %xmm0,%xmm1
  jp     L202
  je     L181
L202:
  mov    %rbp,%rdx
  lea    D48(%rip),%rdi
  mov    $0x2,%eax
  call   <printf@plt>
  lea    0x1(%rbx),%eax
  cmp    $0xa,%ebx
  jg     L255
  add    $0x1,%r13
  mov    %eax,%ebx
  mov    $0x1,%edx
  cmp    $0x3e0,%r13
  jne    L247
L94:
  test   %edx,%edx
  jne    L255
  lea    D163(%rip),%rdi
  call   <puts@plt>
  jmp    L152
L255:
  lea    D71(%rip),%rdi
  call   <puts@plt>
L152:
  mov    0x4(%rsp),%ebx
  mov    0x8(%rsp),%rdi
  mov    %ebx,%esi
  call   <omp_target_free@plt>
  mov    %ebx,%esi
  mov    %r15,%rdi
  call   <omp_target_free@plt>
  mov    %ebx,%esi
  mov    %r14,%rdi
  call   <omp_target_free@plt>
  mov    0x5d48(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L126
  add    $0x5d58,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L424:
  mov    0x4(%rsp),%esi
  mov    %rbp,%rdi
  call   <omp_target_is_present@plt>
  test   %rax,%rax
  je     L203
  lea    D415(%rip),%rdi
  call   <puts@plt>
  mov    0x4(%rsp),%esi
  mov    %rbp,%rdi
  call   <omp_target_disassociate_ptr@plt>
  lea    D116(%rip),%rsi
  lea    D79(%rip),%rdi
  test   %eax,%eax
  lea    D587(%rip),%rax
  cmovne %rax,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L203
L135:
  mov    0x4(%rsp),%esi
  mov    %r11,%rdi
  mov    %r11,0x10(%rsp)
  call   <omp_target_is_present@plt>
  test   %rax,%rax
  je     L374
  lea    D51(%rip),%rdi
  call   <puts@plt>
  mov    0x4(%rsp),%esi
  mov    0x10(%rsp),%rdi
  call   <omp_target_disassociate_ptr@plt>
  lea    D116(%rip),%rsi
  lea    D458(%rip),%rdi
  test   %eax,%eax
  lea    D587(%rip),%rax
  cmovne %rax,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L374
L269:
  mov    0x4(%rsp),%esi
  mov    %r11,%rdi
  mov    %r11,0x20(%rsp)
  call   <omp_target_is_present@plt>
  mov    0x20(%rsp),%r11
  test   %rax,%rax
  jne    L183
  lea    D540(%rip),%rdi
  call   <puts@plt>
  mov    0x20(%rsp),%r11
  mov    0x10(%rsp),%rsi
  mov    $0x640,%ecx
  mov    0x4(%rsp),%r8d
  mov    $0x1f00,%edx
  mov    %r11,%rdi
  mov    %r11,0x10(%rsp)
  call   <omp_target_associate_ptr@plt>
  lea    D116(%rip),%rsi
  lea    D568(%rip),%rdi
  test   %eax,%eax
  lea    D587(%rip),%rax
  cmovne %rax,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%rsp),%r11
  jmp    L183
L257:
  mov    0x4(%rsp),%esi
  mov    %rbp,%rdi
  mov    %r11,0x10(%rsp)
  call   <omp_target_is_present@plt>
  mov    0x10(%rsp),%r11
  test   %rax,%rax
  jne    L222
  lea    D618(%rip),%rdi
  call   <puts@plt>
  mov    0x4(%rsp),%r8d
  mov    0x18(%rsp),%rsi
  mov    %rbp,%rdi
  mov    $0x960,%ecx
  mov    $0x1f00,%edx
  call   <omp_target_associate_ptr@plt>
  lea    D116(%rip),%rsi
  lea    D623(%rip),%rdi
  test   %eax,%eax
  lea    D587(%rip),%rax
  cmovne %rax,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%rsp),%r11
  jmp    L222
L149:
  xor    %eax,%eax
  call   <offloading_disabled@plt>
  mov    0x10(%rsp),%r11
  lea    D260(%rip),%rsi
  test   %rax,%rax
  je     L372
  jmp    L308
L193:
  call   <omp_get_initial_device@plt>
  mov    %eax,0x4(%rsp)
  jmp    L359
L216:
  movsd  D522(%rip),%xmm1
  mov    0x8(%rsp),%rdx
  xor    %eax,%eax
  nopl   0x0(%rax)
L423:
  movsd  (%r15,%rax,1),%xmm0
  addsd  (%r14,%rax,1),%xmm0
  addsd  %xmm1,%xmm0
  movsd  %xmm0,(%rdx,%rax,1)
  add    $0x8,%rax
  cmp    $0x1f00,%rax
  jne    L423
  jmp    L469
L332:
  lea    D587(%rip),%rsi
  jmp    L97
L126:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: data_label: D260
type_infered: string
name: read_data
arguments: data_label: D359
type_infered: string
name: read_data
arguments: data_label: D30
type_infered: string
name: read_data
arguments: data_label: D171
type_infered: string
name: read_data
arguments: data_label: D312
type_infered: string
name: read_data
arguments: data_label: D11
type_infered: string
name: read_data
arguments: data_label: D565
type_infered: string
name: read_data
arguments: data_label: D197
type_infered: string
name: read_data
arguments: data_label: D522
type_infered: byte[16]
name: read_data
arguments: data_label: D356
type_infered: byte[16]
name: read_data
arguments: data_label: D454
type_infered: byte[16]
name: read_data
arguments: data_label: D116
type_infered: string
name: read_data
arguments: data_label: D99
type_infered: string
name: read_data
arguments: data_label: D42
type_infered: string
name: read_data
arguments: data_label: D48
type_infered: string
name: read_data
arguments: data_label: D92
type_infered: string
name: read_data
arguments: data_label: D33
type_infered: string
name: read_data
arguments: data_label: D540
type_infered: string
name: read_data
arguments: data_label: D568
type_infered: string
name: read_data
arguments: data_label: D618
type_infered: string
name: read_data
arguments: data_label: D623
type_infered: string
name: read_data
arguments: data_label: D423
type_infered: string
name: read_data
arguments: data_label: D309
type_infered: string
name: read_data
arguments: data_label: D131
type_infered: string
name: read_data
arguments: data_label: D51
type_infered: string
name: read_data
arguments: data_label: D458
type_infered: string
name: read_data
arguments: data_label: D415
type_infered: string
name: read_data
arguments: data_label: D79
type_infered: string
name: read_data
arguments: data_label: D163
type_infered: string
name: read_data
arguments: data_label: D71
type_infered: string
name: read_data
arguments: data_label: D587
type_infered: string

tool: 

tool: D359: Is%s initial device


tool: D30:  not

tool: D171: Initial device: %d


tool: D312: Default device before task: %d


tool: D11: Default device inside task: %d


tool: D565: Default device inside task after resetting: %d


tool: D197: Default device outside task: %d


tool: {"D522": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: {"D356": [0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x03,0x00,0x00,0x00]}

tool: {"D454": [0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00]}

tool: D116: succeeded

tool: D99: omp_target_alloc %s


tool: D42: A[i]

tool: D48: Failed at %3d with %s, expected %f, got %f


tool: D92: Test omp_target_memcpy: Succeeded

tool: D33: Test omp_target_memcpy: Failed

tool: D540: C is not present, associating it...

tool: D568: omp_target_associate_ptr C %s


tool: D618: D is not present, associating it...

tool: D623: omp_target_associate_ptr D %s


tool: D423: Inside target data: A is%s present


tool: D309: Inside target data: C is%s present


tool: D131: Inside target data: D is%s present


tool: D51: C is present, disassociating it...

tool: D458: omp_target_disassociate_ptr C %s


tool: D415: D is present, disassociating it...

tool: D79: omp_target_disassociate_ptr D %s


tool: D163: Test omp_target_associate_ptr: Succeeded

tool: D71: Test omp_target_associate_ptr: Failed

tool: D587: failed

assistant: ```c
int main(void) {
  check_offloading();
  printf("Is%s initial device\n", omp_is_initial_device() ? "" : " not");
  printf("Initial device: %d\n", omp_get_initial_device());
  omp_set_default_device(1);
  printf("Default device before task: %d\n", omp_get_default_device());
#pragma omp task
  {
    printf("Default device inside task: %d\n", omp_get_default_device());
    omp_set_default_device(2);
    printf("Default device inside task after resetting: %d\n", omp_get_default_device());
  }
#pragma omp taskwait
  printf("Default device outside task: %d\n", omp_get_default_device());
  const int default_device = 0;
  omp_set_default_device(default_device);
  int default_device_omp_target_call = default_device;
  if (omp_get_num_devices() == 0) {
    default_device_omp_target_call = omp_get_initial_device();
  }
  double A[(992)], B[(992)], C[(992)], D[(992)], E[(992)];
  double *pA, *pB, *pC, *pD, *pE;
  pA = &A[0];
  pB = &B[0];
  pC = &C[0];
  pD = &D[0];
  pE = &E[0];
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  pA = pA - 10;
  pC = pC - 20;
  pD = pD - 30;
  void *device_A = omp_target_alloc((992) * sizeof(double), default_device_omp_target_call);
  void *device_C = omp_target_alloc((992) * sizeof(double), default_device_omp_target_call);
  void *device_D = omp_target_alloc((992) * sizeof(double), default_device_omp_target_call);
  double *dpA = (double *)device_A - 100;
  double *dpC = (double *)device_C - 200;
  double *dpD = (double *)device_D - 300;
  printf("omp_target_alloc %s\n", device_A && device_C && device_D ? "succeeded" : "failed");
  omp_target_memcpy(dpC, pC, (992) * sizeof(double), 200 * sizeof(double), 20 * sizeof(double), default_device_omp_target_call, omp_get_initial_device());
  omp_target_memcpy(dpD, pD, (992) * sizeof(double), 300 * sizeof(double), 30 * sizeof(double), default_device_omp_target_call, omp_get_initial_device());
#pragma omp target is_device_ptr(dpA, dpC, dpD) device(default_device)
  {
#pragma omp parallel for schedule(static, 1)
    for (int i = 0; i < 992; i++)
      dpA[i + 100] = dpC[i + 200] + dpD[i + 300] + 1;
  }
  omp_target_memcpy(pA, dpA, (992) * sizeof(double), 10 * sizeof(double), 100 * sizeof(double), omp_get_initial_device(), default_device_omp_target_call);
  int fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < (992); i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test omp_target_memcpy: Failed\n");
  } else {
    printf("Test omp_target_memcpy: Succeeded\n");
  }
  {
    int i;
    for (i = 0; i < (992); i++) {
      {
        A[i] = 0;
        C[i] = 1;
        D[i] = i;
        E[i] = -i;
      }
    }
  };
  if (offloading_disabled()) {
    printf("C is not present, associating it...\n");
    printf("omp_target_associate_ptr C %s\n", 1 ? "succeeded" : "failed");
  } else if (!omp_target_is_present(C, default_device_omp_target_call)) {
    printf("C is not present, associating it...\n");
    int rc = omp_target_associate_ptr(C, dpC, (992) * sizeof(double), 200 * sizeof(double), default_device_omp_target_call);
    printf("omp_target_associate_ptr C %s\n", !rc ? "succeeded" : "failed");
  }
  if (offloading_disabled()) {
    printf("D is not present, associating it...\n");
    printf("omp_target_associate_ptr D %s\n", 1 ? "succeeded" : "failed");
  } else if (!omp_target_is_present(D, default_device_omp_target_call)) {
    printf("D is not present, associating it...\n");
    int rc = omp_target_associate_ptr(D, dpD, (992) * sizeof(double), 300 * sizeof(double), default_device_omp_target_call);
    printf("omp_target_associate_ptr D %s\n", !rc ? "succeeded" : "failed");
  }
#pragma omp target data map(from : C, D) device(default_device)
  {
    printf("Inside target data: A is%s present\n", (omp_target_is_present(A, default_device_omp_target_call) && !offloading_disabled()) ? "" : " not");
    printf("Inside target data: C is%s present\n", omp_target_is_present(C, default_device_omp_target_call) ? "" : " not");
    printf("Inside target data: D is%s present\n", omp_target_is_present(D, default_device_omp_target_call) ? "" : " not");
#pragma omp target map(from : A) device(default_device)
    {
#pragma omp parallel for schedule(static, 1)
      for (int i = 0; i < 992; i++)
        A[i] = C[i] + D[i] + 1;
    }
  }
  if (offloading_disabled()) {
    printf("C is present, disassociating it...\n");
    printf("omp_target_disassociate_ptr C %s\n", 1 ? "succeeded" : "failed");
  } else if (omp_target_is_present(C, default_device_omp_target_call)) {
    printf("C is present, disassociating it...\n");
    int rc = omp_target_disassociate_ptr(C, default_device_omp_target_call);
    printf("omp_target_disassociate_ptr C %s\n", !rc ? "succeeded" : "failed");
  }
  if (offloading_disabled()) {
    printf("D is present, disassociating it...\n");
    printf("omp_target_disassociate_ptr D %s\n", 1 ? "succeeded" : "failed");
  } else if (omp_target_is_present(D, default_device_omp_target_call)) {
    printf("D is present, disassociating it...\n");
    int rc = omp_target_disassociate_ptr(D, default_device_omp_target_call);
    printf("omp_target_disassociate_ptr D %s\n", !rc ? "succeeded" : "failed");
  }
  fail = 0;
  {
    int i;
    int errorNum = 0;
    for (i = 0; i < (992); i++) {
      if (A[i] != (double)(i + 2)) {
        printf("Failed at %3d with %s, expected %f, got %f\n", i, "A[i]", (double)(i + 2), A[i]);
        fail = 1;
        if (errorNum++ > 10)
          break;
      }
    }
  };
  if (fail) {
    printf("Test omp_target_associate_ptr: Failed\n");
  } else {
    printf("Test omp_target_associate_ptr: Succeeded\n");
  }
  omp_target_free(device_A, default_device_omp_target_call);
  omp_target_free(device_C, default_device_omp_target_call);
  omp_target_free(device_D, default_device_omp_target_call);
  return 0;
}
```