// { dg-do compile { target c++17 } }

typedef enum omp_allocator_handle_t
: __UINTPTR_TYPE__
{
  omp_null_allocator = 0,
  omp_default_mem_alloc = 1,
  omp_large_cap_mem_alloc = 2,
  omp_const_mem_alloc = 3,
  omp_high_bw_mem_alloc = 4,
  omp_low_lat_mem_alloc = 5,
  omp_cgroup_mem_alloc = 6,
  omp_pteam_mem_alloc = 7,
  omp_thread_mem_alloc = 8,
  __omp_allocator_handle_t_max__ = __UINTPTR_MAX__
} omp_allocator_handle_t;

typedef enum omp_sync_hint_t {
omp_sync_hint_none = 0x0,
omp_lock_hint_none = omp_sync_hint_none,
omp_sync_hint_uncontended = 0x1,
omp_lock_hint_uncontended = omp_sync_hint_uncontended,
omp_sync_hint_contended = 0x2,
omp_lock_hint_contended = omp_sync_hint_contended,
omp_sync_hint_nonspeculative = 0x4,
omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative,
omp_sync_hint_speculative = 0x8,
omp_lock_hint_speculative = omp_sync_hint_speculative
} omp_sync_hint_t;

typedef struct __attribute__((__aligned__ (sizeof (void *)))) omp_depend_t {
  char __omp_depend_t__[2 * sizeof (void *)];
} omp_depend_t;

int t;
#pragma omp threadprivate (t)

#pragma omp declare target
int f, l, ll, r, r2;

void
foo (int d, int m, int i1, int i2, int p, int *idp, int s,
     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm)
{
  [[omp::directive (distribute parallel for,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),order(concurrent),allocate (omp_default_mem_alloc:f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for simd,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    if (parallel: i2),if(simd: i1),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),nontemporal(ntm),
    safelen(8),simdlen(4),aligned(q: 32),order(concurrent),allocate (omp_default_mem_alloc:f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute simd,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    safelen(8),simdlen(4),aligned(q: 32),reduction(+:r),if(i1),nontemporal(ntm),
    order(concurrent),allocate (omp_default_mem_alloc:f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    allocate (omp_default_mem_alloc:f),order(concurrent))]]
  for (int i = 0; i < 64; i++)
    ll++;
}

void
qux (int p)
{
  [[omp::directive (loop, bind(teams),order(concurrent),
    private (p),lastprivate (l),collapse(1),reduction(+:r))]]
  for (l = 0; l < 64; ++l)
    ll++;
}
#pragma omp end declare target

void
baz (int d, int m, int i1, int i2, int p, int *idp, int s,
     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int ntm)
{
  [[omp::directive (distribute parallel for,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),copyin(t),allocate (p))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),order(concurrent),allocate (p))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for simd,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    if (parallel: i2),if(simd: i1),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),nontemporal(ntm),
    safelen(8),simdlen(4),aligned(q: 32),copyin(t),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute parallel for simd,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    if (parallel: i2),if(simd: i1),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),nontemporal(ntm),
    safelen(8),simdlen(4),aligned(q: 32),order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (distribute simd,
    private (p),firstprivate (f),collapse(1),dist_schedule(static, 16),
    safelen(8),simdlen(4),aligned(q: 32),reduction(+:r),if(i1),nontemporal(ntm),
    order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (loop, bind(parallel),order(concurrent),
    private (p),lastprivate (l),collapse(1),reduction(+:r))]]
  for (l = 0; l < 64; ++l)
    ll++;
}

void
bar (int d, int m, int i1, int i2, int i3, int p, int *idp, int s,
     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int *dd, int ntm,
     const char *msg)
{
  [[omp::directive (nothing)]];
  [[omp::directive (error, at (execution), severity (warning), message (msg))]];
  [[omp::directive (for simd,
    private (p),firstprivate (f),lastprivate (l),linear (ll:1),reduction(+:r),schedule(static, 4),collapse(1),nowait,
    safelen(8),simdlen(4),aligned(q: 32),nontemporal(ntm),if(i1),order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (for,
    private (p),firstprivate (f),lastprivate (l),linear (ll:1),reduction(+:r),schedule(static, 4),collapse(1),nowait,
    order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (simd,
    private (p),lastprivate (l),linear (ll:1),reduction(+:r),collapse(1),safelen(8),simdlen(4),aligned(q: 32),
    nontemporal(ntm),if(i1),order(concurrent))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel for,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),copyin(t),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),linear (ll:1),ordered schedule(static, 4),collapse(1),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel for,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),copyin(t),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),linear (ll:1),schedule(static, 4),collapse(1),order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel for simd,
    private (p),firstprivate (f),if (i2),default(shared),shared(s),copyin(t),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),linear (ll:1),schedule(static, 4),collapse(1),
    safelen(8),simdlen(4),aligned(q: 32),nontemporal(ntm),order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel sections,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),copyin(t),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),allocate (f))]]
  {
    [[using omp:directive (section)]]
    {}
    [[omp::sequence (omp::directive (section))]]
    {}
  }
  [[omp::directive (sections, private (p),firstprivate (f),reduction(+:r),lastprivate (l),allocate (f),nowait)]]
  {
    ;
    [[omp::sequence (sequence (directive (section)))]]
    ;
    [[omp::directive (section)]]
    {}
  }
  [[omp::directive (barrier)]];
  [[using omp:sequence (omp::directive (single, private (p),firstprivate (f),allocate (f),nowait))]]
    ;
  [[omp::sequence (directive (barrier))]];
  [[using omp:sequence (directive (parallel, private (p)),
    omp::directive (single, copyprivate (p),firstprivate (f),allocate (f)))]]
    p = 6;
  [[omp::directive (target parallel,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread)
    nowait depend(inout: dd[0]),allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
    ;
  [[omp::directive (target parallel for,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),linear (ll:1),ordered schedule(static, 4),collapse(1),nowait depend(inout: dd[0]),
    allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[using omp:directive (target parallel for,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),linear (ll:1),schedule(static, 4),collapse(1),nowait depend(inout: dd[0]),order(concurrent),
    allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (target parallel for simd,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),linear (ll:1),schedule(static, 4),collapse(1),
    safelen(8),simdlen(4),aligned(q: 32),nowait depend(inout: dd[0]),nontemporal(ntm),if (simd: i3),order(concurrent),
    allocate (omp_default_mem_alloc:f),in_reduction(+:r2)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[using omp:sequence (directive (target teams,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),nowait, depend(inout: dd[0]),
    allocate (omp_default_mem_alloc:f) in_reduction(+:r2)))]]
    ;
  [[using omp:sequence (directive (target,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    nowait depend(inout: dd[0]),allocate (omp_default_mem_alloc:f),in_reduction(+:r2)))]]
    ;
  [[omp::sequence (omp::directive (target teams distribute,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),order(concurrent),
    collapse(1),dist_schedule(static, 16),nowait depend(inout: dd[0]),allocate (omp_default_mem_alloc:f),in_reduction(+:r2)))]]
  for (int i = 0; i < 64; i++)
    ;
  [[omp::directive (target teams distribute parallel for,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),nowait depend(inout: dd[0]),order(concurrent),
     allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target teams distribute parallel for simd,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),order(concurrent),
    safelen(8),simdlen(4),aligned(q: 32),nowait depend(inout: dd[0]),nontemporal(ntm),if (simd: i3),
    allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target teams distribute simd,
    device(d),map (tofrom: m),if (i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),order(concurrent),
    safelen(8),simdlen(4),aligned(q: 32),nowait depend(inout: dd[0]),nontemporal(ntm),
    allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (target simd,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    safelen(8),simdlen(4),lastprivate (l),linear(ll: 1),aligned(q: 32),reduction(+:r),
    nowait depend(inout: dd[0]),nontemporal(ntm),if(simd:i3),order(concurrent),
    allocate (omp_default_mem_alloc:f),in_reduction(+:r2))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup, task_reduction(+:r2), allocate (r2)),
    omp::directive (taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),if(simd: i2),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),in_reduction(+:r2),nontemporal(ntm),
    order(concurrent),allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[using omp:sequence (omp::directive (taskgroup, task_reduction(+:r), allocate (r)),
    directive (taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(i1),final(fi),mergeable,nogroup,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),in_reduction(+:r),nontemporal(ntm),
    order(concurrent),allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (taskwait)]];
  [[omp::directive (taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),if(taskloop: i1),final(fi),priority (pp)
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(+:r),if (simd: i3),nontemporal(ntm),
    order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup, task_reduction(+:r2), allocate (r2)),
    omp::directive (taskloop
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied, if(taskloop: i1),final(fi),mergeable, priority (pp),
    reduction(default, +:r),in_reduction(+:r2),allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup, task_reduction(+:r2),allocate (r2)),
    omp::directive (task,
    private (p),firstprivate (f),shared (s),default(shared),untied,if(task: i1),final(fi),mergeable,priority (pp),
    in_reduction(+:r2),allocate (f)))]]
    ;
  [[omp::directive (taskyield)]];
  [[omp::directive (target data, if (target data: i1),device(d),map (tofrom: m),use_device_ptr (q),use_device_addr (p))]]
  ;
  [[omp::directive (target enter data, if (target enter data: i1),device(d),map (to: m),depend(inout: dd[0]),nowait)]]
  ;
  [[omp::directive (target exit data, if (target exit data: i1),device(d),map (from: m),depend(inout: dd[0]),nowait)]]
  ;
  [[omp::directive (target update, if (target update: i1),device(d),to (m),depend(inout: dd[0]),nowait)]]
  ;
  [[omp::directive (target update, if (target update: i1),device(d),from (m),depend(inout: dd[0]),nowait)]]
  ;
  [[omp::directive (taskwait)]];
  [[omp::sequence (directive (target, nowait,depend(inout: dd[0]),in_reduction(+:r2)),
    directive (teams distribute,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),allocate (omp_default_mem_alloc: f),order(concurrent)))]]
  for (int i = 0; i < 64; i++)
    ;
  [[omp::directive (teams,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    allocate (omp_default_mem_alloc: f))]]
    ;
  [[omp::sequence (omp::directive (target),
    omp::directive (teams distribute parallel for,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),order(concurrent),allocate (omp_default_mem_alloc: f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[using omp:sequence (directive (target),
    directive (teams distribute parallel for simd,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),order(concurrent),
    safelen(8),simdlen(4),aligned(q: 32),if (simd: i3),nontemporal(ntm),
    allocate (omp_default_mem_alloc: f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (target),
    directive (teams distribute simd,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),order(concurrent),
    safelen(8),simdlen(4),aligned(q: 32),if(i3),nontemporal(ntm),
    allocate (omp_default_mem_alloc: f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),copyin(t),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),order(concurrent),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for simd,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),
    safelen(8),simdlen(4),aligned(q: 32),if (simd: i3),nontemporal(ntm),copyin(t),
    allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute parallel for simd,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),
    if (parallel: i2),num_threads (nth),proc_bind(spread),
    lastprivate (l),schedule(static, 4),order(concurrent),
    safelen(8),simdlen(4),aligned(q: 32),if (simd: i3),nontemporal(ntm),
    allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (teams distribute simd,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),dist_schedule(static, 16),order(concurrent),
    safelen(8),simdlen(4),aligned(q: 32),if(i3),nontemporal(ntm),allocate(f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),reduction(+:r),
    num_threads (nth),proc_bind(spread),copyin(t),allocate (f))]]
    ;
  [[omp::directive (parallel masked,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),reduction(+:r),
    num_threads (nth),proc_bind(spread),copyin(t),allocate (f),filter(d))]]
    ;
  [[omp::directive (parallel,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),reduction(+:r),
    num_threads (nth),proc_bind(spread),copyin(t),allocate (f))]]
    ;
  [[using omp:sequence (directive (taskgroup, task_reduction (+:r2),allocate (r2)),
    omp::directive (master taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied, if(taskloop: i1),final(fi),mergeable, priority (pp),
    reduction(default, +:r),in_reduction(+:r2),allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[using omp:sequence (directive (taskgroup, task_reduction (+:r2),allocate (r2)),
    omp::directive (masked taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied, if(taskloop: i1),final(fi),mergeable, priority (pp),
    reduction(default, +:r),in_reduction(+:r2),allocate (f),filter(d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[using omp:directive (master)]];
  [[using omp:directive (masked)]];
  [[using omp:directive (masked,filter(d))]];
  [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2),allocate (r2)),
    directive (master taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),if(simd: i2),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),in_reduction(+:r2),nontemporal(ntm),
    order(concurrent),allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup task_reduction (+:r2),allocate (r2)),
    directive (masked taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),if(simd: i2),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),in_reduction(+:r2),nontemporal(ntm),
    order(concurrent),allocate (f),filter(d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),final(fi),mergeable,priority (pp),
    reduction(default, +:r),if (parallel: i2),num_threads (nth),proc_bind(spread),copyin(t),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),final(fi),mergeable,priority (pp),
    reduction(default, +:r),if (parallel: i2),num_threads (nth),proc_bind(spread),copyin(t),allocate (f),filter(d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),if(simd: i2),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),nontemporal(ntm),if (parallel: i2),num_threads (nth),proc_bind(spread),copyin(t),
    order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),grainsize (g),collapse(1),untied,if(taskloop: i1),if(simd: i2),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),nontemporal(ntm),if (parallel: i2),num_threads (nth),proc_bind(spread),copyin(t),
    order(concurrent),allocate (f),filter(d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup,task_reduction (+:r2),allocate (r2)),
    directive (master taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied,if(i1),final(fi),mergeable,priority (pp),
    reduction(default, +:r),in_reduction(+:r2)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (directive (taskgroup,task_reduction (+:r2),allocate (r2)),
    directive (masked taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied,if(i1),final(fi),mergeable,priority (pp),
    reduction(default, +:r),in_reduction(+:r2),filter(d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup,task_reduction (+:r2),allocate (r2)),
    omp::directive (master taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied,if(i1),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),in_reduction(+:r2),nontemporal(ntm),
    order(concurrent),allocate (f)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::sequence (omp::directive (taskgroup,task_reduction (+:r2),allocate (r2)),
    omp::directive (masked taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied,if(i1),final(fi),mergeable,priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),in_reduction(+:r2),nontemporal(ntm),
    order(concurrent),allocate (f),filter(d)))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied if(i1),final(fi),mergeable priority (pp),
    reduction(default, +:r),num_threads (nth),proc_bind(spread),copyin(t),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied if(i1),final(fi),mergeable priority (pp),
    reduction(default, +:r),num_threads (nth),proc_bind(spread),copyin(t),allocate (f),filter(d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel master taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied if(i1),final(fi),mergeable priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),nontemporal(ntm),num_threads (nth),proc_bind(spread),copyin(t),
    order(concurrent),allocate (f))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (parallel masked taskloop simd,
    private (p),firstprivate (f),lastprivate (l),shared (s),default(shared),num_tasks (nta),collapse(1),untied if(i1),final(fi),mergeable priority (pp),
    safelen(8),simdlen(4),linear(ll: 1),aligned(q: 32),reduction(default, +:r),nontemporal(ntm),num_threads (nth),proc_bind(spread),copyin(t),
    order(concurrent),allocate (f),filter(d))]]
  for (int i = 0; i < 64; i++)
    ll++;
  [[omp::directive (loop, bind(thread),order(concurrent),
    private (p),lastprivate (l),collapse(1),reduction(+:r))]]
  for (l = 0; l < 64; ++l)
    ll++;
  [[omp::directive (parallel loop,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),copyin(t),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),collapse(1),bind(parallel),order(concurrent),allocate (f))]]
  for (l = 0; l < 64; l++)
    ll++;
  [[omp::directive (parallel loop,
    private (p),firstprivate (f),if (parallel: i2),default(shared),shared(s),copyin(t),reduction(+:r),num_threads (nth),proc_bind(spread),
    lastprivate (l),collapse(1),allocate (f))]]
  for (l = 0; l < 64; l++)
    ll++;
  [[omp::directive (teams loop,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),lastprivate (l),bind(teams),allocate (f))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (teams loop,
    private(p),firstprivate (f),shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),
    collapse(1),lastprivate (l),order(concurrent),allocate (f))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target parallel loop,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    nowait depend(inout: dd[0]),lastprivate (l),bind(parallel),order(concurrent),collapse(1),
    allocate (omp_default_mem_alloc: f),in_reduction(+:r2))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target parallel loop,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    if (parallel: i2),default(shared),shared(s),reduction(+:r),num_threads (nth),proc_bind(spread),
    nowait depend(inout: dd[0]),lastprivate (l),order(concurrent),collapse(1),
    allocate (omp_default_mem_alloc: f),in_reduction(+:r2))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target teams loop,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),nowait,depend(inout: dd[0]),
    lastprivate (l),bind(teams),collapse(1),
    allocate (omp_default_mem_alloc: f),in_reduction(+:r2))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (target teams loop,
    device(d),map (tofrom: m),if (target: i1),private (p),firstprivate (f),defaultmap(tofrom: scalar),is_device_ptr (idp),
    shared(s),default(shared),reduction(+:r),num_teams(nte),thread_limit(tl),nowait,depend(inout: dd[0]),
    lastprivate (l),order(concurrent),collapse(1)
    allocate (omp_default_mem_alloc: f),in_reduction(+:r2))]]
  for (l = 0; l < 64; ++l)
    ;
  [[omp::directive (critical)]] {
  }
  [[omp::directive (critical (foobar),hint(omp_sync_hint_none))]]
  ;
  [[using omp:directive (taskwait, depend (inout: dd[0]))]]
  ;
  [[omp::directive (taskgroup, task_reduction(+:r2),allocate (r2))]]
  ;
  [[omp::directive (atomic, update,seq_cst,hint(omp_sync_hint_none))]]
  p++;
  [[omp::directive (atomic, read, hint(omp_sync_hint_none),relaxed)]]
  f = p;
  [[omp::directive (atomic,write, release hint(omp_sync_hint_none))]]
  p = f;
  [[omp::directive (flush)]]
  ;
  [[omp::directive (flush, acq_rel)]]
  ;
  [[omp::directive (flush, acquire)]]
  ;
  [[omp::directive (flush, release)]]
  ;
  [[omp::directive (flush, seq_cst)]]
  ;
  [[omp::directive (flush (p, f))]]
  ;
  [[omp::directive (simd,
    private (p),lastprivate (l),linear (ll:1),reduction(+:r),collapse(1),safelen(8),simdlen(4),aligned(q: 32),
    nontemporal(ntm),if(i1))]]
  for (int i = 0; i < 64; i++)
    [[omp::directive (ordered, simd)]]
      ll++;
  [[omp::directive (for,
    private (p),firstprivate (f),lastprivate (l),linear (ll:1),reduction(+:r),schedule(static, 4),collapse(1),nowait,
    ordered, allocate (f))]]
  for (int i = 0; i < 64; i++)
    [[omp::directive (ordered, threads)]]
      ll++;
  [[omp::directive(for, ordered (1))]]
  for (l = 0; l < 64; l++)
    {
      [[omp::directive(ordered, depend (sink: l - 1))]];
      [[omp::directive(ordered, depend (source))]];
    }
  extern omp_depend_t depobj;
  [[omp::directive (depobj(depobj),depend(in : dd[0]))]];
  [[omp::directive (parallel)]] {
    if (p) {
      [[omp::directive (cancel, parallel)]];
    } else {
      [[omp::directive (cancellation point, parallel)]];
    }
  }
  [[omp::directive (scope, private (p), reduction(+:r), nowait)]]
    ;
  [[using omp:directive (scope, private (p), reduction(task, +:r))]]
    ;
  extern int t2;
  [[omp::directive (threadprivate (t2))]];
  extern int t2;
  [[omp::directive (declare reduction (dr: int: omp_out += omp_in),initializer (omp_priv = 0))]]
  ;
}

void corge1 ();

void
corge ()
{
  [[omp::directive (declare variant (corge1),match (construct={parallel,for}))]]
  extern void corge2 ();
  [[omp::sequence (directive (parallel), directive (for))]]
  for (int i = 0; i < 5; i++)
    corge2 ();
  [[omp::directive (declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch),
    omp::directive (declare simd,simdlen(8),notinbranch)]]
  extern int corge3 (int l, int *p);
  [[using omp:directive (declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch),
    directive (declare simd, simdlen(8),notinbranch)]]
  extern int corge4 (int l, int *p);
  [[omp::sequence (directive (declare simd, simdlen(4),linear(l),aligned(p:4),uniform(p),inbranch),
    omp::directive (declare simd, simdlen(8),notinbranch))]]
  extern int corge5 (int l, int *p);
  [[omp::directive (declare target)]];
  extern void corge6 ();
  [[omp::directive (end declare target)]];
}

int
garply (int a, int *c, int *d, int *e, int *f)
{
  int i;
  [[omp::directive (simd, reduction (inscan, +: a))]]
  for (i = 0; i < 64; i++)
    {
      d[i] = a;
      [[omp::directive (scan, exclusive (a))]]
      a += c[i];
    }
  [[omp::directive (simd, reduction (inscan, +: a))]]
  for (i = 0; i < 64; i++)
    {
      a += c[i];
      [[using omp : sequence (sequence (directive (scan inclusive (a))))]]
      d[i] = a;
    }
  return a;
}